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 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
1595 echo "configure:1596: checking for GNU make" >&5
1596 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
1597   echo $ac_n "(cached) $ac_c" 1>&6
1598 else
1599   _cv_gnu_make_command='' ;
1600           for a in "${MAKE:-make}" make gmake gnumake ; do
1601                   if  ( $a --version 2> /dev/null | grep  -q GNU  ) ;  then
1602                           _cv_gnu_make_command=$a ;
1603                           break;
1604                   fi
1605           done ;
1606
1607 fi
1608
1609 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
1610   if test  "x$_cv_gnu_make_command" != "x"  ; then
1611           ifGNUmake='' ;
1612   else
1613           ifGNUmake='#' ;
1614   fi
1615
1616
1617   if test "x$_cv_gnu_make_command" = "x"; then
1618     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
1619   fi
1620 # Check whether --enable-shared or --disable-shared was given.
1621 if test "${enable_shared+set}" = set; then
1622   enableval="$enable_shared"
1623   p=${PACKAGE-default}
1624 case "$enableval" in
1625 yes) enable_shared=yes ;;
1626 no) enable_shared=no ;;
1627 *)
1628   enable_shared=no
1629   # Look at the argument we got.  We use all the common list separators.
1630   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1631   for pkg in $enableval; do
1632     if test "X$pkg" = "X$p"; then
1633       enable_shared=yes
1634     fi
1635   done
1636   IFS="$ac_save_ifs"
1637   ;;
1638 esac
1639 else
1640   enable_shared=yes
1641 fi
1642
1643 # Check whether --enable-static or --disable-static was given.
1644 if test "${enable_static+set}" = set; then
1645   enableval="$enable_static"
1646   p=${PACKAGE-default}
1647 case "$enableval" in
1648 yes) enable_static=yes ;;
1649 no) enable_static=no ;;
1650 *)
1651   enable_static=no
1652   # Look at the argument we got.  We use all the common list separators.
1653   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1654   for pkg in $enableval; do
1655     if test "X$pkg" = "X$p"; then
1656       enable_static=yes
1657     fi
1658   done
1659   IFS="$ac_save_ifs"
1660   ;;
1661 esac
1662 else
1663   enable_static=yes
1664 fi
1665
1666 # Check whether --enable-fast-install or --disable-fast-install was given.
1667 if test "${enable_fast_install+set}" = set; then
1668   enableval="$enable_fast_install"
1669   p=${PACKAGE-default}
1670 case "$enableval" in
1671 yes) enable_fast_install=yes ;;
1672 no) enable_fast_install=no ;;
1673 *)
1674   enable_fast_install=no
1675   # Look at the argument we got.  We use all the common list separators.
1676   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1677   for pkg in $enableval; do
1678     if test "X$pkg" = "X$p"; then
1679       enable_fast_install=yes
1680     fi
1681   done
1682   IFS="$ac_save_ifs"
1683   ;;
1684 esac
1685 else
1686   enable_fast_install=yes
1687 fi
1688
1689 # Extract the first word of "ranlib", so it can be a program name with args.
1690 set dummy ranlib; ac_word=$2
1691 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1692 echo "configure:1693: checking for $ac_word" >&5
1693 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1694   echo $ac_n "(cached) $ac_c" 1>&6
1695 else
1696   if test -n "$RANLIB"; then
1697   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1698 else
1699   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1700   ac_dummy="$PATH"
1701   for ac_dir in $ac_dummy; do
1702     test -z "$ac_dir" && ac_dir=.
1703     if test -f $ac_dir/$ac_word; then
1704       ac_cv_prog_RANLIB="ranlib"
1705       break
1706     fi
1707   done
1708   IFS="$ac_save_ifs"
1709   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1710 fi
1711 fi
1712 RANLIB="$ac_cv_prog_RANLIB"
1713 if test -n "$RANLIB"; then
1714   echo "$ac_t""$RANLIB" 1>&6
1715 else
1716   echo "$ac_t""no" 1>&6
1717 fi
1718
1719 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1720 if test "${with_gnu_ld+set}" = set; then
1721   withval="$with_gnu_ld"
1722   test "$withval" = no || with_gnu_ld=yes
1723 else
1724   with_gnu_ld=no
1725 fi
1726
1727 ac_prog=ld
1728 if test "$ac_cv_prog_gcc" = yes; then
1729   # Check if gcc -print-prog-name=ld gives a path.
1730   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1731 echo "configure:1732: checking for ld used by GCC" >&5
1732   ac_prog=`($CC -print-prog-name=ld) 2>&5`
1733   case "$ac_prog" in
1734     # Accept absolute paths.
1735     [\\/]* | [A-Za-z]:[\\/]*)
1736       re_direlt='/[^/][^/]*/\.\./'
1737       # Canonicalize the path of ld
1738       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1739       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1740         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1741       done
1742       test -z "$LD" && LD="$ac_prog"
1743       ;;
1744   "")
1745     # If it fails, then pretend we aren't using GCC.
1746     ac_prog=ld
1747     ;;
1748   *)
1749     # If it is relative, then search for the first ld in PATH.
1750     with_gnu_ld=unknown
1751     ;;
1752   esac
1753 elif test "$with_gnu_ld" = yes; then
1754   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1755 echo "configure:1756: checking for GNU ld" >&5
1756 else
1757   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1758 echo "configure:1759: checking for non-GNU ld" >&5
1759 fi
1760 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1761   echo $ac_n "(cached) $ac_c" 1>&6
1762 else
1763   if test -z "$LD"; then
1764   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1765   for ac_dir in $PATH; do
1766     test -z "$ac_dir" && ac_dir=.
1767     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1768       ac_cv_path_LD="$ac_dir/$ac_prog"
1769       # Check to see if the program is GNU ld.  I'd rather use --version,
1770       # but apparently some GNU ld's only accept -v.
1771       # Break only if it was the GNU/non-GNU ld that we prefer.
1772       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1773         test "$with_gnu_ld" != no && break
1774       else
1775         test "$with_gnu_ld" != yes && break
1776       fi
1777     fi
1778   done
1779   IFS="$ac_save_ifs"
1780 else
1781   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1782 fi
1783 fi
1784
1785 LD="$ac_cv_path_LD"
1786 if test -n "$LD"; then
1787   echo "$ac_t""$LD" 1>&6
1788 else
1789   echo "$ac_t""no" 1>&6
1790 fi
1791 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1792 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1793 echo "configure:1794: checking if the linker ($LD) is GNU ld" >&5
1794 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1795   echo $ac_n "(cached) $ac_c" 1>&6
1796 else
1797   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1798 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1799   ac_cv_prog_gnu_ld=yes
1800 else
1801   ac_cv_prog_gnu_ld=no
1802 fi
1803 fi
1804
1805 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1806
1807
1808 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1809 echo "configure:1810: checking for BSD-compatible nm" >&5
1810 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1811   echo $ac_n "(cached) $ac_c" 1>&6
1812 else
1813   if test -n "$NM"; then
1814   # Let the user override the test.
1815   ac_cv_path_NM="$NM"
1816 else
1817   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1818   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1819     test -z "$ac_dir" && ac_dir=.
1820     if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
1821       # Check to see if the nm accepts a BSD-compat flag.
1822       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1823       #   nm: unknown option "B" ignored
1824       if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1825         ac_cv_path_NM="$ac_dir/nm -B"
1826         break
1827       elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1828         ac_cv_path_NM="$ac_dir/nm -p"
1829         break
1830       else
1831         ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
1832         continue # so that we can try to find one that supports BSD flags
1833       fi
1834     fi
1835   done
1836   IFS="$ac_save_ifs"
1837   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1838 fi
1839 fi
1840
1841 NM="$ac_cv_path_NM"
1842 echo "$ac_t""$NM" 1>&6
1843
1844 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1845 echo "configure:1846: checking whether ln -s works" >&5
1846 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1847   echo $ac_n "(cached) $ac_c" 1>&6
1848 else
1849   rm -f conftestdata
1850 if ln -s X conftestdata 2>/dev/null
1851 then
1852   rm -f conftestdata
1853   ac_cv_prog_LN_S="ln -s"
1854 else
1855   ac_cv_prog_LN_S=ln
1856 fi
1857 fi
1858 LN_S="$ac_cv_prog_LN_S"
1859 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1860   echo "$ac_t""yes" 1>&6
1861 else
1862   echo "$ac_t""no" 1>&6
1863 fi
1864
1865
1866 # Check for any special flags to pass to ltconfig.
1867 libtool_flags="--cache-file=$cache_file"
1868 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
1869 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
1870 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
1871 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
1872 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
1873 libtool_flags="$libtool_flags --enable-dlopen"
1874
1875 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
1876 if test "${enable_libtool_lock+set}" = set; then
1877   enableval="$enable_libtool_lock"
1878   :
1879 fi
1880
1881 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
1882 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
1883
1884 # Some flags need to be propagated to the compiler or linker for good
1885 # libtool support.
1886 case "$host" in
1887 *-*-irix6*)
1888   # Find out which ABI we are using.
1889   echo '#line 1890 "configure"' > conftest.$ac_ext
1890   if { (eval echo configure:1891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1891     case "`/usr/bin/file conftest.o`" in
1892     *32-bit*)
1893       LD="${LD-ld} -32"
1894       ;;
1895     *N32*)
1896       LD="${LD-ld} -n32"
1897       ;;
1898     *64-bit*)
1899       LD="${LD-ld} -64"
1900       ;;
1901     esac
1902   fi
1903   rm -rf conftest*
1904   ;;
1905
1906 *-*-sco3.2v5*)
1907   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
1908   SAVE_CFLAGS="$CFLAGS"
1909   CFLAGS="$CFLAGS -belf"
1910   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
1911 echo "configure:1912: checking whether the C compiler needs -belf" >&5
1912 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
1913   echo $ac_n "(cached) $ac_c" 1>&6
1914 else
1915   cat > conftest.$ac_ext <<EOF
1916 #line 1917 "configure"
1917 #include "confdefs.h"
1918
1919 int main() {
1920
1921 ; return 0; }
1922 EOF
1923 if { (eval echo configure:1924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1924   rm -rf conftest*
1925   lt_cv_cc_needs_belf=yes
1926 else
1927   echo "configure: failed program was:" >&5
1928   cat conftest.$ac_ext >&5
1929   rm -rf conftest*
1930   lt_cv_cc_needs_belf=no
1931 fi
1932 rm -f conftest*
1933 fi
1934
1935 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
1936   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
1937     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
1938     CFLAGS="$SAVE_CFLAGS"
1939   fi
1940   ;;
1941
1942
1943 esac
1944
1945
1946 # Save cache, so that ltconfig can load it
1947 cat > confcache <<\EOF
1948 # This file is a shell script that caches the results of configure
1949 # tests run on this system so they can be shared between configure
1950 # scripts and configure runs.  It is not useful on other systems.
1951 # If it contains results you don't want to keep, you may remove or edit it.
1952 #
1953 # By default, configure uses ./config.cache as the cache file,
1954 # creating it if it does not exist already.  You can give configure
1955 # the --cache-file=FILE option to use a different cache file; that is
1956 # what configure does when it calls configure scripts in
1957 # subdirectories, so they share the cache.
1958 # Giving --cache-file=/dev/null disables caching, for debugging configure.
1959 # config.status only pays attention to the cache file if you give it the
1960 # --recheck option to rerun configure.
1961 #
1962 EOF
1963 # The following way of writing the cache mishandles newlines in values,
1964 # but we know of no workaround that is simple, portable, and efficient.
1965 # So, don't put newlines in cache variables' values.
1966 # Ultrix sh set writes to stderr and can't be redirected directly,
1967 # and sets the high bit in the cache file unless we assign to the vars.
1968 (set) 2>&1 |
1969   case `(ac_space=' '; set | grep ac_space) 2>&1` in
1970   *ac_space=\ *)
1971     # `set' does not quote correctly, so add quotes (double-quote substitution
1972     # turns \\\\ into \\, and sed turns \\ into \).
1973     sed -n \
1974       -e "s/'/'\\\\''/g" \
1975       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
1976     ;;
1977   *)
1978     # `set' quotes correctly as required by POSIX, so do not add quotes.
1979     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
1980     ;;
1981   esac >> confcache
1982 if cmp -s $cache_file confcache; then
1983   :
1984 else
1985   if test -w $cache_file; then
1986     echo "updating cache $cache_file"
1987     cat confcache > $cache_file
1988   else
1989     echo "not updating unwritable cache $cache_file"
1990   fi
1991 fi
1992 rm -f confcache
1993
1994
1995 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
1996 CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
1997 LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
1998 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
1999 DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
2000 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2001 $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
2002 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2003
2004 # Reload cache, that may have been modified by ltconfig
2005 if test -r "$cache_file"; then
2006   echo "loading cache $cache_file"
2007   . $cache_file
2008 else
2009   echo "creating cache $cache_file"
2010   > $cache_file
2011 fi
2012
2013
2014 # This can be used to rebuild libtool when needed
2015 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
2016
2017 # Always use our own libtool.
2018 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2019
2020 # Redirect the config.log output again, so that the ltconfig log is not
2021 # clobbered by the next message.
2022 exec 5>>./config.log
2023
2024
2025
2026
2027
2028 # Check for c++ or library specific bits that don't require linking.
2029 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2030 echo "configure:2031: checking how to run the C preprocessor" >&5
2031 # On Suns, sometimes $CPP names a directory.
2032 if test -n "$CPP" && test -d "$CPP"; then
2033   CPP=
2034 fi
2035 if test -z "$CPP"; then
2036 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2037   echo $ac_n "(cached) $ac_c" 1>&6
2038 else
2039     # This must be in double quotes, not single quotes, because CPP may get
2040   # substituted into the Makefile and "${CC-cc}" will confuse make.
2041   CPP="${CC-cc} -E"
2042   # On the NeXT, cc -E runs the code through the compiler's parser,
2043   # not just through cpp.
2044   cat > conftest.$ac_ext <<EOF
2045 #line 2046 "configure"
2046 #include "confdefs.h"
2047 #include <assert.h>
2048 Syntax Error
2049 EOF
2050 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2051 { (eval echo configure:2052: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2052 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2053 if test -z "$ac_err"; then
2054   :
2055 else
2056   echo "$ac_err" >&5
2057   echo "configure: failed program was:" >&5
2058   cat conftest.$ac_ext >&5
2059   rm -rf conftest*
2060   CPP="${CC-cc} -E -traditional-cpp"
2061   cat > conftest.$ac_ext <<EOF
2062 #line 2063 "configure"
2063 #include "confdefs.h"
2064 #include <assert.h>
2065 Syntax Error
2066 EOF
2067 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2068 { (eval echo configure:2069: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2069 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2070 if test -z "$ac_err"; then
2071   :
2072 else
2073   echo "$ac_err" >&5
2074   echo "configure: failed program was:" >&5
2075   cat conftest.$ac_ext >&5
2076   rm -rf conftest*
2077   CPP="${CC-cc} -nologo -E"
2078   cat > conftest.$ac_ext <<EOF
2079 #line 2080 "configure"
2080 #include "confdefs.h"
2081 #include <assert.h>
2082 Syntax Error
2083 EOF
2084 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2085 { (eval echo configure:2086: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2086 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2087 if test -z "$ac_err"; then
2088   :
2089 else
2090   echo "$ac_err" >&5
2091   echo "configure: failed program was:" >&5
2092   cat conftest.$ac_ext >&5
2093   rm -rf conftest*
2094   CPP=/lib/cpp
2095 fi
2096 rm -f conftest*
2097 fi
2098 rm -f conftest*
2099 fi
2100 rm -f conftest*
2101   ac_cv_prog_CPP="$CPP"
2102 fi
2103   CPP="$ac_cv_prog_CPP"
2104 else
2105   ac_cv_prog_CPP="$CPP"
2106 fi
2107 echo "$ac_t""$CPP" 1>&6
2108
2109
2110   # Sanity check that g++ is capable of dealing with v-3.
2111   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2112 echo "configure:2113: checking for g++ that will successfully compile this code" >&5
2113   cat > conftest.$ac_ext <<EOF
2114 #line 2115 "configure"
2115 #include "confdefs.h"
2116
2117   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2118     ok
2119   #endif
2120
2121 EOF
2122 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2123   egrep "ok" >/dev/null 2>&1; then
2124   rm -rf conftest*
2125   gpp_satisfactory=yes
2126 else
2127   rm -rf conftest*
2128   { echo "configure: error: "please upgrade to gcc-2.95 or above"" 1>&2; exit 1; }
2129 fi
2130 rm -f conftest*
2131
2132   echo "$ac_t""$gpp_satisfactory" 1>&6
2133
2134
2135     echo $ac_n "checking for cpu primitives directory""... $ac_c" 1>&6
2136 echo "configure:2137: checking for cpu primitives directory" >&5
2137     CPU_FLAGS=
2138     case "$target_cpu" in
2139       alpha*)
2140         cpu_include_dir="config/cpu/alpha"
2141         ;;
2142       arm*)
2143         cpu_include_dir="config/cpu/arm"
2144         ;;
2145       i386)
2146         cpu_include_dir="config/cpu/i386"
2147         ;;
2148       i486 | i586 | i686 | i786)
2149         cpu_include_dir="config/cpu/i486"
2150         ;;
2151       powerpc | rs6000)
2152         cpu_include_dir="config/cpu/powerpc"
2153         CPU_FLAGS='-mcpu=powerpc'
2154         ;;
2155       sparc64 | ultrasparc)
2156         cpu_include_dir="config/cpu/sparc/sparc64"
2157         ;;
2158       sparc*)
2159         cpu_include_dir="config/cpu/sparc/sparc32"
2160         ;;
2161       *)
2162         cpu_include_dir="config/cpu/generic"
2163         ;;
2164     esac
2165     echo "$ac_t""$cpu_include_dir" 1>&6
2166
2167
2168
2169
2170 # Enable all the crazy c++ stuff.
2171 # Check whether --enable-debug or --disable-debug was given.
2172 if test "${enable_debug+set}" = set; then
2173   enableval="$enable_debug"
2174   case "$enableval" in
2175  yes) enable_debug=yes ;;
2176  no)  enable_debug=no ;;
2177  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2178  esac
2179 else
2180   enable_debug=no
2181 fi
2182 case "$enable_debug" in
2183     yes)
2184         DEBUG_FLAGS='-O0 -ggdb'
2185         ;;
2186     no)
2187         DEBUG_FLAGS='-g'
2188         ;;
2189 esac
2190
2191
2192
2193   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2194 echo "configure:2195: checking for cstdio to use" >&5
2195   # Check whether --enable-cstdio or --disable-cstdio was given.
2196 if test "${enable_cstdio+set}" = set; then
2197   enableval="$enable_cstdio"
2198   if test x$enable_cstdio = xno; then
2199     enable_cstdio=libio
2200   fi
2201 else
2202   enable_cstdio=libio
2203 fi
2204
2205
2206   enable_cstdio_flag=$enable_cstdio
2207
2208     case x${enable_cstdio_flag} in
2209     xlibio | x | xno | xnone | xyes)
2210       # default
2211       CSTDIO_H=config/c_io_libio.h
2212       CSTDIO_CC=config/c_io_libio.cc
2213       echo "$ac_t""libio" 1>&6
2214
2215       # see if we are on a system with libio native (ie, linux)
2216       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2217 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2218 echo "configure:2219: checking for libio.h" >&5
2219 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2220   echo $ac_n "(cached) $ac_c" 1>&6
2221 else
2222   cat > conftest.$ac_ext <<EOF
2223 #line 2224 "configure"
2224 #include "confdefs.h"
2225 #include <libio.h>
2226 EOF
2227 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2228 { (eval echo configure:2229: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2229 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2230 if test -z "$ac_err"; then
2231   rm -rf conftest*
2232   eval "ac_cv_header_$ac_safe=yes"
2233 else
2234   echo "$ac_err" >&5
2235   echo "configure: failed program was:" >&5
2236   cat conftest.$ac_ext >&5
2237   rm -rf conftest*
2238   eval "ac_cv_header_$ac_safe=no"
2239 fi
2240 rm -f conftest*
2241 fi
2242 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2243   echo "$ac_t""yes" 1>&6
2244   has_libio=yes
2245 else
2246   echo "$ac_t""no" 1>&6
2247 has_libio=no
2248 fi
2249
2250
2251       # Need to check and see what version of glibc is being used. If
2252       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2253       # compile most of libio for linux systems.
2254       if test x$has_libio = x"yes"; then
2255         case "$target" in
2256           *-*-linux*)
2257             echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2258 echo "configure:2259: checking for glibc version >= 2.2" >&5
2259             cat > conftest.$ac_ext <<EOF
2260 #line 2261 "configure"
2261 #include "confdefs.h"
2262
2263             #include <features.h>
2264             #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2265                 ok
2266             #endif
2267
2268 EOF
2269 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2270   egrep "ok" >/dev/null 2>&1; then
2271   rm -rf conftest*
2272   glibc_satisfactory=yes
2273 else
2274   rm -rf conftest*
2275   glibc_satisfactory=no
2276 fi
2277 rm -f conftest*
2278
2279             echo "$ac_t""$glibc_satisfactory" 1>&6
2280             ;;
2281         esac
2282
2283         if test x$glibc_satisfactory = x"yes"; then
2284           need_libio=no
2285           need_xtra_libio=no
2286           need_wlibio=no
2287         else
2288           need_libio=yes
2289           need_xtra_libio=yes
2290           # bkoz XXX need to add checks to enable this
2291           need_wlibio=yes
2292         fi
2293
2294       # Using libio, but <libio.h> doesn't exist on the target system. . .
2295       else
2296         need_libio=yes
2297         need_xtra_libio=no
2298         # bkoz XXX need to add checks to enable this
2299         need_wlibio=no
2300       fi
2301       ;;
2302
2303     xwince)
2304       CSTDIO_H=config/c_io_wince.h
2305       CSTDIO_CC=config/c_io_wince.cc
2306       echo "$ac_t""wince" 1>&6
2307
2308       need_libio=no
2309       ;;
2310     *)
2311       echo "$enable_cstdio is an unknown io package" 1>&2
2312       exit 1
2313       ;;
2314   esac
2315
2316
2317
2318
2319 if test "$need_libio" = yes; then
2320   GLIBCPP_NEED_LIBIO_TRUE=
2321   GLIBCPP_NEED_LIBIO_FALSE='#'
2322 else
2323   GLIBCPP_NEED_LIBIO_TRUE='#'
2324   GLIBCPP_NEED_LIBIO_FALSE=
2325 fi
2326
2327
2328 if test "$need_xtra_libio" = yes; then
2329   GLIBCPP_NEED_XTRA_LIBIO_TRUE=
2330   GLIBCPP_NEED_XTRA_LIBIO_FALSE='#'
2331 else
2332   GLIBCPP_NEED_XTRA_LIBIO_TRUE='#'
2333   GLIBCPP_NEED_XTRA_LIBIO_FALSE=
2334 fi
2335
2336
2337 if test "$need_wlibio" = yes; then
2338   GLIBCPP_NEED_WLIBIO_TRUE=
2339   GLIBCPP_NEED_WLIBIO_FALSE='#'
2340 else
2341   GLIBCPP_NEED_WLIBIO_TRUE='#'
2342   GLIBCPP_NEED_WLIBIO_FALSE=
2343 fi
2344
2345
2346   # Check whether --enable-long-long or --disable-long-long was given.
2347 if test "${enable_long_long+set}" = set; then
2348   enableval="$enable_long_long"
2349     case "$enableval" in
2350    yes) enable_long_long=yes ;;
2351    no)  enable_long_long=no ;;
2352    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2353    esac
2354 else
2355   enable_long_long=yes
2356 fi
2357
2358   # Check for the existance of functions used if long long is enabled.
2359   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2360 echo "configure:2361: checking for strtoll" >&5
2361 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2362   echo $ac_n "(cached) $ac_c" 1>&6
2363 else
2364   cat > conftest.$ac_ext <<EOF
2365 #line 2366 "configure"
2366 #include "confdefs.h"
2367 /* System header to define __stub macros and hopefully few prototypes,
2368     which can conflict with char strtoll(); below.  */
2369 #include <assert.h>
2370 /* Override any gcc2 internal prototype to avoid an error.  */
2371 /* We use char because int might match the return type of a gcc2
2372     builtin and then its argument prototype would still apply.  */
2373 char strtoll();
2374
2375 int main() {
2376
2377 /* The GNU C library defines this for functions which it implements
2378     to always fail with ENOSYS.  Some functions are actually named
2379     something starting with __ and the normal name is an alias.  */
2380 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2381 choke me
2382 #else
2383 strtoll();
2384 #endif
2385
2386 ; return 0; }
2387 EOF
2388 if { (eval echo configure:2389: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2389   rm -rf conftest*
2390   eval "ac_cv_func_strtoll=yes"
2391 else
2392   echo "configure: failed program was:" >&5
2393   cat conftest.$ac_ext >&5
2394   rm -rf conftest*
2395   eval "ac_cv_func_strtoll=no"
2396 fi
2397 rm -f conftest*
2398 fi
2399
2400 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2401   echo "$ac_t""yes" 1>&6
2402   :
2403 else
2404   echo "$ac_t""no" 1>&6
2405 ac_strtoll=no
2406 fi
2407
2408   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2409 echo "configure:2410: checking for strtoull" >&5
2410 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2411   echo $ac_n "(cached) $ac_c" 1>&6
2412 else
2413   cat > conftest.$ac_ext <<EOF
2414 #line 2415 "configure"
2415 #include "confdefs.h"
2416 /* System header to define __stub macros and hopefully few prototypes,
2417     which can conflict with char strtoull(); below.  */
2418 #include <assert.h>
2419 /* Override any gcc2 internal prototype to avoid an error.  */
2420 /* We use char because int might match the return type of a gcc2
2421     builtin and then its argument prototype would still apply.  */
2422 char strtoull();
2423
2424 int main() {
2425
2426 /* The GNU C library defines this for functions which it implements
2427     to always fail with ENOSYS.  Some functions are actually named
2428     something starting with __ and the normal name is an alias.  */
2429 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2430 choke me
2431 #else
2432 strtoull();
2433 #endif
2434
2435 ; return 0; }
2436 EOF
2437 if { (eval echo configure:2438: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2438   rm -rf conftest*
2439   eval "ac_cv_func_strtoull=yes"
2440 else
2441   echo "configure: failed program was:" >&5
2442   cat conftest.$ac_ext >&5
2443   rm -rf conftest*
2444   eval "ac_cv_func_strtoull=no"
2445 fi
2446 rm -f conftest*
2447 fi
2448
2449 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2450   echo "$ac_t""yes" 1>&6
2451   :
2452 else
2453   echo "$ac_t""no" 1>&6
2454 ac_strtoull=no
2455 fi
2456
2457
2458   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2459 echo "configure:2460: checking for enabled long long" >&5
2460   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2461     enable_long_long=no;
2462   fi;
2463   echo "$ac_t""$enable_long_long" 1>&6
2464
2465     case "$enable_long_long" in
2466     yes)  cat >> confdefs.h <<\EOF
2467 #define _GLIBCPP_USE_LONG_LONG 1
2468 EOF
2469
2470           ;;
2471   esac
2472
2473 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2474 echo "configure:2475: checking for enabled cshadow headers" >&5
2475 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2476 if test "${enable_cshadow_headers+set}" = set; then
2477   enableval="$enable_cshadow_headers"
2478   case "$enableval" in
2479  yes) enable_cshadow_headers=yes
2480         ;;
2481  no)  enable_cshadow_headers=no
2482         ;;
2483  *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
2484         ;;
2485  esac
2486 else
2487   enable_cshadow_headers=no
2488 fi
2489 echo "$ac_t""$enable_cshadow_headers" 1>&6
2490 case "$enable_cshadow_headers" in
2491     yes)
2492         CSHADOWFLAGS=""
2493         ;;
2494     no)
2495         CSHADOWFLAGS=""
2496         ;;
2497 esac
2498
2499
2500
2501
2502 if test "$enable_cshadow_headers" = yes; then
2503   GLIBCPP_USE_CSHADOW_TRUE=
2504   GLIBCPP_USE_CSHADOW_FALSE='#'
2505 else
2506   GLIBCPP_USE_CSHADOW_TRUE='#'
2507   GLIBCPP_USE_CSHADOW_FALSE=
2508 fi
2509
2510
2511       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
2512 echo "configure:2513: checking for threads package to use" >&5
2513   # Check whether --enable-threads or --disable-threads was given.
2514 if test "${enable_threads+set}" = set; then
2515   enableval="$enable_threads"
2516   if test x$enable_threads = xno; then
2517     enable_threads=''
2518   fi
2519 else
2520   enable_threads=''
2521 fi
2522
2523
2524   enable_threads_flag=$enable_threads
2525
2526     case x${enable_threads_flag} in
2527         x | xno | xnone)
2528                 # No threads
2529                 target_thread_file='single'
2530                 ;;
2531         xyes)
2532                 # default
2533                 target_thread_file=''
2534                 ;;
2535         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
2536         xsolaris | xwin32 | xdce | xvxworks)
2537                 target_thread_file=$enable_threads_flag
2538                 ;;
2539         *)
2540                 echo "$enable_threads is an unknown thread package" 1>&2
2541                 exit 1
2542                 ;;
2543   esac
2544
2545     case "$target_thread_file" in
2546     no | none | single)
2547       THREADS=none
2548       ;;
2549     posix | pthreads)
2550       THREADS=posix
2551       case "$target" in
2552         *-*-linux*)
2553         ;;
2554       esac
2555       ;;
2556     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
2557       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
2558       ;;
2559     *)
2560       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
2561       ;;
2562   esac
2563   echo "$ac_t""$THREADS" 1>&6
2564
2565   THREADLIBS=
2566   THREADINCS=
2567   THREADDEPS=
2568   THREADOBJS=
2569   THREADH=
2570   THREADSPEC=
2571   case "$THREADS" in
2572     posix)
2573       ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
2574 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
2575 echo "configure:2576: checking for pthread.h" >&5
2576 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2577   echo $ac_n "(cached) $ac_c" 1>&6
2578 else
2579   cat > conftest.$ac_ext <<EOF
2580 #line 2581 "configure"
2581 #include "confdefs.h"
2582 #include <pthread.h>
2583 EOF
2584 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2585 { (eval echo configure:2586: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2586 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2587 if test -z "$ac_err"; then
2588   rm -rf conftest*
2589   eval "ac_cv_header_$ac_safe=yes"
2590 else
2591   echo "$ac_err" >&5
2592   echo "configure: failed program was:" >&5
2593   cat conftest.$ac_ext >&5
2594   rm -rf conftest*
2595   eval "ac_cv_header_$ac_safe=no"
2596 fi
2597 rm -f conftest*
2598 fi
2599 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2600   echo "$ac_t""yes" 1>&6
2601   have_pthread_h=yes
2602 else
2603   echo "$ac_t""no" 1>&6
2604 have_pthread_h=
2605 fi
2606
2607       THREADLIBS=-lpthread
2608       THREADSPEC=-lpthread
2609                   THREADH=threads-posix.h
2610       ;;
2611     none)
2612                   THREADH=threads-no.h
2613       ;;
2614   esac
2615
2616
2617
2618
2619
2620
2621
2622 #GLIBCPP_ENABLE_RELIBGCC([../..])
2623 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
2624 if test "${enable_cxx_flags+set}" = set; then
2625   enableval="$enable_cxx_flags"
2626   case "x$enableval" in
2627  xyes)   { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
2628  xno|x)  enable_cxx_flags='' ;;
2629  *)      enable_cxx_flags="$enableval" ;;
2630  esac
2631 else
2632   enable_cxx_flags='none'
2633 fi
2634 if test "$enable_cxx_flags" = "none"; then enable_cxx_flags=''; fi
2635 if test -n "$enable_cxx_flags"; then
2636     for f in $enable_cxx_flags; do
2637         case "$f" in
2638             -fhonor-std)  ;;
2639             -*)  ;;
2640             *)   # and we're trying to pass /what/ exactly?
2641                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
2642         esac
2643     done
2644 fi
2645 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2646
2647
2648
2649
2650 if test -n "$with_cross_host"; then
2651
2652   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
2653   # may not work correctly, because the compiler may not be able to
2654   # link executables.
2655
2656   xcompiling=1
2657   NATIVE=no
2658   # If Canadian cross, then don't pick up tools from the build
2659   # directory.
2660   if test "$build" != "$with_cross_host"; then
2661     CANADIAN=yes
2662     NULL_TARGET=yes
2663   else
2664     CANADIAN=no
2665     NULL_TARGET=no
2666   fi
2667
2668   case "$target_alias" in
2669     *-wince-*)
2670         # Configure for Microsoft Windows CE, or whatever they are
2671         # currently calling it.
2672         cat >> confdefs.h <<\EOF
2673 #define HAVE_FLOAT_H 1
2674 EOF
2675
2676
2677         cat >> confdefs.h <<\EOF
2678 #define HAVE__FINITE 1
2679 EOF
2680
2681         cat >> confdefs.h <<\EOF
2682 #define HAVE__ISNAN 1
2683 EOF
2684
2685         cat >> confdefs.h <<\EOF
2686 #define HAVE__COPYSIGN 1
2687 EOF
2688
2689         cat >> confdefs.h <<\EOF
2690 #define HAVE__FPCLASS 1
2691 EOF
2692
2693         cat >> confdefs.h <<\EOF
2694 #define HAVE_MODF 1
2695 EOF
2696
2697
2698         ctype_include_dir="config/wince"
2699
2700
2701         cat >> confdefs.h <<\EOF
2702 #define _GLIBCPP_NEED_MBSTATE_T 1
2703 EOF
2704
2705
2706         cat >> confdefs.h <<\EOF
2707 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2708 EOF
2709
2710         cat >> confdefs.h <<\EOF
2711 #define _GLIBCPP_BUGGY_COMPLEX 1
2712 EOF
2713
2714         ;;
2715     *)
2716         # We assume newlib.  This lets us hard-code the functions we know
2717         # we'll have.
2718         cat >> confdefs.h <<\EOF
2719 #define HAVE_FINITE 1
2720 EOF
2721
2722         cat >> confdefs.h <<\EOF
2723 #define HAVE_ISNAN 1
2724 EOF
2725
2726         cat >> confdefs.h <<\EOF
2727 #define HAVE_ISNANF 1
2728 EOF
2729
2730         cat >> confdefs.h <<\EOF
2731 #define HAVE_ISINF 1
2732 EOF
2733
2734         cat >> confdefs.h <<\EOF
2735 #define HAVE_ISINFF 1
2736 EOF
2737
2738
2739         ctype_include_dir="config/newlib"
2740
2741
2742         cat >> confdefs.h <<\EOF
2743 #define _GLIBCPP_NEED_MBSTATE_T 1
2744 EOF
2745
2746
2747         cat >> confdefs.h <<\EOF
2748 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2749 EOF
2750
2751         cat >> confdefs.h <<\EOF
2752 #define _GLIBCPP_BUGGY_COMPLEX 1
2753 EOF
2754
2755         # need to ceck for faster f versions of math functions, ie sinf?
2756         ;;
2757   esac
2758 else
2759
2760   # We are being configured natively. We can do more elaborate tests
2761   # that include AC_TRY_COMPILE now, as the linker is assumed to be
2762   # working.
2763
2764   xcompiling=0
2765   NATIVE=yes
2766   CANADIAN=no
2767   NULL_TARGET=no
2768
2769   # Check for available headers.
2770   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
2771   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h
2772 do
2773 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
2774 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
2775 echo "configure:2776: checking for $ac_hdr" >&5
2776 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2777   echo $ac_n "(cached) $ac_c" 1>&6
2778 else
2779   cat > conftest.$ac_ext <<EOF
2780 #line 2781 "configure"
2781 #include "confdefs.h"
2782 #include <$ac_hdr>
2783 EOF
2784 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2785 { (eval echo configure:2786: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2786 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2787 if test -z "$ac_err"; then
2788   rm -rf conftest*
2789   eval "ac_cv_header_$ac_safe=yes"
2790 else
2791   echo "$ac_err" >&5
2792   echo "configure: failed program was:" >&5
2793   cat conftest.$ac_ext >&5
2794   rm -rf conftest*
2795   eval "ac_cv_header_$ac_safe=no"
2796 fi
2797 rm -f conftest*
2798 fi
2799 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2800   echo "$ac_t""yes" 1>&6
2801     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
2802   cat >> confdefs.h <<EOF
2803 #define $ac_tr_hdr 1
2804 EOF
2805
2806 else
2807   echo "$ac_t""no" 1>&6
2808 fi
2809 done
2810
2811
2812
2813   # All these tests are for C++; save the language and the compiler flags.
2814   # The CXXFLAGS thing is suspicious, but based on similar bits
2815   # found in GLIBCPP_CONFIGURE.
2816
2817   ac_ext=C
2818 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2819 ac_cpp='$CXXCPP $CPPFLAGS'
2820 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2821 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2822 cross_compiling=$ac_cv_prog_cxx_cross
2823
2824   ac_test_CXXFLAGS="${CXXFLAGS+set}"
2825   ac_save_CXXFLAGS="$CXXFLAGS"
2826   WERROR='-Werror'
2827
2828   # Check for pragma system_header.
2829   echo $ac_n "checking for g++ that supports pragma system_header""... $ac_c" 1>&6
2830 echo "configure:2831: checking for g++ that supports pragma system_header" >&5
2831   CXXFLAGS='-Wunknown-pragmas -Werror'
2832   cat > conftest.$ac_ext <<EOF
2833 #line 2834 "configure"
2834 #include "confdefs.h"
2835 #pragma GCC system_header
2836 int main() {
2837 int foo;
2838
2839 ; return 0; }
2840 EOF
2841 if { (eval echo configure:2842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2842   rm -rf conftest*
2843   ac_newpragma=yes
2844 else
2845   echo "configure: failed program was:" >&5
2846   cat conftest.$ac_ext >&5
2847   rm -rf conftest*
2848   ac_newpragma=no
2849 fi
2850 rm -f conftest*
2851   if test "$ac_test_CXXFLAGS" = set; then
2852     CXXFLAGS="$ac_save_CXXFLAGS"
2853   else
2854     # this is the suspicious part
2855     CXXFLAGS=''
2856   fi
2857   if test "$ac_newpragma" = "no"; then
2858     WERROR="$WERROR -Wno-unknown-pragmas"
2859   fi
2860   echo "$ac_t""$ac_newpragma" 1>&6
2861
2862   # Check for more sophisticated diagnostic control.
2863   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
2864 echo "configure:2865: checking for g++ that supports -fdiagnostics-show-location=once" >&5
2865   CXXFLAGS='-fdiagnostics-show-location=once'
2866   cat > conftest.$ac_ext <<EOF
2867 #line 2868 "configure"
2868 #include "confdefs.h"
2869
2870 int main() {
2871 int foo;
2872
2873 ; return 0; }
2874 EOF
2875 if { (eval echo configure:2876: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2876   rm -rf conftest*
2877   ac_gabydiags=yes
2878 else
2879   echo "configure: failed program was:" >&5
2880   cat conftest.$ac_ext >&5
2881   rm -rf conftest*
2882   ac_gabydiags=no
2883 fi
2884 rm -f conftest*
2885   if test "$ac_test_CXXFLAGS" = set; then
2886     CXXFLAGS="$ac_save_CXXFLAGS"
2887   else
2888     # this is the suspicious part
2889     CXXFLAGS=''
2890   fi
2891   if test "$ac_gabydiags" = "yes"; then
2892     WFMT_FLAGS='-fdiagnostics-show-location=once'
2893   fi
2894   echo "$ac_t""$ac_gabydiags" 1>&6
2895
2896   # Check for -ffunction-sections -fdata-sections
2897   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
2898 echo "configure:2899: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
2899   CXXFLAGS='-ffunction-sections -fdata-sections'
2900   cat > conftest.$ac_ext <<EOF
2901 #line 2902 "configure"
2902 #include "confdefs.h"
2903
2904 int main() {
2905 int foo;
2906
2907 ; return 0; }
2908 EOF
2909 if { (eval echo configure:2910: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2910   rm -rf conftest*
2911   ac_fdsections=yes
2912 else
2913   echo "configure: failed program was:" >&5
2914   cat conftest.$ac_ext >&5
2915   rm -rf conftest*
2916   ac_fdsections=no
2917 fi
2918 rm -f conftest*
2919   if test "$ac_test_CXXFLAGS" = set; then
2920     CXXFLAGS="$ac_save_CXXFLAGS"
2921   else
2922     # this is the suspicious part
2923     CXXFLAGS=''
2924   fi
2925   if test "$ac_fdsections" = "yes"; then
2926     SECTION_FLAGS='-ffunction-sections -fdata-sections'
2927   fi
2928   echo "$ac_t""$ac_fdsections" 1>&6
2929
2930   ac_ext=c
2931 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2932 ac_cpp='$CPP $CPPFLAGS'
2933 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2934 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2935 cross_compiling=$ac_cv_prog_cc_cross
2936
2937
2938
2939
2940
2941
2942   # All these tests are for C++; save the language and the compiler flags.
2943   # Need to do this so that g++ won't try to link in libstdc++
2944   ac_test_CFLAGS="${CFLAGS+set}"
2945   ac_save_CFLAGS="$CFLAGS"
2946   CFLAGS='-x c++  -Wl,--gc-sections'
2947
2948   # Check for -Wl,--gc-sections
2949   echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
2950 echo "configure:2951: checking for ld that supports -Wl,--gc-sections" >&5
2951   if test "$cross_compiling" = yes; then
2952   ac_sectionLDflags=yes
2953 else
2954   cat > conftest.$ac_ext <<EOF
2955 #line 2956 "configure"
2956 #include "confdefs.h"
2957
2958    int main(void)
2959    {
2960      try { throw 1; }
2961      catch (...) { };
2962      return 0;
2963    }
2964
2965 EOF
2966 if { (eval echo configure:2967: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
2967 then
2968   ac_sectionLDflags=yes
2969 else
2970   echo "configure: failed program was:" >&5
2971   cat conftest.$ac_ext >&5
2972   rm -fr conftest*
2973   ac_sectionLFflags=no
2974 fi
2975 rm -fr conftest*
2976 fi
2977
2978   if test "$ac_test_CFLAGS" = set; then
2979     CFLAGS="$ac_save_CFLAGS"
2980   else
2981     # this is the suspicious part
2982     CFLAGS=''
2983   fi
2984   if test "$ac_sectionLDflags" = "yes"; then
2985     SECTION_LDFLAGS='-Wl,--gc-sections'
2986   fi
2987   echo "$ac_t""$ac_sectionLDflags" 1>&6
2988
2989
2990
2991
2992
2993
2994   ac_ext=C
2995 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2996 ac_cpp='$CXXCPP $CPPFLAGS'
2997 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2998 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2999 cross_compiling=$ac_cv_prog_cxx_cross
3000
3001   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3002 echo "configure:3003: checking for __builtin_abs declaration" >&5
3003   cat > conftest.$ac_ext <<EOF
3004 #line 3005 "configure"
3005 #include "confdefs.h"
3006 #include <math.h>
3007 int main() {
3008  __builtin_abs(0);
3009 ; return 0; }
3010 EOF
3011 if { (eval echo configure:3012: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3012   rm -rf conftest*
3013   use___builtin_abs=yes
3014 else
3015   echo "configure: failed program was:" >&5
3016   cat conftest.$ac_ext >&5
3017   rm -rf conftest*
3018   use___builtin_abs=no
3019 fi
3020 rm -f conftest*
3021   echo "$ac_t""$use___builtin_abs" 1>&6
3022   ac_ext=c
3023 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3024 ac_cpp='$CPP $CPPFLAGS'
3025 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3026 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3027 cross_compiling=$ac_cv_prog_cc_cross
3028
3029   if test x$use___builtin_abs = x"yes"; then
3030     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3031 echo "configure:3032: checking for __builtin_abs linkage" >&5
3032       cat > conftest.$ac_ext <<EOF
3033 #line 3034 "configure"
3034 #include "confdefs.h"
3035 #include <math.h>
3036 int main() {
3037  __builtin_abs(0);
3038 ; return 0; }
3039 EOF
3040 if { (eval echo configure:3041: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3041   rm -rf conftest*
3042   link___builtin_abs=yes
3043 else
3044   echo "configure: failed program was:" >&5
3045   cat conftest.$ac_ext >&5
3046   rm -rf conftest*
3047   link___builtin_abs=no
3048 fi
3049 rm -f conftest*
3050     echo "$ac_t""$link___builtin_abs" 1>&6
3051     if test x$link___builtin_abs = x"yes"; then
3052       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3053       cat >> confdefs.h <<EOF
3054 #define ${ac_tr_func} 1
3055 EOF
3056
3057     fi
3058   fi
3059
3060
3061
3062   ac_ext=C
3063 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3064 ac_cpp='$CXXCPP $CPPFLAGS'
3065 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3066 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3067 cross_compiling=$ac_cv_prog_cxx_cross
3068
3069   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3070 echo "configure:3071: checking for __builtin_fabsf declaration" >&5
3071   cat > conftest.$ac_ext <<EOF
3072 #line 3073 "configure"
3073 #include "confdefs.h"
3074 #include <math.h>
3075 int main() {
3076  __builtin_fabsf(0);
3077 ; return 0; }
3078 EOF
3079 if { (eval echo configure:3080: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3080   rm -rf conftest*
3081   use___builtin_fabsf=yes
3082 else
3083   echo "configure: failed program was:" >&5
3084   cat conftest.$ac_ext >&5
3085   rm -rf conftest*
3086   use___builtin_fabsf=no
3087 fi
3088 rm -f conftest*
3089   echo "$ac_t""$use___builtin_fabsf" 1>&6
3090   ac_ext=c
3091 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3092 ac_cpp='$CPP $CPPFLAGS'
3093 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3094 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3095 cross_compiling=$ac_cv_prog_cc_cross
3096
3097   if test x$use___builtin_fabsf = x"yes"; then
3098     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3099 echo "configure:3100: checking for __builtin_fabsf linkage" >&5
3100       cat > conftest.$ac_ext <<EOF
3101 #line 3102 "configure"
3102 #include "confdefs.h"
3103 #include <math.h>
3104 int main() {
3105  __builtin_fabsf(0);
3106 ; return 0; }
3107 EOF
3108 if { (eval echo configure:3109: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3109   rm -rf conftest*
3110   link___builtin_fabsf=yes
3111 else
3112   echo "configure: failed program was:" >&5
3113   cat conftest.$ac_ext >&5
3114   rm -rf conftest*
3115   link___builtin_fabsf=no
3116 fi
3117 rm -f conftest*
3118     echo "$ac_t""$link___builtin_fabsf" 1>&6
3119     if test x$link___builtin_fabsf = x"yes"; then
3120       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3121       cat >> confdefs.h <<EOF
3122 #define ${ac_tr_func} 1
3123 EOF
3124
3125     fi
3126   fi
3127
3128
3129
3130   ac_ext=C
3131 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3132 ac_cpp='$CXXCPP $CPPFLAGS'
3133 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3134 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3135 cross_compiling=$ac_cv_prog_cxx_cross
3136
3137   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3138 echo "configure:3139: checking for __builtin_fabs declaration" >&5
3139   cat > conftest.$ac_ext <<EOF
3140 #line 3141 "configure"
3141 #include "confdefs.h"
3142 #include <math.h>
3143 int main() {
3144  __builtin_fabs(0);
3145 ; return 0; }
3146 EOF
3147 if { (eval echo configure:3148: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3148   rm -rf conftest*
3149   use___builtin_fabs=yes
3150 else
3151   echo "configure: failed program was:" >&5
3152   cat conftest.$ac_ext >&5
3153   rm -rf conftest*
3154   use___builtin_fabs=no
3155 fi
3156 rm -f conftest*
3157   echo "$ac_t""$use___builtin_fabs" 1>&6
3158   ac_ext=c
3159 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3160 ac_cpp='$CPP $CPPFLAGS'
3161 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3162 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3163 cross_compiling=$ac_cv_prog_cc_cross
3164
3165   if test x$use___builtin_fabs = x"yes"; then
3166     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3167 echo "configure:3168: checking for __builtin_fabs linkage" >&5
3168       cat > conftest.$ac_ext <<EOF
3169 #line 3170 "configure"
3170 #include "confdefs.h"
3171 #include <math.h>
3172 int main() {
3173  __builtin_fabs(0);
3174 ; return 0; }
3175 EOF
3176 if { (eval echo configure:3177: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3177   rm -rf conftest*
3178   link___builtin_fabs=yes
3179 else
3180   echo "configure: failed program was:" >&5
3181   cat conftest.$ac_ext >&5
3182   rm -rf conftest*
3183   link___builtin_fabs=no
3184 fi
3185 rm -f conftest*
3186     echo "$ac_t""$link___builtin_fabs" 1>&6
3187     if test x$link___builtin_fabs = x"yes"; then
3188       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3189       cat >> confdefs.h <<EOF
3190 #define ${ac_tr_func} 1
3191 EOF
3192
3193     fi
3194   fi
3195
3196
3197
3198   ac_ext=C
3199 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3200 ac_cpp='$CXXCPP $CPPFLAGS'
3201 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3202 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3203 cross_compiling=$ac_cv_prog_cxx_cross
3204
3205   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3206 echo "configure:3207: checking for __builtin_fabsl declaration" >&5
3207   cat > conftest.$ac_ext <<EOF
3208 #line 3209 "configure"
3209 #include "confdefs.h"
3210 #include <math.h>
3211 int main() {
3212  __builtin_fabsl(0);
3213 ; return 0; }
3214 EOF
3215 if { (eval echo configure:3216: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3216   rm -rf conftest*
3217   use___builtin_fabsl=yes
3218 else
3219   echo "configure: failed program was:" >&5
3220   cat conftest.$ac_ext >&5
3221   rm -rf conftest*
3222   use___builtin_fabsl=no
3223 fi
3224 rm -f conftest*
3225   echo "$ac_t""$use___builtin_fabsl" 1>&6
3226   ac_ext=c
3227 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3228 ac_cpp='$CPP $CPPFLAGS'
3229 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3230 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3231 cross_compiling=$ac_cv_prog_cc_cross
3232
3233   if test x$use___builtin_fabsl = x"yes"; then
3234     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3235 echo "configure:3236: checking for __builtin_fabsl linkage" >&5
3236       cat > conftest.$ac_ext <<EOF
3237 #line 3238 "configure"
3238 #include "confdefs.h"
3239 #include <math.h>
3240 int main() {
3241  __builtin_fabsl(0);
3242 ; return 0; }
3243 EOF
3244 if { (eval echo configure:3245: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3245   rm -rf conftest*
3246   link___builtin_fabsl=yes
3247 else
3248   echo "configure: failed program was:" >&5
3249   cat conftest.$ac_ext >&5
3250   rm -rf conftest*
3251   link___builtin_fabsl=no
3252 fi
3253 rm -f conftest*
3254     echo "$ac_t""$link___builtin_fabsl" 1>&6
3255     if test x$link___builtin_fabsl = x"yes"; then
3256       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3257       cat >> confdefs.h <<EOF
3258 #define ${ac_tr_func} 1
3259 EOF
3260
3261     fi
3262   fi
3263
3264
3265
3266   ac_ext=C
3267 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3268 ac_cpp='$CXXCPP $CPPFLAGS'
3269 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3270 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3271 cross_compiling=$ac_cv_prog_cxx_cross
3272
3273   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3274 echo "configure:3275: checking for __builtin_labs declaration" >&5
3275   cat > conftest.$ac_ext <<EOF
3276 #line 3277 "configure"
3277 #include "confdefs.h"
3278 #include <math.h>
3279 int main() {
3280  __builtin_labs(0);
3281 ; return 0; }
3282 EOF
3283 if { (eval echo configure:3284: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3284   rm -rf conftest*
3285   use___builtin_labs=yes
3286 else
3287   echo "configure: failed program was:" >&5
3288   cat conftest.$ac_ext >&5
3289   rm -rf conftest*
3290   use___builtin_labs=no
3291 fi
3292 rm -f conftest*
3293   echo "$ac_t""$use___builtin_labs" 1>&6
3294   ac_ext=c
3295 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3296 ac_cpp='$CPP $CPPFLAGS'
3297 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3298 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3299 cross_compiling=$ac_cv_prog_cc_cross
3300
3301   if test x$use___builtin_labs = x"yes"; then
3302     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3303 echo "configure:3304: checking for __builtin_labs linkage" >&5
3304       cat > conftest.$ac_ext <<EOF
3305 #line 3306 "configure"
3306 #include "confdefs.h"
3307 #include <math.h>
3308 int main() {
3309  __builtin_labs(0);
3310 ; return 0; }
3311 EOF
3312 if { (eval echo configure:3313: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3313   rm -rf conftest*
3314   link___builtin_labs=yes
3315 else
3316   echo "configure: failed program was:" >&5
3317   cat conftest.$ac_ext >&5
3318   rm -rf conftest*
3319   link___builtin_labs=no
3320 fi
3321 rm -f conftest*
3322     echo "$ac_t""$link___builtin_labs" 1>&6
3323     if test x$link___builtin_labs = x"yes"; then
3324       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3325       cat >> confdefs.h <<EOF
3326 #define ${ac_tr_func} 1
3327 EOF
3328
3329     fi
3330   fi
3331
3332
3333
3334
3335   ac_ext=C
3336 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3337 ac_cpp='$CXXCPP $CPPFLAGS'
3338 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3339 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3340 cross_compiling=$ac_cv_prog_cxx_cross
3341
3342   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3343 echo "configure:3344: checking for __builtin_sqrtf declaration" >&5
3344   cat > conftest.$ac_ext <<EOF
3345 #line 3346 "configure"
3346 #include "confdefs.h"
3347 #include <math.h>
3348 int main() {
3349  __builtin_sqrtf(0);
3350 ; return 0; }
3351 EOF
3352 if { (eval echo configure:3353: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3353   rm -rf conftest*
3354   use___builtin_sqrtf=yes
3355 else
3356   echo "configure: failed program was:" >&5
3357   cat conftest.$ac_ext >&5
3358   rm -rf conftest*
3359   use___builtin_sqrtf=no
3360 fi
3361 rm -f conftest*
3362   echo "$ac_t""$use___builtin_sqrtf" 1>&6
3363   ac_ext=c
3364 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3365 ac_cpp='$CPP $CPPFLAGS'
3366 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3367 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3368 cross_compiling=$ac_cv_prog_cc_cross
3369
3370   if test x$use___builtin_sqrtf = x"yes"; then
3371     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3372 echo "configure:3373: checking for __builtin_sqrtf linkage" >&5
3373       cat > conftest.$ac_ext <<EOF
3374 #line 3375 "configure"
3375 #include "confdefs.h"
3376 #include <math.h>
3377 int main() {
3378  __builtin_sqrtf(0);
3379 ; return 0; }
3380 EOF
3381 if { (eval echo configure:3382: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3382   rm -rf conftest*
3383   link___builtin_sqrtf=yes
3384 else
3385   echo "configure: failed program was:" >&5
3386   cat conftest.$ac_ext >&5
3387   rm -rf conftest*
3388   link___builtin_sqrtf=no
3389 fi
3390 rm -f conftest*
3391     echo "$ac_t""$link___builtin_sqrtf" 1>&6
3392     if test x$link___builtin_sqrtf = x"yes"; then
3393       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3394       cat >> confdefs.h <<EOF
3395 #define ${ac_tr_func} 1
3396 EOF
3397
3398     fi
3399   fi
3400
3401
3402
3403   ac_ext=C
3404 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3405 ac_cpp='$CXXCPP $CPPFLAGS'
3406 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3407 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3408 cross_compiling=$ac_cv_prog_cxx_cross
3409
3410   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
3411 echo "configure:3412: checking for __builtin_fsqrt declaration" >&5
3412   cat > conftest.$ac_ext <<EOF
3413 #line 3414 "configure"
3414 #include "confdefs.h"
3415 #include <math.h>
3416 int main() {
3417  __builtin_fsqrt(0);
3418 ; return 0; }
3419 EOF
3420 if { (eval echo configure:3421: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3421   rm -rf conftest*
3422   use___builtin_fsqrt=yes
3423 else
3424   echo "configure: failed program was:" >&5
3425   cat conftest.$ac_ext >&5
3426   rm -rf conftest*
3427   use___builtin_fsqrt=no
3428 fi
3429 rm -f conftest*
3430   echo "$ac_t""$use___builtin_fsqrt" 1>&6
3431   ac_ext=c
3432 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3433 ac_cpp='$CPP $CPPFLAGS'
3434 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3435 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3436 cross_compiling=$ac_cv_prog_cc_cross
3437
3438   if test x$use___builtin_fsqrt = x"yes"; then
3439     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
3440 echo "configure:3441: checking for __builtin_fsqrt linkage" >&5
3441       cat > conftest.$ac_ext <<EOF
3442 #line 3443 "configure"
3443 #include "confdefs.h"
3444 #include <math.h>
3445 int main() {
3446  __builtin_fsqrt(0);
3447 ; return 0; }
3448 EOF
3449 if { (eval echo configure:3450: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3450   rm -rf conftest*
3451   link___builtin_fsqrt=yes
3452 else
3453   echo "configure: failed program was:" >&5
3454   cat conftest.$ac_ext >&5
3455   rm -rf conftest*
3456   link___builtin_fsqrt=no
3457 fi
3458 rm -f conftest*
3459     echo "$ac_t""$link___builtin_fsqrt" 1>&6
3460     if test x$link___builtin_fsqrt = x"yes"; then
3461       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3462       cat >> confdefs.h <<EOF
3463 #define ${ac_tr_func} 1
3464 EOF
3465
3466     fi
3467   fi
3468
3469
3470
3471   ac_ext=C
3472 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3473 ac_cpp='$CXXCPP $CPPFLAGS'
3474 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3475 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3476 cross_compiling=$ac_cv_prog_cxx_cross
3477
3478   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
3479 echo "configure:3480: checking for __builtin_sqrtl declaration" >&5
3480   cat > conftest.$ac_ext <<EOF
3481 #line 3482 "configure"
3482 #include "confdefs.h"
3483 #include <math.h>
3484 int main() {
3485  __builtin_sqrtl(0);
3486 ; return 0; }
3487 EOF
3488 if { (eval echo configure:3489: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3489   rm -rf conftest*
3490   use___builtin_sqrtl=yes
3491 else
3492   echo "configure: failed program was:" >&5
3493   cat conftest.$ac_ext >&5
3494   rm -rf conftest*
3495   use___builtin_sqrtl=no
3496 fi
3497 rm -f conftest*
3498   echo "$ac_t""$use___builtin_sqrtl" 1>&6
3499   ac_ext=c
3500 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3501 ac_cpp='$CPP $CPPFLAGS'
3502 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3503 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3504 cross_compiling=$ac_cv_prog_cc_cross
3505
3506   if test x$use___builtin_sqrtl = x"yes"; then
3507     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
3508 echo "configure:3509: checking for __builtin_sqrtl linkage" >&5
3509       cat > conftest.$ac_ext <<EOF
3510 #line 3511 "configure"
3511 #include "confdefs.h"
3512 #include <math.h>
3513 int main() {
3514  __builtin_sqrtl(0);
3515 ; return 0; }
3516 EOF
3517 if { (eval echo configure:3518: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3518   rm -rf conftest*
3519   link___builtin_sqrtl=yes
3520 else
3521   echo "configure: failed program was:" >&5
3522   cat conftest.$ac_ext >&5
3523   rm -rf conftest*
3524   link___builtin_sqrtl=no
3525 fi
3526 rm -f conftest*
3527     echo "$ac_t""$link___builtin_sqrtl" 1>&6
3528     if test x$link___builtin_sqrtl = x"yes"; then
3529       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3530       cat >> confdefs.h <<EOF
3531 #define ${ac_tr_func} 1
3532 EOF
3533
3534     fi
3535   fi
3536
3537
3538
3539
3540   ac_ext=C
3541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3542 ac_cpp='$CXXCPP $CPPFLAGS'
3543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3545 cross_compiling=$ac_cv_prog_cxx_cross
3546
3547   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
3548 echo "configure:3549: checking for __builtin_sinf declaration" >&5
3549   cat > conftest.$ac_ext <<EOF
3550 #line 3551 "configure"
3551 #include "confdefs.h"
3552 #include <math.h>
3553 int main() {
3554  __builtin_sinf(0);
3555 ; return 0; }
3556 EOF
3557 if { (eval echo configure:3558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3558   rm -rf conftest*
3559   use___builtin_sinf=yes
3560 else
3561   echo "configure: failed program was:" >&5
3562   cat conftest.$ac_ext >&5
3563   rm -rf conftest*
3564   use___builtin_sinf=no
3565 fi
3566 rm -f conftest*
3567   echo "$ac_t""$use___builtin_sinf" 1>&6
3568   ac_ext=c
3569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3570 ac_cpp='$CPP $CPPFLAGS'
3571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3573 cross_compiling=$ac_cv_prog_cc_cross
3574
3575   if test x$use___builtin_sinf = x"yes"; then
3576     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
3577 echo "configure:3578: checking for __builtin_sinf linkage" >&5
3578       cat > conftest.$ac_ext <<EOF
3579 #line 3580 "configure"
3580 #include "confdefs.h"
3581 #include <math.h>
3582 int main() {
3583  __builtin_sinf(0);
3584 ; return 0; }
3585 EOF
3586 if { (eval echo configure:3587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3587   rm -rf conftest*
3588   link___builtin_sinf=yes
3589 else
3590   echo "configure: failed program was:" >&5
3591   cat conftest.$ac_ext >&5
3592   rm -rf conftest*
3593   link___builtin_sinf=no
3594 fi
3595 rm -f conftest*
3596     echo "$ac_t""$link___builtin_sinf" 1>&6
3597     if test x$link___builtin_sinf = x"yes"; then
3598       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3599       cat >> confdefs.h <<EOF
3600 #define ${ac_tr_func} 1
3601 EOF
3602
3603     fi
3604   fi
3605
3606
3607
3608   ac_ext=C
3609 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3610 ac_cpp='$CXXCPP $CPPFLAGS'
3611 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3612 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3613 cross_compiling=$ac_cv_prog_cxx_cross
3614
3615   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
3616 echo "configure:3617: checking for __builtin_sin declaration" >&5
3617   cat > conftest.$ac_ext <<EOF
3618 #line 3619 "configure"
3619 #include "confdefs.h"
3620 #include <math.h>
3621 int main() {
3622  __builtin_sin(0);
3623 ; return 0; }
3624 EOF
3625 if { (eval echo configure:3626: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3626   rm -rf conftest*
3627   use___builtin_sin=yes
3628 else
3629   echo "configure: failed program was:" >&5
3630   cat conftest.$ac_ext >&5
3631   rm -rf conftest*
3632   use___builtin_sin=no
3633 fi
3634 rm -f conftest*
3635   echo "$ac_t""$use___builtin_sin" 1>&6
3636   ac_ext=c
3637 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3638 ac_cpp='$CPP $CPPFLAGS'
3639 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3640 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3641 cross_compiling=$ac_cv_prog_cc_cross
3642
3643   if test x$use___builtin_sin = x"yes"; then
3644     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
3645 echo "configure:3646: checking for __builtin_sin linkage" >&5
3646       cat > conftest.$ac_ext <<EOF
3647 #line 3648 "configure"
3648 #include "confdefs.h"
3649 #include <math.h>
3650 int main() {
3651  __builtin_sin(0);
3652 ; return 0; }
3653 EOF
3654 if { (eval echo configure:3655: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3655   rm -rf conftest*
3656   link___builtin_sin=yes
3657 else
3658   echo "configure: failed program was:" >&5
3659   cat conftest.$ac_ext >&5
3660   rm -rf conftest*
3661   link___builtin_sin=no
3662 fi
3663 rm -f conftest*
3664     echo "$ac_t""$link___builtin_sin" 1>&6
3665     if test x$link___builtin_sin = x"yes"; then
3666       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3667       cat >> confdefs.h <<EOF
3668 #define ${ac_tr_func} 1
3669 EOF
3670
3671     fi
3672   fi
3673
3674
3675
3676   ac_ext=C
3677 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3678 ac_cpp='$CXXCPP $CPPFLAGS'
3679 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3680 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3681 cross_compiling=$ac_cv_prog_cxx_cross
3682
3683   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
3684 echo "configure:3685: checking for __builtin_sinl declaration" >&5
3685   cat > conftest.$ac_ext <<EOF
3686 #line 3687 "configure"
3687 #include "confdefs.h"
3688 #include <math.h>
3689 int main() {
3690  __builtin_sinl(0);
3691 ; return 0; }
3692 EOF
3693 if { (eval echo configure:3694: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3694   rm -rf conftest*
3695   use___builtin_sinl=yes
3696 else
3697   echo "configure: failed program was:" >&5
3698   cat conftest.$ac_ext >&5
3699   rm -rf conftest*
3700   use___builtin_sinl=no
3701 fi
3702 rm -f conftest*
3703   echo "$ac_t""$use___builtin_sinl" 1>&6
3704   ac_ext=c
3705 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3706 ac_cpp='$CPP $CPPFLAGS'
3707 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3708 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3709 cross_compiling=$ac_cv_prog_cc_cross
3710
3711   if test x$use___builtin_sinl = x"yes"; then
3712     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
3713 echo "configure:3714: checking for __builtin_sinl linkage" >&5
3714       cat > conftest.$ac_ext <<EOF
3715 #line 3716 "configure"
3716 #include "confdefs.h"
3717 #include <math.h>
3718 int main() {
3719  __builtin_sinl(0);
3720 ; return 0; }
3721 EOF
3722 if { (eval echo configure:3723: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3723   rm -rf conftest*
3724   link___builtin_sinl=yes
3725 else
3726   echo "configure: failed program was:" >&5
3727   cat conftest.$ac_ext >&5
3728   rm -rf conftest*
3729   link___builtin_sinl=no
3730 fi
3731 rm -f conftest*
3732     echo "$ac_t""$link___builtin_sinl" 1>&6
3733     if test x$link___builtin_sinl = x"yes"; then
3734       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3735       cat >> confdefs.h <<EOF
3736 #define ${ac_tr_func} 1
3737 EOF
3738
3739     fi
3740   fi
3741
3742
3743
3744
3745   ac_ext=C
3746 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3747 ac_cpp='$CXXCPP $CPPFLAGS'
3748 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3749 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3750 cross_compiling=$ac_cv_prog_cxx_cross
3751
3752   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
3753 echo "configure:3754: checking for __builtin_cosf declaration" >&5
3754   cat > conftest.$ac_ext <<EOF
3755 #line 3756 "configure"
3756 #include "confdefs.h"
3757 #include <math.h>
3758 int main() {
3759  __builtin_cosf(0);
3760 ; return 0; }
3761 EOF
3762 if { (eval echo configure:3763: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3763   rm -rf conftest*
3764   use___builtin_cosf=yes
3765 else
3766   echo "configure: failed program was:" >&5
3767   cat conftest.$ac_ext >&5
3768   rm -rf conftest*
3769   use___builtin_cosf=no
3770 fi
3771 rm -f conftest*
3772   echo "$ac_t""$use___builtin_cosf" 1>&6
3773   ac_ext=c
3774 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3775 ac_cpp='$CPP $CPPFLAGS'
3776 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3777 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3778 cross_compiling=$ac_cv_prog_cc_cross
3779
3780   if test x$use___builtin_cosf = x"yes"; then
3781     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
3782 echo "configure:3783: checking for __builtin_cosf linkage" >&5
3783       cat > conftest.$ac_ext <<EOF
3784 #line 3785 "configure"
3785 #include "confdefs.h"
3786 #include <math.h>
3787 int main() {
3788  __builtin_cosf(0);
3789 ; return 0; }
3790 EOF
3791 if { (eval echo configure:3792: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3792   rm -rf conftest*
3793   link___builtin_cosf=yes
3794 else
3795   echo "configure: failed program was:" >&5
3796   cat conftest.$ac_ext >&5
3797   rm -rf conftest*
3798   link___builtin_cosf=no
3799 fi
3800 rm -f conftest*
3801     echo "$ac_t""$link___builtin_cosf" 1>&6
3802     if test x$link___builtin_cosf = x"yes"; then
3803       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3804       cat >> confdefs.h <<EOF
3805 #define ${ac_tr_func} 1
3806 EOF
3807
3808     fi
3809   fi
3810
3811
3812
3813   ac_ext=C
3814 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3815 ac_cpp='$CXXCPP $CPPFLAGS'
3816 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3817 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3818 cross_compiling=$ac_cv_prog_cxx_cross
3819
3820   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
3821 echo "configure:3822: checking for __builtin_cos declaration" >&5
3822   cat > conftest.$ac_ext <<EOF
3823 #line 3824 "configure"
3824 #include "confdefs.h"
3825 #include <math.h>
3826 int main() {
3827  __builtin_cos(0);
3828 ; return 0; }
3829 EOF
3830 if { (eval echo configure:3831: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3831   rm -rf conftest*
3832   use___builtin_cos=yes
3833 else
3834   echo "configure: failed program was:" >&5
3835   cat conftest.$ac_ext >&5
3836   rm -rf conftest*
3837   use___builtin_cos=no
3838 fi
3839 rm -f conftest*
3840   echo "$ac_t""$use___builtin_cos" 1>&6
3841   ac_ext=c
3842 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3843 ac_cpp='$CPP $CPPFLAGS'
3844 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3845 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3846 cross_compiling=$ac_cv_prog_cc_cross
3847
3848   if test x$use___builtin_cos = x"yes"; then
3849     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
3850 echo "configure:3851: checking for __builtin_cos linkage" >&5
3851       cat > conftest.$ac_ext <<EOF
3852 #line 3853 "configure"
3853 #include "confdefs.h"
3854 #include <math.h>
3855 int main() {
3856  __builtin_cos(0);
3857 ; return 0; }
3858 EOF
3859 if { (eval echo configure:3860: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3860   rm -rf conftest*
3861   link___builtin_cos=yes
3862 else
3863   echo "configure: failed program was:" >&5
3864   cat conftest.$ac_ext >&5
3865   rm -rf conftest*
3866   link___builtin_cos=no
3867 fi
3868 rm -f conftest*
3869     echo "$ac_t""$link___builtin_cos" 1>&6
3870     if test x$link___builtin_cos = x"yes"; then
3871       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3872       cat >> confdefs.h <<EOF
3873 #define ${ac_tr_func} 1
3874 EOF
3875
3876     fi
3877   fi
3878
3879
3880
3881   ac_ext=C
3882 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3883 ac_cpp='$CXXCPP $CPPFLAGS'
3884 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3885 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3886 cross_compiling=$ac_cv_prog_cxx_cross
3887
3888   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
3889 echo "configure:3890: checking for __builtin_cosl declaration" >&5
3890   cat > conftest.$ac_ext <<EOF
3891 #line 3892 "configure"
3892 #include "confdefs.h"
3893 #include <math.h>
3894 int main() {
3895  __builtin_cosl(0);
3896 ; return 0; }
3897 EOF
3898 if { (eval echo configure:3899: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3899   rm -rf conftest*
3900   use___builtin_cosl=yes
3901 else
3902   echo "configure: failed program was:" >&5
3903   cat conftest.$ac_ext >&5
3904   rm -rf conftest*
3905   use___builtin_cosl=no
3906 fi
3907 rm -f conftest*
3908   echo "$ac_t""$use___builtin_cosl" 1>&6
3909   ac_ext=c
3910 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3911 ac_cpp='$CPP $CPPFLAGS'
3912 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3913 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3914 cross_compiling=$ac_cv_prog_cc_cross
3915
3916   if test x$use___builtin_cosl = x"yes"; then
3917     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
3918 echo "configure:3919: checking for __builtin_cosl linkage" >&5
3919       cat > conftest.$ac_ext <<EOF
3920 #line 3921 "configure"
3921 #include "confdefs.h"
3922 #include <math.h>
3923 int main() {
3924  __builtin_cosl(0);
3925 ; return 0; }
3926 EOF
3927 if { (eval echo configure:3928: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3928   rm -rf conftest*
3929   link___builtin_cosl=yes
3930 else
3931   echo "configure: failed program was:" >&5
3932   cat conftest.$ac_ext >&5
3933   rm -rf conftest*
3934   link___builtin_cosl=no
3935 fi
3936 rm -f conftest*
3937     echo "$ac_t""$link___builtin_cosl" 1>&6
3938     if test x$link___builtin_cosl = x"yes"; then
3939       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3940       cat >> confdefs.h <<EOF
3941 #define ${ac_tr_func} 1
3942 EOF
3943
3944     fi
3945   fi
3946
3947
3948               dummyvar=no
3949   if test x$dummyvar = x"yes"; then
3950     cat >> confdefs.h <<\EOF
3951 #define HAVE___BUILTIN_ABS 1
3952 EOF
3953
3954     cat >> confdefs.h <<\EOF
3955 #define HAVE___BUILTIN_LABS 1
3956 EOF
3957
3958     cat >> confdefs.h <<\EOF
3959 #define HAVE___BUILTIN_COS 1
3960 EOF
3961
3962     cat >> confdefs.h <<\EOF
3963 #define HAVE___BUILTIN_COSF 1
3964 EOF
3965
3966     cat >> confdefs.h <<\EOF
3967 #define HAVE___BUILTIN_COSL 1
3968 EOF
3969
3970     cat >> confdefs.h <<\EOF
3971 #define HAVE___BUILTIN_FABS 1
3972 EOF
3973
3974     cat >> confdefs.h <<\EOF
3975 #define HAVE___BUILTIN_FABSF 1
3976 EOF
3977
3978     cat >> confdefs.h <<\EOF
3979 #define HAVE___BUILTIN_FABSL 1
3980 EOF
3981
3982     cat >> confdefs.h <<\EOF
3983 #define HAVE___BUILTIN_SIN 1
3984 EOF
3985
3986     cat >> confdefs.h <<\EOF
3987 #define HAVE___BUILTIN_SINF 1
3988 EOF
3989
3990     cat >> confdefs.h <<\EOF
3991 #define HAVE___BUILTIN_SINL 1
3992 EOF
3993
3994     cat >> confdefs.h <<\EOF
3995 #define HAVE___BUILTIN_FSQRT 1
3996 EOF
3997
3998     cat >> confdefs.h <<\EOF
3999 #define HAVE___BUILTIN_SQRTF 1
4000 EOF
4001
4002     cat >> confdefs.h <<\EOF
4003 #define HAVE___BUILTIN_SQRTL 1
4004 EOF
4005
4006   fi
4007
4008
4009   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4010   ac_save_CXXFLAGS="$CXXFLAGS"
4011   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4012
4013     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4014 echo "configure:4015: checking for sin in -lm" >&5
4015 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4016 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4017   echo $ac_n "(cached) $ac_c" 1>&6
4018 else
4019   ac_save_LIBS="$LIBS"
4020 LIBS="-lm  $LIBS"
4021 cat > conftest.$ac_ext <<EOF
4022 #line 4023 "configure"
4023 #include "confdefs.h"
4024 /* Override any gcc2 internal prototype to avoid an error.  */
4025 /* We use char because int might match the return type of a gcc2
4026     builtin and then its argument prototype would still apply.  */
4027 char sin();
4028
4029 int main() {
4030 sin()
4031 ; return 0; }
4032 EOF
4033 if { (eval echo configure:4034: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4034   rm -rf conftest*
4035   eval "ac_cv_lib_$ac_lib_var=yes"
4036 else
4037   echo "configure: failed program was:" >&5
4038   cat conftest.$ac_ext >&5
4039   rm -rf conftest*
4040   eval "ac_cv_lib_$ac_lib_var=no"
4041 fi
4042 rm -f conftest*
4043 LIBS="$ac_save_LIBS"
4044
4045 fi
4046 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4047   echo "$ac_t""yes" 1>&6
4048   libm="-lm"
4049 else
4050   echo "$ac_t""no" 1>&6
4051 fi
4052
4053   ac_save_LIBS="$LIBS"
4054   LIBS="$LIBS $libm"
4055
4056     for ac_func in strtof strtold
4057 do
4058 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4059 echo "configure:4060: checking for $ac_func" >&5
4060 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4061   echo $ac_n "(cached) $ac_c" 1>&6
4062 else
4063   cat > conftest.$ac_ext <<EOF
4064 #line 4065 "configure"
4065 #include "confdefs.h"
4066 /* System header to define __stub macros and hopefully few prototypes,
4067     which can conflict with char $ac_func(); below.  */
4068 #include <assert.h>
4069 /* Override any gcc2 internal prototype to avoid an error.  */
4070 /* We use char because int might match the return type of a gcc2
4071     builtin and then its argument prototype would still apply.  */
4072 char $ac_func();
4073
4074 int main() {
4075
4076 /* The GNU C library defines this for functions which it implements
4077     to always fail with ENOSYS.  Some functions are actually named
4078     something starting with __ and the normal name is an alias.  */
4079 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4080 choke me
4081 #else
4082 $ac_func();
4083 #endif
4084
4085 ; return 0; }
4086 EOF
4087 if { (eval echo configure:4088: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4088   rm -rf conftest*
4089   eval "ac_cv_func_$ac_func=yes"
4090 else
4091   echo "configure: failed program was:" >&5
4092   cat conftest.$ac_ext >&5
4093   rm -rf conftest*
4094   eval "ac_cv_func_$ac_func=no"
4095 fi
4096 rm -f conftest*
4097 fi
4098
4099 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4100   echo "$ac_t""yes" 1>&6
4101     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4102   cat >> confdefs.h <<EOF
4103 #define $ac_tr_func 1
4104 EOF
4105
4106 else
4107   echo "$ac_t""no" 1>&6
4108 fi
4109 done
4110
4111
4112
4113
4114   ac_ext=C
4115 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4116 ac_cpp='$CXXCPP $CPPFLAGS'
4117 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4118 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4119 cross_compiling=$ac_cv_prog_cxx_cross
4120
4121   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4122 echo "configure:4123: checking for isinf declaration" >&5
4123   cat > conftest.$ac_ext <<EOF
4124 #line 4125 "configure"
4125 #include "confdefs.h"
4126 #include <math.h>
4127 int main() {
4128  isinf(0);
4129 ; return 0; }
4130 EOF
4131 if { (eval echo configure:4132: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4132   rm -rf conftest*
4133   use_isinf=yes
4134 else
4135   echo "configure: failed program was:" >&5
4136   cat conftest.$ac_ext >&5
4137   rm -rf conftest*
4138   use_isinf=no
4139 fi
4140 rm -f conftest*
4141   echo "$ac_t""$use_isinf" 1>&6
4142   ac_ext=c
4143 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4144 ac_cpp='$CPP $CPPFLAGS'
4145 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4146 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4147 cross_compiling=$ac_cv_prog_cc_cross
4148
4149   if test x$use_isinf = x"yes"; then
4150     for ac_func in isinf
4151 do
4152 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4153 echo "configure:4154: checking for $ac_func" >&5
4154 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4155   echo $ac_n "(cached) $ac_c" 1>&6
4156 else
4157   cat > conftest.$ac_ext <<EOF
4158 #line 4159 "configure"
4159 #include "confdefs.h"
4160 /* System header to define __stub macros and hopefully few prototypes,
4161     which can conflict with char $ac_func(); below.  */
4162 #include <assert.h>
4163 /* Override any gcc2 internal prototype to avoid an error.  */
4164 /* We use char because int might match the return type of a gcc2
4165     builtin and then its argument prototype would still apply.  */
4166 char $ac_func();
4167
4168 int main() {
4169
4170 /* The GNU C library defines this for functions which it implements
4171     to always fail with ENOSYS.  Some functions are actually named
4172     something starting with __ and the normal name is an alias.  */
4173 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4174 choke me
4175 #else
4176 $ac_func();
4177 #endif
4178
4179 ; return 0; }
4180 EOF
4181 if { (eval echo configure:4182: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4182   rm -rf conftest*
4183   eval "ac_cv_func_$ac_func=yes"
4184 else
4185   echo "configure: failed program was:" >&5
4186   cat conftest.$ac_ext >&5
4187   rm -rf conftest*
4188   eval "ac_cv_func_$ac_func=no"
4189 fi
4190 rm -f conftest*
4191 fi
4192
4193 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4194   echo "$ac_t""yes" 1>&6
4195     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4196   cat >> confdefs.h <<EOF
4197 #define $ac_tr_func 1
4198 EOF
4199
4200 else
4201   echo "$ac_t""no" 1>&6
4202 fi
4203 done
4204
4205   fi
4206
4207
4208
4209   ac_ext=C
4210 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4211 ac_cpp='$CXXCPP $CPPFLAGS'
4212 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4213 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4214 cross_compiling=$ac_cv_prog_cxx_cross
4215
4216   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4217 echo "configure:4218: checking for isnan declaration" >&5
4218   cat > conftest.$ac_ext <<EOF
4219 #line 4220 "configure"
4220 #include "confdefs.h"
4221 #include <math.h>
4222 int main() {
4223  isnan(0);
4224 ; return 0; }
4225 EOF
4226 if { (eval echo configure:4227: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4227   rm -rf conftest*
4228   use_isnan=yes
4229 else
4230   echo "configure: failed program was:" >&5
4231   cat conftest.$ac_ext >&5
4232   rm -rf conftest*
4233   use_isnan=no
4234 fi
4235 rm -f conftest*
4236   echo "$ac_t""$use_isnan" 1>&6
4237   ac_ext=c
4238 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4239 ac_cpp='$CPP $CPPFLAGS'
4240 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4241 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4242 cross_compiling=$ac_cv_prog_cc_cross
4243
4244   if test x$use_isnan = x"yes"; then
4245     for ac_func in isnan
4246 do
4247 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4248 echo "configure:4249: checking for $ac_func" >&5
4249 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4250   echo $ac_n "(cached) $ac_c" 1>&6
4251 else
4252   cat > conftest.$ac_ext <<EOF
4253 #line 4254 "configure"
4254 #include "confdefs.h"
4255 /* System header to define __stub macros and hopefully few prototypes,
4256     which can conflict with char $ac_func(); below.  */
4257 #include <assert.h>
4258 /* Override any gcc2 internal prototype to avoid an error.  */
4259 /* We use char because int might match the return type of a gcc2
4260     builtin and then its argument prototype would still apply.  */
4261 char $ac_func();
4262
4263 int main() {
4264
4265 /* The GNU C library defines this for functions which it implements
4266     to always fail with ENOSYS.  Some functions are actually named
4267     something starting with __ and the normal name is an alias.  */
4268 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4269 choke me
4270 #else
4271 $ac_func();
4272 #endif
4273
4274 ; return 0; }
4275 EOF
4276 if { (eval echo configure:4277: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4277   rm -rf conftest*
4278   eval "ac_cv_func_$ac_func=yes"
4279 else
4280   echo "configure: failed program was:" >&5
4281   cat conftest.$ac_ext >&5
4282   rm -rf conftest*
4283   eval "ac_cv_func_$ac_func=no"
4284 fi
4285 rm -f conftest*
4286 fi
4287
4288 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4289   echo "$ac_t""yes" 1>&6
4290     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4291   cat >> confdefs.h <<EOF
4292 #define $ac_tr_func 1
4293 EOF
4294
4295 else
4296   echo "$ac_t""no" 1>&6
4297 fi
4298 done
4299
4300   fi
4301
4302
4303
4304   ac_ext=C
4305 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4306 ac_cpp='$CXXCPP $CPPFLAGS'
4307 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4308 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4309 cross_compiling=$ac_cv_prog_cxx_cross
4310
4311   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
4312 echo "configure:4313: checking for finite declaration" >&5
4313   cat > conftest.$ac_ext <<EOF
4314 #line 4315 "configure"
4315 #include "confdefs.h"
4316 #include <math.h>
4317 int main() {
4318  finite(0);
4319 ; return 0; }
4320 EOF
4321 if { (eval echo configure:4322: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4322   rm -rf conftest*
4323   use_finite=yes
4324 else
4325   echo "configure: failed program was:" >&5
4326   cat conftest.$ac_ext >&5
4327   rm -rf conftest*
4328   use_finite=no
4329 fi
4330 rm -f conftest*
4331   echo "$ac_t""$use_finite" 1>&6
4332   ac_ext=c
4333 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4334 ac_cpp='$CPP $CPPFLAGS'
4335 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4336 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4337 cross_compiling=$ac_cv_prog_cc_cross
4338
4339   if test x$use_finite = x"yes"; then
4340     for ac_func in finite
4341 do
4342 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4343 echo "configure:4344: checking for $ac_func" >&5
4344 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4345   echo $ac_n "(cached) $ac_c" 1>&6
4346 else
4347   cat > conftest.$ac_ext <<EOF
4348 #line 4349 "configure"
4349 #include "confdefs.h"
4350 /* System header to define __stub macros and hopefully few prototypes,
4351     which can conflict with char $ac_func(); below.  */
4352 #include <assert.h>
4353 /* Override any gcc2 internal prototype to avoid an error.  */
4354 /* We use char because int might match the return type of a gcc2
4355     builtin and then its argument prototype would still apply.  */
4356 char $ac_func();
4357
4358 int main() {
4359
4360 /* The GNU C library defines this for functions which it implements
4361     to always fail with ENOSYS.  Some functions are actually named
4362     something starting with __ and the normal name is an alias.  */
4363 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4364 choke me
4365 #else
4366 $ac_func();
4367 #endif
4368
4369 ; return 0; }
4370 EOF
4371 if { (eval echo configure:4372: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4372   rm -rf conftest*
4373   eval "ac_cv_func_$ac_func=yes"
4374 else
4375   echo "configure: failed program was:" >&5
4376   cat conftest.$ac_ext >&5
4377   rm -rf conftest*
4378   eval "ac_cv_func_$ac_func=no"
4379 fi
4380 rm -f conftest*
4381 fi
4382
4383 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4384   echo "$ac_t""yes" 1>&6
4385     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4386   cat >> confdefs.h <<EOF
4387 #define $ac_tr_func 1
4388 EOF
4389
4390 else
4391   echo "$ac_t""no" 1>&6
4392 fi
4393 done
4394
4395   fi
4396
4397
4398
4399   ac_ext=C
4400 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4401 ac_cpp='$CXXCPP $CPPFLAGS'
4402 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4403 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4404 cross_compiling=$ac_cv_prog_cxx_cross
4405
4406   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
4407 echo "configure:4408: checking for copysign declaration" >&5
4408   cat > conftest.$ac_ext <<EOF
4409 #line 4410 "configure"
4410 #include "confdefs.h"
4411 #include <math.h>
4412 int main() {
4413  copysign(0, 0);
4414 ; return 0; }
4415 EOF
4416 if { (eval echo configure:4417: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4417   rm -rf conftest*
4418   use_copysign=yes
4419 else
4420   echo "configure: failed program was:" >&5
4421   cat conftest.$ac_ext >&5
4422   rm -rf conftest*
4423   use_copysign=no
4424 fi
4425 rm -f conftest*
4426   echo "$ac_t""$use_copysign" 1>&6
4427   ac_ext=c
4428 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4429 ac_cpp='$CPP $CPPFLAGS'
4430 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4431 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4432 cross_compiling=$ac_cv_prog_cc_cross
4433
4434   if test x$use_copysign = x"yes"; then
4435     for ac_func in copysign
4436 do
4437 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4438 echo "configure:4439: checking for $ac_func" >&5
4439 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4440   echo $ac_n "(cached) $ac_c" 1>&6
4441 else
4442   cat > conftest.$ac_ext <<EOF
4443 #line 4444 "configure"
4444 #include "confdefs.h"
4445 /* System header to define __stub macros and hopefully few prototypes,
4446     which can conflict with char $ac_func(); below.  */
4447 #include <assert.h>
4448 /* Override any gcc2 internal prototype to avoid an error.  */
4449 /* We use char because int might match the return type of a gcc2
4450     builtin and then its argument prototype would still apply.  */
4451 char $ac_func();
4452
4453 int main() {
4454
4455 /* The GNU C library defines this for functions which it implements
4456     to always fail with ENOSYS.  Some functions are actually named
4457     something starting with __ and the normal name is an alias.  */
4458 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4459 choke me
4460 #else
4461 $ac_func();
4462 #endif
4463
4464 ; return 0; }
4465 EOF
4466 if { (eval echo configure:4467: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4467   rm -rf conftest*
4468   eval "ac_cv_func_$ac_func=yes"
4469 else
4470   echo "configure: failed program was:" >&5
4471   cat conftest.$ac_ext >&5
4472   rm -rf conftest*
4473   eval "ac_cv_func_$ac_func=no"
4474 fi
4475 rm -f conftest*
4476 fi
4477
4478 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4479   echo "$ac_t""yes" 1>&6
4480     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4481   cat >> confdefs.h <<EOF
4482 #define $ac_tr_func 1
4483 EOF
4484
4485 else
4486   echo "$ac_t""no" 1>&6
4487 fi
4488 done
4489
4490   fi
4491
4492
4493
4494   ac_ext=C
4495 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4496 ac_cpp='$CXXCPP $CPPFLAGS'
4497 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4498 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4499 cross_compiling=$ac_cv_prog_cxx_cross
4500
4501   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
4502 echo "configure:4503: checking for sincos declaration" >&5
4503   cat > conftest.$ac_ext <<EOF
4504 #line 4505 "configure"
4505 #include "confdefs.h"
4506 #include <math.h>
4507 int main() {
4508  sincos(0, 0, 0);
4509 ; return 0; }
4510 EOF
4511 if { (eval echo configure:4512: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4512   rm -rf conftest*
4513   use_sincos=yes
4514 else
4515   echo "configure: failed program was:" >&5
4516   cat conftest.$ac_ext >&5
4517   rm -rf conftest*
4518   use_sincos=no
4519 fi
4520 rm -f conftest*
4521   echo "$ac_t""$use_sincos" 1>&6
4522   ac_ext=c
4523 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4524 ac_cpp='$CPP $CPPFLAGS'
4525 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4526 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4527 cross_compiling=$ac_cv_prog_cc_cross
4528
4529   if test x$use_sincos = x"yes"; then
4530     for ac_func in sincos
4531 do
4532 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4533 echo "configure:4534: checking for $ac_func" >&5
4534 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4535   echo $ac_n "(cached) $ac_c" 1>&6
4536 else
4537   cat > conftest.$ac_ext <<EOF
4538 #line 4539 "configure"
4539 #include "confdefs.h"
4540 /* System header to define __stub macros and hopefully few prototypes,
4541     which can conflict with char $ac_func(); below.  */
4542 #include <assert.h>
4543 /* Override any gcc2 internal prototype to avoid an error.  */
4544 /* We use char because int might match the return type of a gcc2
4545     builtin and then its argument prototype would still apply.  */
4546 char $ac_func();
4547
4548 int main() {
4549
4550 /* The GNU C library defines this for functions which it implements
4551     to always fail with ENOSYS.  Some functions are actually named
4552     something starting with __ and the normal name is an alias.  */
4553 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4554 choke me
4555 #else
4556 $ac_func();
4557 #endif
4558
4559 ; return 0; }
4560 EOF
4561 if { (eval echo configure:4562: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4562   rm -rf conftest*
4563   eval "ac_cv_func_$ac_func=yes"
4564 else
4565   echo "configure: failed program was:" >&5
4566   cat conftest.$ac_ext >&5
4567   rm -rf conftest*
4568   eval "ac_cv_func_$ac_func=no"
4569 fi
4570 rm -f conftest*
4571 fi
4572
4573 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4574   echo "$ac_t""yes" 1>&6
4575     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4576   cat >> confdefs.h <<EOF
4577 #define $ac_tr_func 1
4578 EOF
4579
4580 else
4581   echo "$ac_t""no" 1>&6
4582 fi
4583 done
4584
4585   fi
4586
4587
4588
4589   ac_ext=C
4590 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4591 ac_cpp='$CXXCPP $CPPFLAGS'
4592 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4593 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4594 cross_compiling=$ac_cv_prog_cxx_cross
4595
4596   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
4597 echo "configure:4598: checking for fpclass declaration" >&5
4598   cat > conftest.$ac_ext <<EOF
4599 #line 4600 "configure"
4600 #include "confdefs.h"
4601 #include <math.h>
4602 int main() {
4603  fpclass(0);
4604 ; return 0; }
4605 EOF
4606 if { (eval echo configure:4607: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4607   rm -rf conftest*
4608   use_fpclass=yes
4609 else
4610   echo "configure: failed program was:" >&5
4611   cat conftest.$ac_ext >&5
4612   rm -rf conftest*
4613   use_fpclass=no
4614 fi
4615 rm -f conftest*
4616   echo "$ac_t""$use_fpclass" 1>&6
4617   ac_ext=c
4618 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4619 ac_cpp='$CPP $CPPFLAGS'
4620 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4621 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4622 cross_compiling=$ac_cv_prog_cc_cross
4623
4624   if test x$use_fpclass = x"yes"; then
4625     for ac_func in fpclass
4626 do
4627 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4628 echo "configure:4629: checking for $ac_func" >&5
4629 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4630   echo $ac_n "(cached) $ac_c" 1>&6
4631 else
4632   cat > conftest.$ac_ext <<EOF
4633 #line 4634 "configure"
4634 #include "confdefs.h"
4635 /* System header to define __stub macros and hopefully few prototypes,
4636     which can conflict with char $ac_func(); below.  */
4637 #include <assert.h>
4638 /* Override any gcc2 internal prototype to avoid an error.  */
4639 /* We use char because int might match the return type of a gcc2
4640     builtin and then its argument prototype would still apply.  */
4641 char $ac_func();
4642
4643 int main() {
4644
4645 /* The GNU C library defines this for functions which it implements
4646     to always fail with ENOSYS.  Some functions are actually named
4647     something starting with __ and the normal name is an alias.  */
4648 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4649 choke me
4650 #else
4651 $ac_func();
4652 #endif
4653
4654 ; return 0; }
4655 EOF
4656 if { (eval echo configure:4657: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4657   rm -rf conftest*
4658   eval "ac_cv_func_$ac_func=yes"
4659 else
4660   echo "configure: failed program was:" >&5
4661   cat conftest.$ac_ext >&5
4662   rm -rf conftest*
4663   eval "ac_cv_func_$ac_func=no"
4664 fi
4665 rm -f conftest*
4666 fi
4667
4668 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4669   echo "$ac_t""yes" 1>&6
4670     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4671   cat >> confdefs.h <<EOF
4672 #define $ac_tr_func 1
4673 EOF
4674
4675 else
4676   echo "$ac_t""no" 1>&6
4677 fi
4678 done
4679
4680   fi
4681
4682
4683
4684   ac_ext=C
4685 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4686 ac_cpp='$CXXCPP $CPPFLAGS'
4687 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4688 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4689 cross_compiling=$ac_cv_prog_cxx_cross
4690
4691   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
4692 echo "configure:4693: checking for qfpclass declaration" >&5
4693   cat > conftest.$ac_ext <<EOF
4694 #line 4695 "configure"
4695 #include "confdefs.h"
4696 #include <math.h>
4697 int main() {
4698  qfpclass(0);
4699 ; return 0; }
4700 EOF
4701 if { (eval echo configure:4702: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4702   rm -rf conftest*
4703   use_qfpclass=yes
4704 else
4705   echo "configure: failed program was:" >&5
4706   cat conftest.$ac_ext >&5
4707   rm -rf conftest*
4708   use_qfpclass=no
4709 fi
4710 rm -f conftest*
4711   echo "$ac_t""$use_qfpclass" 1>&6
4712   ac_ext=c
4713 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4714 ac_cpp='$CPP $CPPFLAGS'
4715 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4716 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4717 cross_compiling=$ac_cv_prog_cc_cross
4718
4719   if test x$use_qfpclass = x"yes"; then
4720     for ac_func in qfpclass
4721 do
4722 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4723 echo "configure:4724: checking for $ac_func" >&5
4724 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4725   echo $ac_n "(cached) $ac_c" 1>&6
4726 else
4727   cat > conftest.$ac_ext <<EOF
4728 #line 4729 "configure"
4729 #include "confdefs.h"
4730 /* System header to define __stub macros and hopefully few prototypes,
4731     which can conflict with char $ac_func(); below.  */
4732 #include <assert.h>
4733 /* Override any gcc2 internal prototype to avoid an error.  */
4734 /* We use char because int might match the return type of a gcc2
4735     builtin and then its argument prototype would still apply.  */
4736 char $ac_func();
4737
4738 int main() {
4739
4740 /* The GNU C library defines this for functions which it implements
4741     to always fail with ENOSYS.  Some functions are actually named
4742     something starting with __ and the normal name is an alias.  */
4743 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4744 choke me
4745 #else
4746 $ac_func();
4747 #endif
4748
4749 ; return 0; }
4750 EOF
4751 if { (eval echo configure:4752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4752   rm -rf conftest*
4753   eval "ac_cv_func_$ac_func=yes"
4754 else
4755   echo "configure: failed program was:" >&5
4756   cat conftest.$ac_ext >&5
4757   rm -rf conftest*
4758   eval "ac_cv_func_$ac_func=no"
4759 fi
4760 rm -f conftest*
4761 fi
4762
4763 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4764   echo "$ac_t""yes" 1>&6
4765     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4766   cat >> confdefs.h <<EOF
4767 #define $ac_tr_func 1
4768 EOF
4769
4770 else
4771   echo "$ac_t""no" 1>&6
4772 fi
4773 done
4774
4775   fi
4776
4777
4778
4779
4780   ac_ext=C
4781 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4782 ac_cpp='$CXXCPP $CPPFLAGS'
4783 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4784 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4785 cross_compiling=$ac_cv_prog_cxx_cross
4786
4787   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
4788 echo "configure:4789: checking for isnanf declaration" >&5
4789   cat > conftest.$ac_ext <<EOF
4790 #line 4791 "configure"
4791 #include "confdefs.h"
4792 #include <math.h>
4793 int main() {
4794  isnanf(0);
4795 ; return 0; }
4796 EOF
4797 if { (eval echo configure:4798: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4798   rm -rf conftest*
4799   use_isnanf=yes
4800 else
4801   echo "configure: failed program was:" >&5
4802   cat conftest.$ac_ext >&5
4803   rm -rf conftest*
4804   use_isnanf=no
4805 fi
4806 rm -f conftest*
4807   echo "$ac_t""$use_isnanf" 1>&6
4808   ac_ext=c
4809 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4810 ac_cpp='$CPP $CPPFLAGS'
4811 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4812 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4813 cross_compiling=$ac_cv_prog_cc_cross
4814
4815   if test x$use_isnanf = x"yes"; then
4816     for ac_func in isnanf
4817 do
4818 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4819 echo "configure:4820: checking for $ac_func" >&5
4820 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4821   echo $ac_n "(cached) $ac_c" 1>&6
4822 else
4823   cat > conftest.$ac_ext <<EOF
4824 #line 4825 "configure"
4825 #include "confdefs.h"
4826 /* System header to define __stub macros and hopefully few prototypes,
4827     which can conflict with char $ac_func(); below.  */
4828 #include <assert.h>
4829 /* Override any gcc2 internal prototype to avoid an error.  */
4830 /* We use char because int might match the return type of a gcc2
4831     builtin and then its argument prototype would still apply.  */
4832 char $ac_func();
4833
4834 int main() {
4835
4836 /* The GNU C library defines this for functions which it implements
4837     to always fail with ENOSYS.  Some functions are actually named
4838     something starting with __ and the normal name is an alias.  */
4839 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4840 choke me
4841 #else
4842 $ac_func();
4843 #endif
4844
4845 ; return 0; }
4846 EOF
4847 if { (eval echo configure:4848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4848   rm -rf conftest*
4849   eval "ac_cv_func_$ac_func=yes"
4850 else
4851   echo "configure: failed program was:" >&5
4852   cat conftest.$ac_ext >&5
4853   rm -rf conftest*
4854   eval "ac_cv_func_$ac_func=no"
4855 fi
4856 rm -f conftest*
4857 fi
4858
4859 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4860   echo "$ac_t""yes" 1>&6
4861     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4862   cat >> confdefs.h <<EOF
4863 #define $ac_tr_func 1
4864 EOF
4865
4866 else
4867   echo "$ac_t""no" 1>&6
4868 fi
4869 done
4870
4871   fi
4872
4873
4874
4875   ac_ext=C
4876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4877 ac_cpp='$CXXCPP $CPPFLAGS'
4878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4880 cross_compiling=$ac_cv_prog_cxx_cross
4881
4882   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
4883 echo "configure:4884: checking for isinff declaration" >&5
4884   cat > conftest.$ac_ext <<EOF
4885 #line 4886 "configure"
4886 #include "confdefs.h"
4887 #include <math.h>
4888 int main() {
4889  isinff(0);
4890 ; return 0; }
4891 EOF
4892 if { (eval echo configure:4893: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4893   rm -rf conftest*
4894   use_isinff=yes
4895 else
4896   echo "configure: failed program was:" >&5
4897   cat conftest.$ac_ext >&5
4898   rm -rf conftest*
4899   use_isinff=no
4900 fi
4901 rm -f conftest*
4902   echo "$ac_t""$use_isinff" 1>&6
4903   ac_ext=c
4904 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4905 ac_cpp='$CPP $CPPFLAGS'
4906 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4907 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4908 cross_compiling=$ac_cv_prog_cc_cross
4909
4910   if test x$use_isinff = x"yes"; then
4911     for ac_func in isinff
4912 do
4913 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4914 echo "configure:4915: checking for $ac_func" >&5
4915 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4916   echo $ac_n "(cached) $ac_c" 1>&6
4917 else
4918   cat > conftest.$ac_ext <<EOF
4919 #line 4920 "configure"
4920 #include "confdefs.h"
4921 /* System header to define __stub macros and hopefully few prototypes,
4922     which can conflict with char $ac_func(); below.  */
4923 #include <assert.h>
4924 /* Override any gcc2 internal prototype to avoid an error.  */
4925 /* We use char because int might match the return type of a gcc2
4926     builtin and then its argument prototype would still apply.  */
4927 char $ac_func();
4928
4929 int main() {
4930
4931 /* The GNU C library defines this for functions which it implements
4932     to always fail with ENOSYS.  Some functions are actually named
4933     something starting with __ and the normal name is an alias.  */
4934 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4935 choke me
4936 #else
4937 $ac_func();
4938 #endif
4939
4940 ; return 0; }
4941 EOF
4942 if { (eval echo configure:4943: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4943   rm -rf conftest*
4944   eval "ac_cv_func_$ac_func=yes"
4945 else
4946   echo "configure: failed program was:" >&5
4947   cat conftest.$ac_ext >&5
4948   rm -rf conftest*
4949   eval "ac_cv_func_$ac_func=no"
4950 fi
4951 rm -f conftest*
4952 fi
4953
4954 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4955   echo "$ac_t""yes" 1>&6
4956     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4957   cat >> confdefs.h <<EOF
4958 #define $ac_tr_func 1
4959 EOF
4960
4961 else
4962   echo "$ac_t""no" 1>&6
4963 fi
4964 done
4965
4966   fi
4967
4968
4969
4970   ac_ext=C
4971 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4972 ac_cpp='$CXXCPP $CPPFLAGS'
4973 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4974 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4975 cross_compiling=$ac_cv_prog_cxx_cross
4976
4977   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
4978 echo "configure:4979: checking for acosf declaration" >&5
4979   cat > conftest.$ac_ext <<EOF
4980 #line 4981 "configure"
4981 #include "confdefs.h"
4982 #include <math.h>
4983 int main() {
4984  acosf(0);
4985 ; return 0; }
4986 EOF
4987 if { (eval echo configure:4988: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4988   rm -rf conftest*
4989   use_acosf=yes
4990 else
4991   echo "configure: failed program was:" >&5
4992   cat conftest.$ac_ext >&5
4993   rm -rf conftest*
4994   use_acosf=no
4995 fi
4996 rm -f conftest*
4997   echo "$ac_t""$use_acosf" 1>&6
4998   ac_ext=c
4999 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5000 ac_cpp='$CPP $CPPFLAGS'
5001 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5002 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5003 cross_compiling=$ac_cv_prog_cc_cross
5004
5005   if test x$use_acosf = x"yes"; then
5006     for ac_func in acosf
5007 do
5008 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5009 echo "configure:5010: checking for $ac_func" >&5
5010 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5011   echo $ac_n "(cached) $ac_c" 1>&6
5012 else
5013   cat > conftest.$ac_ext <<EOF
5014 #line 5015 "configure"
5015 #include "confdefs.h"
5016 /* System header to define __stub macros and hopefully few prototypes,
5017     which can conflict with char $ac_func(); below.  */
5018 #include <assert.h>
5019 /* Override any gcc2 internal prototype to avoid an error.  */
5020 /* We use char because int might match the return type of a gcc2
5021     builtin and then its argument prototype would still apply.  */
5022 char $ac_func();
5023
5024 int main() {
5025
5026 /* The GNU C library defines this for functions which it implements
5027     to always fail with ENOSYS.  Some functions are actually named
5028     something starting with __ and the normal name is an alias.  */
5029 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5030 choke me
5031 #else
5032 $ac_func();
5033 #endif
5034
5035 ; return 0; }
5036 EOF
5037 if { (eval echo configure:5038: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5038   rm -rf conftest*
5039   eval "ac_cv_func_$ac_func=yes"
5040 else
5041   echo "configure: failed program was:" >&5
5042   cat conftest.$ac_ext >&5
5043   rm -rf conftest*
5044   eval "ac_cv_func_$ac_func=no"
5045 fi
5046 rm -f conftest*
5047 fi
5048
5049 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5050   echo "$ac_t""yes" 1>&6
5051     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5052   cat >> confdefs.h <<EOF
5053 #define $ac_tr_func 1
5054 EOF
5055
5056 else
5057   echo "$ac_t""no" 1>&6
5058 fi
5059 done
5060
5061   fi
5062
5063
5064
5065   ac_ext=C
5066 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5067 ac_cpp='$CXXCPP $CPPFLAGS'
5068 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5069 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5070 cross_compiling=$ac_cv_prog_cxx_cross
5071
5072   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5073 echo "configure:5074: checking for asinf declaration" >&5
5074   cat > conftest.$ac_ext <<EOF
5075 #line 5076 "configure"
5076 #include "confdefs.h"
5077 #include <math.h>
5078 int main() {
5079  asinf(0);
5080 ; return 0; }
5081 EOF
5082 if { (eval echo configure:5083: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5083   rm -rf conftest*
5084   use_asinf=yes
5085 else
5086   echo "configure: failed program was:" >&5
5087   cat conftest.$ac_ext >&5
5088   rm -rf conftest*
5089   use_asinf=no
5090 fi
5091 rm -f conftest*
5092   echo "$ac_t""$use_asinf" 1>&6
5093   ac_ext=c
5094 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5095 ac_cpp='$CPP $CPPFLAGS'
5096 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5097 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5098 cross_compiling=$ac_cv_prog_cc_cross
5099
5100   if test x$use_asinf = x"yes"; then
5101     for ac_func in asinf
5102 do
5103 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5104 echo "configure:5105: checking for $ac_func" >&5
5105 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5106   echo $ac_n "(cached) $ac_c" 1>&6
5107 else
5108   cat > conftest.$ac_ext <<EOF
5109 #line 5110 "configure"
5110 #include "confdefs.h"
5111 /* System header to define __stub macros and hopefully few prototypes,
5112     which can conflict with char $ac_func(); below.  */
5113 #include <assert.h>
5114 /* Override any gcc2 internal prototype to avoid an error.  */
5115 /* We use char because int might match the return type of a gcc2
5116     builtin and then its argument prototype would still apply.  */
5117 char $ac_func();
5118
5119 int main() {
5120
5121 /* The GNU C library defines this for functions which it implements
5122     to always fail with ENOSYS.  Some functions are actually named
5123     something starting with __ and the normal name is an alias.  */
5124 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5125 choke me
5126 #else
5127 $ac_func();
5128 #endif
5129
5130 ; return 0; }
5131 EOF
5132 if { (eval echo configure:5133: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5133   rm -rf conftest*
5134   eval "ac_cv_func_$ac_func=yes"
5135 else
5136   echo "configure: failed program was:" >&5
5137   cat conftest.$ac_ext >&5
5138   rm -rf conftest*
5139   eval "ac_cv_func_$ac_func=no"
5140 fi
5141 rm -f conftest*
5142 fi
5143
5144 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5145   echo "$ac_t""yes" 1>&6
5146     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5147   cat >> confdefs.h <<EOF
5148 #define $ac_tr_func 1
5149 EOF
5150
5151 else
5152   echo "$ac_t""no" 1>&6
5153 fi
5154 done
5155
5156   fi
5157
5158
5159
5160   ac_ext=C
5161 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5162 ac_cpp='$CXXCPP $CPPFLAGS'
5163 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5164 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5165 cross_compiling=$ac_cv_prog_cxx_cross
5166
5167   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5168 echo "configure:5169: checking for atanf declaration" >&5
5169   cat > conftest.$ac_ext <<EOF
5170 #line 5171 "configure"
5171 #include "confdefs.h"
5172 #include <math.h>
5173 int main() {
5174  atanf(0);
5175 ; return 0; }
5176 EOF
5177 if { (eval echo configure:5178: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5178   rm -rf conftest*
5179   use_atanf=yes
5180 else
5181   echo "configure: failed program was:" >&5
5182   cat conftest.$ac_ext >&5
5183   rm -rf conftest*
5184   use_atanf=no
5185 fi
5186 rm -f conftest*
5187   echo "$ac_t""$use_atanf" 1>&6
5188   ac_ext=c
5189 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5190 ac_cpp='$CPP $CPPFLAGS'
5191 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5192 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5193 cross_compiling=$ac_cv_prog_cc_cross
5194
5195   if test x$use_atanf = x"yes"; then
5196     for ac_func in atanf
5197 do
5198 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5199 echo "configure:5200: checking for $ac_func" >&5
5200 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5201   echo $ac_n "(cached) $ac_c" 1>&6
5202 else
5203   cat > conftest.$ac_ext <<EOF
5204 #line 5205 "configure"
5205 #include "confdefs.h"
5206 /* System header to define __stub macros and hopefully few prototypes,
5207     which can conflict with char $ac_func(); below.  */
5208 #include <assert.h>
5209 /* Override any gcc2 internal prototype to avoid an error.  */
5210 /* We use char because int might match the return type of a gcc2
5211     builtin and then its argument prototype would still apply.  */
5212 char $ac_func();
5213
5214 int main() {
5215
5216 /* The GNU C library defines this for functions which it implements
5217     to always fail with ENOSYS.  Some functions are actually named
5218     something starting with __ and the normal name is an alias.  */
5219 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5220 choke me
5221 #else
5222 $ac_func();
5223 #endif
5224
5225 ; return 0; }
5226 EOF
5227 if { (eval echo configure:5228: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5228   rm -rf conftest*
5229   eval "ac_cv_func_$ac_func=yes"
5230 else
5231   echo "configure: failed program was:" >&5
5232   cat conftest.$ac_ext >&5
5233   rm -rf conftest*
5234   eval "ac_cv_func_$ac_func=no"
5235 fi
5236 rm -f conftest*
5237 fi
5238
5239 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5240   echo "$ac_t""yes" 1>&6
5241     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5242   cat >> confdefs.h <<EOF
5243 #define $ac_tr_func 1
5244 EOF
5245
5246 else
5247   echo "$ac_t""no" 1>&6
5248 fi
5249 done
5250
5251   fi
5252
5253
5254
5255   ac_ext=C
5256 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5257 ac_cpp='$CXXCPP $CPPFLAGS'
5258 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5259 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5260 cross_compiling=$ac_cv_prog_cxx_cross
5261
5262   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
5263 echo "configure:5264: checking for atan2f declaration" >&5
5264   cat > conftest.$ac_ext <<EOF
5265 #line 5266 "configure"
5266 #include "confdefs.h"
5267 #include <math.h>
5268 int main() {
5269  atan2f(0, 0);
5270 ; return 0; }
5271 EOF
5272 if { (eval echo configure:5273: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5273   rm -rf conftest*
5274   use_atan2f=yes
5275 else
5276   echo "configure: failed program was:" >&5
5277   cat conftest.$ac_ext >&5
5278   rm -rf conftest*
5279   use_atan2f=no
5280 fi
5281 rm -f conftest*
5282   echo "$ac_t""$use_atan2f" 1>&6
5283   ac_ext=c
5284 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5285 ac_cpp='$CPP $CPPFLAGS'
5286 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5287 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5288 cross_compiling=$ac_cv_prog_cc_cross
5289
5290   if test x$use_atan2f = x"yes"; then
5291     for ac_func in atan2f
5292 do
5293 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5294 echo "configure:5295: checking for $ac_func" >&5
5295 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5296   echo $ac_n "(cached) $ac_c" 1>&6
5297 else
5298   cat > conftest.$ac_ext <<EOF
5299 #line 5300 "configure"
5300 #include "confdefs.h"
5301 /* System header to define __stub macros and hopefully few prototypes,
5302     which can conflict with char $ac_func(); below.  */
5303 #include <assert.h>
5304 /* Override any gcc2 internal prototype to avoid an error.  */
5305 /* We use char because int might match the return type of a gcc2
5306     builtin and then its argument prototype would still apply.  */
5307 char $ac_func();
5308
5309 int main() {
5310
5311 /* The GNU C library defines this for functions which it implements
5312     to always fail with ENOSYS.  Some functions are actually named
5313     something starting with __ and the normal name is an alias.  */
5314 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5315 choke me
5316 #else
5317 $ac_func();
5318 #endif
5319
5320 ; return 0; }
5321 EOF
5322 if { (eval echo configure:5323: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5323   rm -rf conftest*
5324   eval "ac_cv_func_$ac_func=yes"
5325 else
5326   echo "configure: failed program was:" >&5
5327   cat conftest.$ac_ext >&5
5328   rm -rf conftest*
5329   eval "ac_cv_func_$ac_func=no"
5330 fi
5331 rm -f conftest*
5332 fi
5333
5334 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5335   echo "$ac_t""yes" 1>&6
5336     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5337   cat >> confdefs.h <<EOF
5338 #define $ac_tr_func 1
5339 EOF
5340
5341 else
5342   echo "$ac_t""no" 1>&6
5343 fi
5344 done
5345
5346   fi
5347
5348
5349
5350   ac_ext=C
5351 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5352 ac_cpp='$CXXCPP $CPPFLAGS'
5353 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5354 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5355 cross_compiling=$ac_cv_prog_cxx_cross
5356
5357   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
5358 echo "configure:5359: checking for ceilf declaration" >&5
5359   cat > conftest.$ac_ext <<EOF
5360 #line 5361 "configure"
5361 #include "confdefs.h"
5362 #include <math.h>
5363 int main() {
5364  ceilf(0);
5365 ; return 0; }
5366 EOF
5367 if { (eval echo configure:5368: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5368   rm -rf conftest*
5369   use_ceilf=yes
5370 else
5371   echo "configure: failed program was:" >&5
5372   cat conftest.$ac_ext >&5
5373   rm -rf conftest*
5374   use_ceilf=no
5375 fi
5376 rm -f conftest*
5377   echo "$ac_t""$use_ceilf" 1>&6
5378   ac_ext=c
5379 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5380 ac_cpp='$CPP $CPPFLAGS'
5381 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5382 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5383 cross_compiling=$ac_cv_prog_cc_cross
5384
5385   if test x$use_ceilf = x"yes"; then
5386     for ac_func in ceilf
5387 do
5388 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5389 echo "configure:5390: checking for $ac_func" >&5
5390 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5391   echo $ac_n "(cached) $ac_c" 1>&6
5392 else
5393   cat > conftest.$ac_ext <<EOF
5394 #line 5395 "configure"
5395 #include "confdefs.h"
5396 /* System header to define __stub macros and hopefully few prototypes,
5397     which can conflict with char $ac_func(); below.  */
5398 #include <assert.h>
5399 /* Override any gcc2 internal prototype to avoid an error.  */
5400 /* We use char because int might match the return type of a gcc2
5401     builtin and then its argument prototype would still apply.  */
5402 char $ac_func();
5403
5404 int main() {
5405
5406 /* The GNU C library defines this for functions which it implements
5407     to always fail with ENOSYS.  Some functions are actually named
5408     something starting with __ and the normal name is an alias.  */
5409 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5410 choke me
5411 #else
5412 $ac_func();
5413 #endif
5414
5415 ; return 0; }
5416 EOF
5417 if { (eval echo configure:5418: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5418   rm -rf conftest*
5419   eval "ac_cv_func_$ac_func=yes"
5420 else
5421   echo "configure: failed program was:" >&5
5422   cat conftest.$ac_ext >&5
5423   rm -rf conftest*
5424   eval "ac_cv_func_$ac_func=no"
5425 fi
5426 rm -f conftest*
5427 fi
5428
5429 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5430   echo "$ac_t""yes" 1>&6
5431     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5432   cat >> confdefs.h <<EOF
5433 #define $ac_tr_func 1
5434 EOF
5435
5436 else
5437   echo "$ac_t""no" 1>&6
5438 fi
5439 done
5440
5441   fi
5442
5443
5444
5445   ac_ext=C
5446 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5447 ac_cpp='$CXXCPP $CPPFLAGS'
5448 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5449 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5450 cross_compiling=$ac_cv_prog_cxx_cross
5451
5452   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
5453 echo "configure:5454: checking for cosf declaration" >&5
5454   cat > conftest.$ac_ext <<EOF
5455 #line 5456 "configure"
5456 #include "confdefs.h"
5457 #include <math.h>
5458 int main() {
5459  cosf(0);
5460 ; return 0; }
5461 EOF
5462 if { (eval echo configure:5463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5463   rm -rf conftest*
5464   use_cosf=yes
5465 else
5466   echo "configure: failed program was:" >&5
5467   cat conftest.$ac_ext >&5
5468   rm -rf conftest*
5469   use_cosf=no
5470 fi
5471 rm -f conftest*
5472   echo "$ac_t""$use_cosf" 1>&6
5473   ac_ext=c
5474 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5475 ac_cpp='$CPP $CPPFLAGS'
5476 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5477 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5478 cross_compiling=$ac_cv_prog_cc_cross
5479
5480   if test x$use_cosf = x"yes"; then
5481     for ac_func in cosf
5482 do
5483 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5484 echo "configure:5485: checking for $ac_func" >&5
5485 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5486   echo $ac_n "(cached) $ac_c" 1>&6
5487 else
5488   cat > conftest.$ac_ext <<EOF
5489 #line 5490 "configure"
5490 #include "confdefs.h"
5491 /* System header to define __stub macros and hopefully few prototypes,
5492     which can conflict with char $ac_func(); below.  */
5493 #include <assert.h>
5494 /* Override any gcc2 internal prototype to avoid an error.  */
5495 /* We use char because int might match the return type of a gcc2
5496     builtin and then its argument prototype would still apply.  */
5497 char $ac_func();
5498
5499 int main() {
5500
5501 /* The GNU C library defines this for functions which it implements
5502     to always fail with ENOSYS.  Some functions are actually named
5503     something starting with __ and the normal name is an alias.  */
5504 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5505 choke me
5506 #else
5507 $ac_func();
5508 #endif
5509
5510 ; return 0; }
5511 EOF
5512 if { (eval echo configure:5513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5513   rm -rf conftest*
5514   eval "ac_cv_func_$ac_func=yes"
5515 else
5516   echo "configure: failed program was:" >&5
5517   cat conftest.$ac_ext >&5
5518   rm -rf conftest*
5519   eval "ac_cv_func_$ac_func=no"
5520 fi
5521 rm -f conftest*
5522 fi
5523
5524 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5525   echo "$ac_t""yes" 1>&6
5526     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5527   cat >> confdefs.h <<EOF
5528 #define $ac_tr_func 1
5529 EOF
5530
5531 else
5532   echo "$ac_t""no" 1>&6
5533 fi
5534 done
5535
5536   fi
5537
5538
5539
5540   ac_ext=C
5541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5542 ac_cpp='$CXXCPP $CPPFLAGS'
5543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5545 cross_compiling=$ac_cv_prog_cxx_cross
5546
5547   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
5548 echo "configure:5549: checking for coshf declaration" >&5
5549   cat > conftest.$ac_ext <<EOF
5550 #line 5551 "configure"
5551 #include "confdefs.h"
5552 #include <math.h>
5553 int main() {
5554  coshf(0);
5555 ; return 0; }
5556 EOF
5557 if { (eval echo configure:5558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5558   rm -rf conftest*
5559   use_coshf=yes
5560 else
5561   echo "configure: failed program was:" >&5
5562   cat conftest.$ac_ext >&5
5563   rm -rf conftest*
5564   use_coshf=no
5565 fi
5566 rm -f conftest*
5567   echo "$ac_t""$use_coshf" 1>&6
5568   ac_ext=c
5569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5570 ac_cpp='$CPP $CPPFLAGS'
5571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5573 cross_compiling=$ac_cv_prog_cc_cross
5574
5575   if test x$use_coshf = x"yes"; then
5576     for ac_func in coshf
5577 do
5578 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5579 echo "configure:5580: checking for $ac_func" >&5
5580 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5581   echo $ac_n "(cached) $ac_c" 1>&6
5582 else
5583   cat > conftest.$ac_ext <<EOF
5584 #line 5585 "configure"
5585 #include "confdefs.h"
5586 /* System header to define __stub macros and hopefully few prototypes,
5587     which can conflict with char $ac_func(); below.  */
5588 #include <assert.h>
5589 /* Override any gcc2 internal prototype to avoid an error.  */
5590 /* We use char because int might match the return type of a gcc2
5591     builtin and then its argument prototype would still apply.  */
5592 char $ac_func();
5593
5594 int main() {
5595
5596 /* The GNU C library defines this for functions which it implements
5597     to always fail with ENOSYS.  Some functions are actually named
5598     something starting with __ and the normal name is an alias.  */
5599 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5600 choke me
5601 #else
5602 $ac_func();
5603 #endif
5604
5605 ; return 0; }
5606 EOF
5607 if { (eval echo configure:5608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5608   rm -rf conftest*
5609   eval "ac_cv_func_$ac_func=yes"
5610 else
5611   echo "configure: failed program was:" >&5
5612   cat conftest.$ac_ext >&5
5613   rm -rf conftest*
5614   eval "ac_cv_func_$ac_func=no"
5615 fi
5616 rm -f conftest*
5617 fi
5618
5619 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5620   echo "$ac_t""yes" 1>&6
5621     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5622   cat >> confdefs.h <<EOF
5623 #define $ac_tr_func 1
5624 EOF
5625
5626 else
5627   echo "$ac_t""no" 1>&6
5628 fi
5629 done
5630
5631   fi
5632
5633
5634
5635   ac_ext=C
5636 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5637 ac_cpp='$CXXCPP $CPPFLAGS'
5638 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5639 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5640 cross_compiling=$ac_cv_prog_cxx_cross
5641
5642   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
5643 echo "configure:5644: checking for expf declaration" >&5
5644   cat > conftest.$ac_ext <<EOF
5645 #line 5646 "configure"
5646 #include "confdefs.h"
5647 #include <math.h>
5648 int main() {
5649  expf(0);
5650 ; return 0; }
5651 EOF
5652 if { (eval echo configure:5653: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5653   rm -rf conftest*
5654   use_expf=yes
5655 else
5656   echo "configure: failed program was:" >&5
5657   cat conftest.$ac_ext >&5
5658   rm -rf conftest*
5659   use_expf=no
5660 fi
5661 rm -f conftest*
5662   echo "$ac_t""$use_expf" 1>&6
5663   ac_ext=c
5664 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5665 ac_cpp='$CPP $CPPFLAGS'
5666 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5667 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5668 cross_compiling=$ac_cv_prog_cc_cross
5669
5670   if test x$use_expf = x"yes"; then
5671     for ac_func in expf
5672 do
5673 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5674 echo "configure:5675: checking for $ac_func" >&5
5675 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5676   echo $ac_n "(cached) $ac_c" 1>&6
5677 else
5678   cat > conftest.$ac_ext <<EOF
5679 #line 5680 "configure"
5680 #include "confdefs.h"
5681 /* System header to define __stub macros and hopefully few prototypes,
5682     which can conflict with char $ac_func(); below.  */
5683 #include <assert.h>
5684 /* Override any gcc2 internal prototype to avoid an error.  */
5685 /* We use char because int might match the return type of a gcc2
5686     builtin and then its argument prototype would still apply.  */
5687 char $ac_func();
5688
5689 int main() {
5690
5691 /* The GNU C library defines this for functions which it implements
5692     to always fail with ENOSYS.  Some functions are actually named
5693     something starting with __ and the normal name is an alias.  */
5694 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5695 choke me
5696 #else
5697 $ac_func();
5698 #endif
5699
5700 ; return 0; }
5701 EOF
5702 if { (eval echo configure:5703: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5703   rm -rf conftest*
5704   eval "ac_cv_func_$ac_func=yes"
5705 else
5706   echo "configure: failed program was:" >&5
5707   cat conftest.$ac_ext >&5
5708   rm -rf conftest*
5709   eval "ac_cv_func_$ac_func=no"
5710 fi
5711 rm -f conftest*
5712 fi
5713
5714 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5715   echo "$ac_t""yes" 1>&6
5716     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5717   cat >> confdefs.h <<EOF
5718 #define $ac_tr_func 1
5719 EOF
5720
5721 else
5722   echo "$ac_t""no" 1>&6
5723 fi
5724 done
5725
5726   fi
5727
5728
5729
5730   ac_ext=C
5731 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5732 ac_cpp='$CXXCPP $CPPFLAGS'
5733 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5734 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5735 cross_compiling=$ac_cv_prog_cxx_cross
5736
5737   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
5738 echo "configure:5739: checking for fabsf declaration" >&5
5739   cat > conftest.$ac_ext <<EOF
5740 #line 5741 "configure"
5741 #include "confdefs.h"
5742 #include <math.h>
5743 int main() {
5744  fabsf(0);
5745 ; return 0; }
5746 EOF
5747 if { (eval echo configure:5748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5748   rm -rf conftest*
5749   use_fabsf=yes
5750 else
5751   echo "configure: failed program was:" >&5
5752   cat conftest.$ac_ext >&5
5753   rm -rf conftest*
5754   use_fabsf=no
5755 fi
5756 rm -f conftest*
5757   echo "$ac_t""$use_fabsf" 1>&6
5758   ac_ext=c
5759 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5760 ac_cpp='$CPP $CPPFLAGS'
5761 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5762 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5763 cross_compiling=$ac_cv_prog_cc_cross
5764
5765   if test x$use_fabsf = x"yes"; then
5766     for ac_func in fabsf
5767 do
5768 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5769 echo "configure:5770: checking for $ac_func" >&5
5770 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5771   echo $ac_n "(cached) $ac_c" 1>&6
5772 else
5773   cat > conftest.$ac_ext <<EOF
5774 #line 5775 "configure"
5775 #include "confdefs.h"
5776 /* System header to define __stub macros and hopefully few prototypes,
5777     which can conflict with char $ac_func(); below.  */
5778 #include <assert.h>
5779 /* Override any gcc2 internal prototype to avoid an error.  */
5780 /* We use char because int might match the return type of a gcc2
5781     builtin and then its argument prototype would still apply.  */
5782 char $ac_func();
5783
5784 int main() {
5785
5786 /* The GNU C library defines this for functions which it implements
5787     to always fail with ENOSYS.  Some functions are actually named
5788     something starting with __ and the normal name is an alias.  */
5789 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5790 choke me
5791 #else
5792 $ac_func();
5793 #endif
5794
5795 ; return 0; }
5796 EOF
5797 if { (eval echo configure:5798: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5798   rm -rf conftest*
5799   eval "ac_cv_func_$ac_func=yes"
5800 else
5801   echo "configure: failed program was:" >&5
5802   cat conftest.$ac_ext >&5
5803   rm -rf conftest*
5804   eval "ac_cv_func_$ac_func=no"
5805 fi
5806 rm -f conftest*
5807 fi
5808
5809 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5810   echo "$ac_t""yes" 1>&6
5811     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5812   cat >> confdefs.h <<EOF
5813 #define $ac_tr_func 1
5814 EOF
5815
5816 else
5817   echo "$ac_t""no" 1>&6
5818 fi
5819 done
5820
5821   fi
5822
5823
5824
5825   ac_ext=C
5826 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5827 ac_cpp='$CXXCPP $CPPFLAGS'
5828 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5829 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5830 cross_compiling=$ac_cv_prog_cxx_cross
5831
5832   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
5833 echo "configure:5834: checking for floorf declaration" >&5
5834   cat > conftest.$ac_ext <<EOF
5835 #line 5836 "configure"
5836 #include "confdefs.h"
5837 #include <math.h>
5838 int main() {
5839  floorf(0);
5840 ; return 0; }
5841 EOF
5842 if { (eval echo configure:5843: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5843   rm -rf conftest*
5844   use_floorf=yes
5845 else
5846   echo "configure: failed program was:" >&5
5847   cat conftest.$ac_ext >&5
5848   rm -rf conftest*
5849   use_floorf=no
5850 fi
5851 rm -f conftest*
5852   echo "$ac_t""$use_floorf" 1>&6
5853   ac_ext=c
5854 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5855 ac_cpp='$CPP $CPPFLAGS'
5856 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5857 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5858 cross_compiling=$ac_cv_prog_cc_cross
5859
5860   if test x$use_floorf = x"yes"; then
5861     for ac_func in floorf
5862 do
5863 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5864 echo "configure:5865: checking for $ac_func" >&5
5865 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5866   echo $ac_n "(cached) $ac_c" 1>&6
5867 else
5868   cat > conftest.$ac_ext <<EOF
5869 #line 5870 "configure"
5870 #include "confdefs.h"
5871 /* System header to define __stub macros and hopefully few prototypes,
5872     which can conflict with char $ac_func(); below.  */
5873 #include <assert.h>
5874 /* Override any gcc2 internal prototype to avoid an error.  */
5875 /* We use char because int might match the return type of a gcc2
5876     builtin and then its argument prototype would still apply.  */
5877 char $ac_func();
5878
5879 int main() {
5880
5881 /* The GNU C library defines this for functions which it implements
5882     to always fail with ENOSYS.  Some functions are actually named
5883     something starting with __ and the normal name is an alias.  */
5884 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5885 choke me
5886 #else
5887 $ac_func();
5888 #endif
5889
5890 ; return 0; }
5891 EOF
5892 if { (eval echo configure:5893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5893   rm -rf conftest*
5894   eval "ac_cv_func_$ac_func=yes"
5895 else
5896   echo "configure: failed program was:" >&5
5897   cat conftest.$ac_ext >&5
5898   rm -rf conftest*
5899   eval "ac_cv_func_$ac_func=no"
5900 fi
5901 rm -f conftest*
5902 fi
5903
5904 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5905   echo "$ac_t""yes" 1>&6
5906     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5907   cat >> confdefs.h <<EOF
5908 #define $ac_tr_func 1
5909 EOF
5910
5911 else
5912   echo "$ac_t""no" 1>&6
5913 fi
5914 done
5915
5916   fi
5917
5918
5919
5920   ac_ext=C
5921 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5922 ac_cpp='$CXXCPP $CPPFLAGS'
5923 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5924 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5925 cross_compiling=$ac_cv_prog_cxx_cross
5926
5927   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
5928 echo "configure:5929: checking for fmodf declaration" >&5
5929   cat > conftest.$ac_ext <<EOF
5930 #line 5931 "configure"
5931 #include "confdefs.h"
5932 #include <math.h>
5933 int main() {
5934  fmodf(0, 0);
5935 ; return 0; }
5936 EOF
5937 if { (eval echo configure:5938: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5938   rm -rf conftest*
5939   use_fmodf=yes
5940 else
5941   echo "configure: failed program was:" >&5
5942   cat conftest.$ac_ext >&5
5943   rm -rf conftest*
5944   use_fmodf=no
5945 fi
5946 rm -f conftest*
5947   echo "$ac_t""$use_fmodf" 1>&6
5948   ac_ext=c
5949 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5950 ac_cpp='$CPP $CPPFLAGS'
5951 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5952 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5953 cross_compiling=$ac_cv_prog_cc_cross
5954
5955   if test x$use_fmodf = x"yes"; then
5956     for ac_func in fmodf
5957 do
5958 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5959 echo "configure:5960: checking for $ac_func" >&5
5960 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5961   echo $ac_n "(cached) $ac_c" 1>&6
5962 else
5963   cat > conftest.$ac_ext <<EOF
5964 #line 5965 "configure"
5965 #include "confdefs.h"
5966 /* System header to define __stub macros and hopefully few prototypes,
5967     which can conflict with char $ac_func(); below.  */
5968 #include <assert.h>
5969 /* Override any gcc2 internal prototype to avoid an error.  */
5970 /* We use char because int might match the return type of a gcc2
5971     builtin and then its argument prototype would still apply.  */
5972 char $ac_func();
5973
5974 int main() {
5975
5976 /* The GNU C library defines this for functions which it implements
5977     to always fail with ENOSYS.  Some functions are actually named
5978     something starting with __ and the normal name is an alias.  */
5979 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5980 choke me
5981 #else
5982 $ac_func();
5983 #endif
5984
5985 ; return 0; }
5986 EOF
5987 if { (eval echo configure:5988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5988   rm -rf conftest*
5989   eval "ac_cv_func_$ac_func=yes"
5990 else
5991   echo "configure: failed program was:" >&5
5992   cat conftest.$ac_ext >&5
5993   rm -rf conftest*
5994   eval "ac_cv_func_$ac_func=no"
5995 fi
5996 rm -f conftest*
5997 fi
5998
5999 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6000   echo "$ac_t""yes" 1>&6
6001     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6002   cat >> confdefs.h <<EOF
6003 #define $ac_tr_func 1
6004 EOF
6005
6006 else
6007   echo "$ac_t""no" 1>&6
6008 fi
6009 done
6010
6011   fi
6012
6013
6014
6015   ac_ext=C
6016 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6017 ac_cpp='$CXXCPP $CPPFLAGS'
6018 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6019 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6020 cross_compiling=$ac_cv_prog_cxx_cross
6021
6022   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6023 echo "configure:6024: checking for frexpf declaration" >&5
6024   cat > conftest.$ac_ext <<EOF
6025 #line 6026 "configure"
6026 #include "confdefs.h"
6027 #include <math.h>
6028 int main() {
6029  frexpf(0, 0);
6030 ; return 0; }
6031 EOF
6032 if { (eval echo configure:6033: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6033   rm -rf conftest*
6034   use_frexpf=yes
6035 else
6036   echo "configure: failed program was:" >&5
6037   cat conftest.$ac_ext >&5
6038   rm -rf conftest*
6039   use_frexpf=no
6040 fi
6041 rm -f conftest*
6042   echo "$ac_t""$use_frexpf" 1>&6
6043   ac_ext=c
6044 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6045 ac_cpp='$CPP $CPPFLAGS'
6046 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6047 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6048 cross_compiling=$ac_cv_prog_cc_cross
6049
6050   if test x$use_frexpf = x"yes"; then
6051     for ac_func in frexpf
6052 do
6053 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6054 echo "configure:6055: checking for $ac_func" >&5
6055 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6056   echo $ac_n "(cached) $ac_c" 1>&6
6057 else
6058   cat > conftest.$ac_ext <<EOF
6059 #line 6060 "configure"
6060 #include "confdefs.h"
6061 /* System header to define __stub macros and hopefully few prototypes,
6062     which can conflict with char $ac_func(); below.  */
6063 #include <assert.h>
6064 /* Override any gcc2 internal prototype to avoid an error.  */
6065 /* We use char because int might match the return type of a gcc2
6066     builtin and then its argument prototype would still apply.  */
6067 char $ac_func();
6068
6069 int main() {
6070
6071 /* The GNU C library defines this for functions which it implements
6072     to always fail with ENOSYS.  Some functions are actually named
6073     something starting with __ and the normal name is an alias.  */
6074 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6075 choke me
6076 #else
6077 $ac_func();
6078 #endif
6079
6080 ; return 0; }
6081 EOF
6082 if { (eval echo configure:6083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6083   rm -rf conftest*
6084   eval "ac_cv_func_$ac_func=yes"
6085 else
6086   echo "configure: failed program was:" >&5
6087   cat conftest.$ac_ext >&5
6088   rm -rf conftest*
6089   eval "ac_cv_func_$ac_func=no"
6090 fi
6091 rm -f conftest*
6092 fi
6093
6094 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6095   echo "$ac_t""yes" 1>&6
6096     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6097   cat >> confdefs.h <<EOF
6098 #define $ac_tr_func 1
6099 EOF
6100
6101 else
6102   echo "$ac_t""no" 1>&6
6103 fi
6104 done
6105
6106   fi
6107
6108
6109
6110   ac_ext=C
6111 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6112 ac_cpp='$CXXCPP $CPPFLAGS'
6113 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6114 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6115 cross_compiling=$ac_cv_prog_cxx_cross
6116
6117   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6118 echo "configure:6119: checking for ldexpf declaration" >&5
6119   cat > conftest.$ac_ext <<EOF
6120 #line 6121 "configure"
6121 #include "confdefs.h"
6122 #include <math.h>
6123 int main() {
6124  ldexpf(0, 0);
6125 ; return 0; }
6126 EOF
6127 if { (eval echo configure:6128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6128   rm -rf conftest*
6129   use_ldexpf=yes
6130 else
6131   echo "configure: failed program was:" >&5
6132   cat conftest.$ac_ext >&5
6133   rm -rf conftest*
6134   use_ldexpf=no
6135 fi
6136 rm -f conftest*
6137   echo "$ac_t""$use_ldexpf" 1>&6
6138   ac_ext=c
6139 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6140 ac_cpp='$CPP $CPPFLAGS'
6141 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6142 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6143 cross_compiling=$ac_cv_prog_cc_cross
6144
6145   if test x$use_ldexpf = x"yes"; then
6146     for ac_func in ldexpf
6147 do
6148 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6149 echo "configure:6150: checking for $ac_func" >&5
6150 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6151   echo $ac_n "(cached) $ac_c" 1>&6
6152 else
6153   cat > conftest.$ac_ext <<EOF
6154 #line 6155 "configure"
6155 #include "confdefs.h"
6156 /* System header to define __stub macros and hopefully few prototypes,
6157     which can conflict with char $ac_func(); below.  */
6158 #include <assert.h>
6159 /* Override any gcc2 internal prototype to avoid an error.  */
6160 /* We use char because int might match the return type of a gcc2
6161     builtin and then its argument prototype would still apply.  */
6162 char $ac_func();
6163
6164 int main() {
6165
6166 /* The GNU C library defines this for functions which it implements
6167     to always fail with ENOSYS.  Some functions are actually named
6168     something starting with __ and the normal name is an alias.  */
6169 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6170 choke me
6171 #else
6172 $ac_func();
6173 #endif
6174
6175 ; return 0; }
6176 EOF
6177 if { (eval echo configure:6178: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6178   rm -rf conftest*
6179   eval "ac_cv_func_$ac_func=yes"
6180 else
6181   echo "configure: failed program was:" >&5
6182   cat conftest.$ac_ext >&5
6183   rm -rf conftest*
6184   eval "ac_cv_func_$ac_func=no"
6185 fi
6186 rm -f conftest*
6187 fi
6188
6189 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6190   echo "$ac_t""yes" 1>&6
6191     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6192   cat >> confdefs.h <<EOF
6193 #define $ac_tr_func 1
6194 EOF
6195
6196 else
6197   echo "$ac_t""no" 1>&6
6198 fi
6199 done
6200
6201   fi
6202
6203
6204
6205   ac_ext=C
6206 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6207 ac_cpp='$CXXCPP $CPPFLAGS'
6208 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6209 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6210 cross_compiling=$ac_cv_prog_cxx_cross
6211
6212   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6213 echo "configure:6214: checking for logf declaration" >&5
6214   cat > conftest.$ac_ext <<EOF
6215 #line 6216 "configure"
6216 #include "confdefs.h"
6217 #include <math.h>
6218 int main() {
6219  logf(0);
6220 ; return 0; }
6221 EOF
6222 if { (eval echo configure:6223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6223   rm -rf conftest*
6224   use_logf=yes
6225 else
6226   echo "configure: failed program was:" >&5
6227   cat conftest.$ac_ext >&5
6228   rm -rf conftest*
6229   use_logf=no
6230 fi
6231 rm -f conftest*
6232   echo "$ac_t""$use_logf" 1>&6
6233   ac_ext=c
6234 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6235 ac_cpp='$CPP $CPPFLAGS'
6236 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6237 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6238 cross_compiling=$ac_cv_prog_cc_cross
6239
6240   if test x$use_logf = x"yes"; then
6241     for ac_func in logf
6242 do
6243 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6244 echo "configure:6245: checking for $ac_func" >&5
6245 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6246   echo $ac_n "(cached) $ac_c" 1>&6
6247 else
6248   cat > conftest.$ac_ext <<EOF
6249 #line 6250 "configure"
6250 #include "confdefs.h"
6251 /* System header to define __stub macros and hopefully few prototypes,
6252     which can conflict with char $ac_func(); below.  */
6253 #include <assert.h>
6254 /* Override any gcc2 internal prototype to avoid an error.  */
6255 /* We use char because int might match the return type of a gcc2
6256     builtin and then its argument prototype would still apply.  */
6257 char $ac_func();
6258
6259 int main() {
6260
6261 /* The GNU C library defines this for functions which it implements
6262     to always fail with ENOSYS.  Some functions are actually named
6263     something starting with __ and the normal name is an alias.  */
6264 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6265 choke me
6266 #else
6267 $ac_func();
6268 #endif
6269
6270 ; return 0; }
6271 EOF
6272 if { (eval echo configure:6273: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6273   rm -rf conftest*
6274   eval "ac_cv_func_$ac_func=yes"
6275 else
6276   echo "configure: failed program was:" >&5
6277   cat conftest.$ac_ext >&5
6278   rm -rf conftest*
6279   eval "ac_cv_func_$ac_func=no"
6280 fi
6281 rm -f conftest*
6282 fi
6283
6284 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6285   echo "$ac_t""yes" 1>&6
6286     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6287   cat >> confdefs.h <<EOF
6288 #define $ac_tr_func 1
6289 EOF
6290
6291 else
6292   echo "$ac_t""no" 1>&6
6293 fi
6294 done
6295
6296   fi
6297
6298
6299
6300   ac_ext=C
6301 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6302 ac_cpp='$CXXCPP $CPPFLAGS'
6303 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6304 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6305 cross_compiling=$ac_cv_prog_cxx_cross
6306
6307   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
6308 echo "configure:6309: checking for log10f declaration" >&5
6309   cat > conftest.$ac_ext <<EOF
6310 #line 6311 "configure"
6311 #include "confdefs.h"
6312 #include <math.h>
6313 int main() {
6314  log10f(0);
6315 ; return 0; }
6316 EOF
6317 if { (eval echo configure:6318: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6318   rm -rf conftest*
6319   use_log10f=yes
6320 else
6321   echo "configure: failed program was:" >&5
6322   cat conftest.$ac_ext >&5
6323   rm -rf conftest*
6324   use_log10f=no
6325 fi
6326 rm -f conftest*
6327   echo "$ac_t""$use_log10f" 1>&6
6328   ac_ext=c
6329 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6330 ac_cpp='$CPP $CPPFLAGS'
6331 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6332 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6333 cross_compiling=$ac_cv_prog_cc_cross
6334
6335   if test x$use_log10f = x"yes"; then
6336     for ac_func in log10f
6337 do
6338 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6339 echo "configure:6340: checking for $ac_func" >&5
6340 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6341   echo $ac_n "(cached) $ac_c" 1>&6
6342 else
6343   cat > conftest.$ac_ext <<EOF
6344 #line 6345 "configure"
6345 #include "confdefs.h"
6346 /* System header to define __stub macros and hopefully few prototypes,
6347     which can conflict with char $ac_func(); below.  */
6348 #include <assert.h>
6349 /* Override any gcc2 internal prototype to avoid an error.  */
6350 /* We use char because int might match the return type of a gcc2
6351     builtin and then its argument prototype would still apply.  */
6352 char $ac_func();
6353
6354 int main() {
6355
6356 /* The GNU C library defines this for functions which it implements
6357     to always fail with ENOSYS.  Some functions are actually named
6358     something starting with __ and the normal name is an alias.  */
6359 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6360 choke me
6361 #else
6362 $ac_func();
6363 #endif
6364
6365 ; return 0; }
6366 EOF
6367 if { (eval echo configure:6368: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6368   rm -rf conftest*
6369   eval "ac_cv_func_$ac_func=yes"
6370 else
6371   echo "configure: failed program was:" >&5
6372   cat conftest.$ac_ext >&5
6373   rm -rf conftest*
6374   eval "ac_cv_func_$ac_func=no"
6375 fi
6376 rm -f conftest*
6377 fi
6378
6379 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6380   echo "$ac_t""yes" 1>&6
6381     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6382   cat >> confdefs.h <<EOF
6383 #define $ac_tr_func 1
6384 EOF
6385
6386 else
6387   echo "$ac_t""no" 1>&6
6388 fi
6389 done
6390
6391   fi
6392
6393
6394
6395   ac_ext=C
6396 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6397 ac_cpp='$CXXCPP $CPPFLAGS'
6398 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6399 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6400 cross_compiling=$ac_cv_prog_cxx_cross
6401
6402   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
6403 echo "configure:6404: checking for modff declaration" >&5
6404   cat > conftest.$ac_ext <<EOF
6405 #line 6406 "configure"
6406 #include "confdefs.h"
6407 #include <math.h>
6408 int main() {
6409  modff(0, 0);
6410 ; return 0; }
6411 EOF
6412 if { (eval echo configure:6413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6413   rm -rf conftest*
6414   use_modff=yes
6415 else
6416   echo "configure: failed program was:" >&5
6417   cat conftest.$ac_ext >&5
6418   rm -rf conftest*
6419   use_modff=no
6420 fi
6421 rm -f conftest*
6422   echo "$ac_t""$use_modff" 1>&6
6423   ac_ext=c
6424 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6425 ac_cpp='$CPP $CPPFLAGS'
6426 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6427 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6428 cross_compiling=$ac_cv_prog_cc_cross
6429
6430   if test x$use_modff = x"yes"; then
6431     for ac_func in modff
6432 do
6433 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6434 echo "configure:6435: checking for $ac_func" >&5
6435 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6436   echo $ac_n "(cached) $ac_c" 1>&6
6437 else
6438   cat > conftest.$ac_ext <<EOF
6439 #line 6440 "configure"
6440 #include "confdefs.h"
6441 /* System header to define __stub macros and hopefully few prototypes,
6442     which can conflict with char $ac_func(); below.  */
6443 #include <assert.h>
6444 /* Override any gcc2 internal prototype to avoid an error.  */
6445 /* We use char because int might match the return type of a gcc2
6446     builtin and then its argument prototype would still apply.  */
6447 char $ac_func();
6448
6449 int main() {
6450
6451 /* The GNU C library defines this for functions which it implements
6452     to always fail with ENOSYS.  Some functions are actually named
6453     something starting with __ and the normal name is an alias.  */
6454 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6455 choke me
6456 #else
6457 $ac_func();
6458 #endif
6459
6460 ; return 0; }
6461 EOF
6462 if { (eval echo configure:6463: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6463   rm -rf conftest*
6464   eval "ac_cv_func_$ac_func=yes"
6465 else
6466   echo "configure: failed program was:" >&5
6467   cat conftest.$ac_ext >&5
6468   rm -rf conftest*
6469   eval "ac_cv_func_$ac_func=no"
6470 fi
6471 rm -f conftest*
6472 fi
6473
6474 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6475   echo "$ac_t""yes" 1>&6
6476     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6477   cat >> confdefs.h <<EOF
6478 #define $ac_tr_func 1
6479 EOF
6480
6481 else
6482   echo "$ac_t""no" 1>&6
6483 fi
6484 done
6485
6486   fi
6487
6488
6489
6490   ac_ext=C
6491 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6492 ac_cpp='$CXXCPP $CPPFLAGS'
6493 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6494 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6495 cross_compiling=$ac_cv_prog_cxx_cross
6496
6497   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
6498 echo "configure:6499: checking for powf declaration" >&5
6499   cat > conftest.$ac_ext <<EOF
6500 #line 6501 "configure"
6501 #include "confdefs.h"
6502 #include <math.h>
6503 int main() {
6504  powf(0, 0);
6505 ; return 0; }
6506 EOF
6507 if { (eval echo configure:6508: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6508   rm -rf conftest*
6509   use_powf=yes
6510 else
6511   echo "configure: failed program was:" >&5
6512   cat conftest.$ac_ext >&5
6513   rm -rf conftest*
6514   use_powf=no
6515 fi
6516 rm -f conftest*
6517   echo "$ac_t""$use_powf" 1>&6
6518   ac_ext=c
6519 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6520 ac_cpp='$CPP $CPPFLAGS'
6521 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6522 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6523 cross_compiling=$ac_cv_prog_cc_cross
6524
6525   if test x$use_powf = x"yes"; then
6526     for ac_func in powf
6527 do
6528 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6529 echo "configure:6530: checking for $ac_func" >&5
6530 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6531   echo $ac_n "(cached) $ac_c" 1>&6
6532 else
6533   cat > conftest.$ac_ext <<EOF
6534 #line 6535 "configure"
6535 #include "confdefs.h"
6536 /* System header to define __stub macros and hopefully few prototypes,
6537     which can conflict with char $ac_func(); below.  */
6538 #include <assert.h>
6539 /* Override any gcc2 internal prototype to avoid an error.  */
6540 /* We use char because int might match the return type of a gcc2
6541     builtin and then its argument prototype would still apply.  */
6542 char $ac_func();
6543
6544 int main() {
6545
6546 /* The GNU C library defines this for functions which it implements
6547     to always fail with ENOSYS.  Some functions are actually named
6548     something starting with __ and the normal name is an alias.  */
6549 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6550 choke me
6551 #else
6552 $ac_func();
6553 #endif
6554
6555 ; return 0; }
6556 EOF
6557 if { (eval echo configure:6558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6558   rm -rf conftest*
6559   eval "ac_cv_func_$ac_func=yes"
6560 else
6561   echo "configure: failed program was:" >&5
6562   cat conftest.$ac_ext >&5
6563   rm -rf conftest*
6564   eval "ac_cv_func_$ac_func=no"
6565 fi
6566 rm -f conftest*
6567 fi
6568
6569 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6570   echo "$ac_t""yes" 1>&6
6571     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6572   cat >> confdefs.h <<EOF
6573 #define $ac_tr_func 1
6574 EOF
6575
6576 else
6577   echo "$ac_t""no" 1>&6
6578 fi
6579 done
6580
6581   fi
6582
6583
6584
6585   ac_ext=C
6586 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6587 ac_cpp='$CXXCPP $CPPFLAGS'
6588 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6589 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6590 cross_compiling=$ac_cv_prog_cxx_cross
6591
6592   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
6593 echo "configure:6594: checking for sinf declaration" >&5
6594   cat > conftest.$ac_ext <<EOF
6595 #line 6596 "configure"
6596 #include "confdefs.h"
6597 #include <math.h>
6598 int main() {
6599  sinf(0);
6600 ; return 0; }
6601 EOF
6602 if { (eval echo configure:6603: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6603   rm -rf conftest*
6604   use_sinf=yes
6605 else
6606   echo "configure: failed program was:" >&5
6607   cat conftest.$ac_ext >&5
6608   rm -rf conftest*
6609   use_sinf=no
6610 fi
6611 rm -f conftest*
6612   echo "$ac_t""$use_sinf" 1>&6
6613   ac_ext=c
6614 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6615 ac_cpp='$CPP $CPPFLAGS'
6616 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6617 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6618 cross_compiling=$ac_cv_prog_cc_cross
6619
6620   if test x$use_sinf = x"yes"; then
6621     for ac_func in sinf
6622 do
6623 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6624 echo "configure:6625: checking for $ac_func" >&5
6625 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6626   echo $ac_n "(cached) $ac_c" 1>&6
6627 else
6628   cat > conftest.$ac_ext <<EOF
6629 #line 6630 "configure"
6630 #include "confdefs.h"
6631 /* System header to define __stub macros and hopefully few prototypes,
6632     which can conflict with char $ac_func(); below.  */
6633 #include <assert.h>
6634 /* Override any gcc2 internal prototype to avoid an error.  */
6635 /* We use char because int might match the return type of a gcc2
6636     builtin and then its argument prototype would still apply.  */
6637 char $ac_func();
6638
6639 int main() {
6640
6641 /* The GNU C library defines this for functions which it implements
6642     to always fail with ENOSYS.  Some functions are actually named
6643     something starting with __ and the normal name is an alias.  */
6644 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6645 choke me
6646 #else
6647 $ac_func();
6648 #endif
6649
6650 ; return 0; }
6651 EOF
6652 if { (eval echo configure:6653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6653   rm -rf conftest*
6654   eval "ac_cv_func_$ac_func=yes"
6655 else
6656   echo "configure: failed program was:" >&5
6657   cat conftest.$ac_ext >&5
6658   rm -rf conftest*
6659   eval "ac_cv_func_$ac_func=no"
6660 fi
6661 rm -f conftest*
6662 fi
6663
6664 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6665   echo "$ac_t""yes" 1>&6
6666     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6667   cat >> confdefs.h <<EOF
6668 #define $ac_tr_func 1
6669 EOF
6670
6671 else
6672   echo "$ac_t""no" 1>&6
6673 fi
6674 done
6675
6676   fi
6677
6678
6679
6680   ac_ext=C
6681 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6682 ac_cpp='$CXXCPP $CPPFLAGS'
6683 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6684 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6685 cross_compiling=$ac_cv_prog_cxx_cross
6686
6687   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
6688 echo "configure:6689: checking for sinhf declaration" >&5
6689   cat > conftest.$ac_ext <<EOF
6690 #line 6691 "configure"
6691 #include "confdefs.h"
6692 #include <math.h>
6693 int main() {
6694  sinhf(0);
6695 ; return 0; }
6696 EOF
6697 if { (eval echo configure:6698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6698   rm -rf conftest*
6699   use_sinhf=yes
6700 else
6701   echo "configure: failed program was:" >&5
6702   cat conftest.$ac_ext >&5
6703   rm -rf conftest*
6704   use_sinhf=no
6705 fi
6706 rm -f conftest*
6707   echo "$ac_t""$use_sinhf" 1>&6
6708   ac_ext=c
6709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6710 ac_cpp='$CPP $CPPFLAGS'
6711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6713 cross_compiling=$ac_cv_prog_cc_cross
6714
6715   if test x$use_sinhf = x"yes"; then
6716     for ac_func in sinhf
6717 do
6718 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6719 echo "configure:6720: checking for $ac_func" >&5
6720 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6721   echo $ac_n "(cached) $ac_c" 1>&6
6722 else
6723   cat > conftest.$ac_ext <<EOF
6724 #line 6725 "configure"
6725 #include "confdefs.h"
6726 /* System header to define __stub macros and hopefully few prototypes,
6727     which can conflict with char $ac_func(); below.  */
6728 #include <assert.h>
6729 /* Override any gcc2 internal prototype to avoid an error.  */
6730 /* We use char because int might match the return type of a gcc2
6731     builtin and then its argument prototype would still apply.  */
6732 char $ac_func();
6733
6734 int main() {
6735
6736 /* The GNU C library defines this for functions which it implements
6737     to always fail with ENOSYS.  Some functions are actually named
6738     something starting with __ and the normal name is an alias.  */
6739 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6740 choke me
6741 #else
6742 $ac_func();
6743 #endif
6744
6745 ; return 0; }
6746 EOF
6747 if { (eval echo configure:6748: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6748   rm -rf conftest*
6749   eval "ac_cv_func_$ac_func=yes"
6750 else
6751   echo "configure: failed program was:" >&5
6752   cat conftest.$ac_ext >&5
6753   rm -rf conftest*
6754   eval "ac_cv_func_$ac_func=no"
6755 fi
6756 rm -f conftest*
6757 fi
6758
6759 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6760   echo "$ac_t""yes" 1>&6
6761     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6762   cat >> confdefs.h <<EOF
6763 #define $ac_tr_func 1
6764 EOF
6765
6766 else
6767   echo "$ac_t""no" 1>&6
6768 fi
6769 done
6770
6771   fi
6772
6773
6774
6775   ac_ext=C
6776 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6777 ac_cpp='$CXXCPP $CPPFLAGS'
6778 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6779 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6780 cross_compiling=$ac_cv_prog_cxx_cross
6781
6782   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
6783 echo "configure:6784: checking for sqrtf declaration" >&5
6784   cat > conftest.$ac_ext <<EOF
6785 #line 6786 "configure"
6786 #include "confdefs.h"
6787 #include <math.h>
6788 int main() {
6789  sqrtf(0);
6790 ; return 0; }
6791 EOF
6792 if { (eval echo configure:6793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6793   rm -rf conftest*
6794   use_sqrtf=yes
6795 else
6796   echo "configure: failed program was:" >&5
6797   cat conftest.$ac_ext >&5
6798   rm -rf conftest*
6799   use_sqrtf=no
6800 fi
6801 rm -f conftest*
6802   echo "$ac_t""$use_sqrtf" 1>&6
6803   ac_ext=c
6804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6805 ac_cpp='$CPP $CPPFLAGS'
6806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6808 cross_compiling=$ac_cv_prog_cc_cross
6809
6810   if test x$use_sqrtf = x"yes"; then
6811     for ac_func in sqrtf
6812 do
6813 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6814 echo "configure:6815: checking for $ac_func" >&5
6815 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6816   echo $ac_n "(cached) $ac_c" 1>&6
6817 else
6818   cat > conftest.$ac_ext <<EOF
6819 #line 6820 "configure"
6820 #include "confdefs.h"
6821 /* System header to define __stub macros and hopefully few prototypes,
6822     which can conflict with char $ac_func(); below.  */
6823 #include <assert.h>
6824 /* Override any gcc2 internal prototype to avoid an error.  */
6825 /* We use char because int might match the return type of a gcc2
6826     builtin and then its argument prototype would still apply.  */
6827 char $ac_func();
6828
6829 int main() {
6830
6831 /* The GNU C library defines this for functions which it implements
6832     to always fail with ENOSYS.  Some functions are actually named
6833     something starting with __ and the normal name is an alias.  */
6834 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6835 choke me
6836 #else
6837 $ac_func();
6838 #endif
6839
6840 ; return 0; }
6841 EOF
6842 if { (eval echo configure:6843: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6843   rm -rf conftest*
6844   eval "ac_cv_func_$ac_func=yes"
6845 else
6846   echo "configure: failed program was:" >&5
6847   cat conftest.$ac_ext >&5
6848   rm -rf conftest*
6849   eval "ac_cv_func_$ac_func=no"
6850 fi
6851 rm -f conftest*
6852 fi
6853
6854 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6855   echo "$ac_t""yes" 1>&6
6856     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6857   cat >> confdefs.h <<EOF
6858 #define $ac_tr_func 1
6859 EOF
6860
6861 else
6862   echo "$ac_t""no" 1>&6
6863 fi
6864 done
6865
6866   fi
6867
6868
6869
6870   ac_ext=C
6871 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6872 ac_cpp='$CXXCPP $CPPFLAGS'
6873 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6874 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6875 cross_compiling=$ac_cv_prog_cxx_cross
6876
6877   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
6878 echo "configure:6879: checking for tanf declaration" >&5
6879   cat > conftest.$ac_ext <<EOF
6880 #line 6881 "configure"
6881 #include "confdefs.h"
6882 #include <math.h>
6883 int main() {
6884  tanf(0);
6885 ; return 0; }
6886 EOF
6887 if { (eval echo configure:6888: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6888   rm -rf conftest*
6889   use_tanf=yes
6890 else
6891   echo "configure: failed program was:" >&5
6892   cat conftest.$ac_ext >&5
6893   rm -rf conftest*
6894   use_tanf=no
6895 fi
6896 rm -f conftest*
6897   echo "$ac_t""$use_tanf" 1>&6
6898   ac_ext=c
6899 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6900 ac_cpp='$CPP $CPPFLAGS'
6901 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6902 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6903 cross_compiling=$ac_cv_prog_cc_cross
6904
6905   if test x$use_tanf = x"yes"; then
6906     for ac_func in tanf
6907 do
6908 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6909 echo "configure:6910: checking for $ac_func" >&5
6910 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6911   echo $ac_n "(cached) $ac_c" 1>&6
6912 else
6913   cat > conftest.$ac_ext <<EOF
6914 #line 6915 "configure"
6915 #include "confdefs.h"
6916 /* System header to define __stub macros and hopefully few prototypes,
6917     which can conflict with char $ac_func(); below.  */
6918 #include <assert.h>
6919 /* Override any gcc2 internal prototype to avoid an error.  */
6920 /* We use char because int might match the return type of a gcc2
6921     builtin and then its argument prototype would still apply.  */
6922 char $ac_func();
6923
6924 int main() {
6925
6926 /* The GNU C library defines this for functions which it implements
6927     to always fail with ENOSYS.  Some functions are actually named
6928     something starting with __ and the normal name is an alias.  */
6929 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6930 choke me
6931 #else
6932 $ac_func();
6933 #endif
6934
6935 ; return 0; }
6936 EOF
6937 if { (eval echo configure:6938: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6938   rm -rf conftest*
6939   eval "ac_cv_func_$ac_func=yes"
6940 else
6941   echo "configure: failed program was:" >&5
6942   cat conftest.$ac_ext >&5
6943   rm -rf conftest*
6944   eval "ac_cv_func_$ac_func=no"
6945 fi
6946 rm -f conftest*
6947 fi
6948
6949 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6950   echo "$ac_t""yes" 1>&6
6951     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6952   cat >> confdefs.h <<EOF
6953 #define $ac_tr_func 1
6954 EOF
6955
6956 else
6957   echo "$ac_t""no" 1>&6
6958 fi
6959 done
6960
6961   fi
6962
6963
6964
6965   ac_ext=C
6966 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6967 ac_cpp='$CXXCPP $CPPFLAGS'
6968 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6969 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6970 cross_compiling=$ac_cv_prog_cxx_cross
6971
6972   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
6973 echo "configure:6974: checking for tanhf declaration" >&5
6974   cat > conftest.$ac_ext <<EOF
6975 #line 6976 "configure"
6976 #include "confdefs.h"
6977 #include <math.h>
6978 int main() {
6979  tanhf(0);
6980 ; return 0; }
6981 EOF
6982 if { (eval echo configure:6983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6983   rm -rf conftest*
6984   use_tanhf=yes
6985 else
6986   echo "configure: failed program was:" >&5
6987   cat conftest.$ac_ext >&5
6988   rm -rf conftest*
6989   use_tanhf=no
6990 fi
6991 rm -f conftest*
6992   echo "$ac_t""$use_tanhf" 1>&6
6993   ac_ext=c
6994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6995 ac_cpp='$CPP $CPPFLAGS'
6996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6998 cross_compiling=$ac_cv_prog_cc_cross
6999
7000   if test x$use_tanhf = x"yes"; then
7001     for ac_func in tanhf
7002 do
7003 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7004 echo "configure:7005: checking for $ac_func" >&5
7005 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7006   echo $ac_n "(cached) $ac_c" 1>&6
7007 else
7008   cat > conftest.$ac_ext <<EOF
7009 #line 7010 "configure"
7010 #include "confdefs.h"
7011 /* System header to define __stub macros and hopefully few prototypes,
7012     which can conflict with char $ac_func(); below.  */
7013 #include <assert.h>
7014 /* Override any gcc2 internal prototype to avoid an error.  */
7015 /* We use char because int might match the return type of a gcc2
7016     builtin and then its argument prototype would still apply.  */
7017 char $ac_func();
7018
7019 int main() {
7020
7021 /* The GNU C library defines this for functions which it implements
7022     to always fail with ENOSYS.  Some functions are actually named
7023     something starting with __ and the normal name is an alias.  */
7024 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7025 choke me
7026 #else
7027 $ac_func();
7028 #endif
7029
7030 ; return 0; }
7031 EOF
7032 if { (eval echo configure:7033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7033   rm -rf conftest*
7034   eval "ac_cv_func_$ac_func=yes"
7035 else
7036   echo "configure: failed program was:" >&5
7037   cat conftest.$ac_ext >&5
7038   rm -rf conftest*
7039   eval "ac_cv_func_$ac_func=no"
7040 fi
7041 rm -f conftest*
7042 fi
7043
7044 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7045   echo "$ac_t""yes" 1>&6
7046     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7047   cat >> confdefs.h <<EOF
7048 #define $ac_tr_func 1
7049 EOF
7050
7051 else
7052   echo "$ac_t""no" 1>&6
7053 fi
7054 done
7055
7056   fi
7057
7058
7059
7060   ac_ext=C
7061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7062 ac_cpp='$CXXCPP $CPPFLAGS'
7063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7065 cross_compiling=$ac_cv_prog_cxx_cross
7066
7067   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7068 echo "configure:7069: checking for sincosf declaration" >&5
7069   cat > conftest.$ac_ext <<EOF
7070 #line 7071 "configure"
7071 #include "confdefs.h"
7072 #include <math.h>
7073 int main() {
7074  sincosf(0, 0, 0);
7075 ; return 0; }
7076 EOF
7077 if { (eval echo configure:7078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7078   rm -rf conftest*
7079   use_sincosf=yes
7080 else
7081   echo "configure: failed program was:" >&5
7082   cat conftest.$ac_ext >&5
7083   rm -rf conftest*
7084   use_sincosf=no
7085 fi
7086 rm -f conftest*
7087   echo "$ac_t""$use_sincosf" 1>&6
7088   ac_ext=c
7089 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7090 ac_cpp='$CPP $CPPFLAGS'
7091 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7092 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7093 cross_compiling=$ac_cv_prog_cc_cross
7094
7095   if test x$use_sincosf = x"yes"; then
7096     for ac_func in sincosf
7097 do
7098 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7099 echo "configure:7100: checking for $ac_func" >&5
7100 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7101   echo $ac_n "(cached) $ac_c" 1>&6
7102 else
7103   cat > conftest.$ac_ext <<EOF
7104 #line 7105 "configure"
7105 #include "confdefs.h"
7106 /* System header to define __stub macros and hopefully few prototypes,
7107     which can conflict with char $ac_func(); below.  */
7108 #include <assert.h>
7109 /* Override any gcc2 internal prototype to avoid an error.  */
7110 /* We use char because int might match the return type of a gcc2
7111     builtin and then its argument prototype would still apply.  */
7112 char $ac_func();
7113
7114 int main() {
7115
7116 /* The GNU C library defines this for functions which it implements
7117     to always fail with ENOSYS.  Some functions are actually named
7118     something starting with __ and the normal name is an alias.  */
7119 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7120 choke me
7121 #else
7122 $ac_func();
7123 #endif
7124
7125 ; return 0; }
7126 EOF
7127 if { (eval echo configure:7128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7128   rm -rf conftest*
7129   eval "ac_cv_func_$ac_func=yes"
7130 else
7131   echo "configure: failed program was:" >&5
7132   cat conftest.$ac_ext >&5
7133   rm -rf conftest*
7134   eval "ac_cv_func_$ac_func=no"
7135 fi
7136 rm -f conftest*
7137 fi
7138
7139 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7140   echo "$ac_t""yes" 1>&6
7141     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7142   cat >> confdefs.h <<EOF
7143 #define $ac_tr_func 1
7144 EOF
7145
7146 else
7147   echo "$ac_t""no" 1>&6
7148 fi
7149 done
7150
7151   fi
7152
7153
7154
7155   ac_ext=C
7156 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7157 ac_cpp='$CXXCPP $CPPFLAGS'
7158 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7159 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7160 cross_compiling=$ac_cv_prog_cxx_cross
7161
7162   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
7163 echo "configure:7164: checking for finitef declaration" >&5
7164   cat > conftest.$ac_ext <<EOF
7165 #line 7166 "configure"
7166 #include "confdefs.h"
7167 #include <math.h>
7168 int main() {
7169  finitef(0);
7170 ; return 0; }
7171 EOF
7172 if { (eval echo configure:7173: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7173   rm -rf conftest*
7174   use_finitef=yes
7175 else
7176   echo "configure: failed program was:" >&5
7177   cat conftest.$ac_ext >&5
7178   rm -rf conftest*
7179   use_finitef=no
7180 fi
7181 rm -f conftest*
7182   echo "$ac_t""$use_finitef" 1>&6
7183   ac_ext=c
7184 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7185 ac_cpp='$CPP $CPPFLAGS'
7186 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7187 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7188 cross_compiling=$ac_cv_prog_cc_cross
7189
7190   if test x$use_finitef = x"yes"; then
7191     for ac_func in finitef
7192 do
7193 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7194 echo "configure:7195: checking for $ac_func" >&5
7195 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7196   echo $ac_n "(cached) $ac_c" 1>&6
7197 else
7198   cat > conftest.$ac_ext <<EOF
7199 #line 7200 "configure"
7200 #include "confdefs.h"
7201 /* System header to define __stub macros and hopefully few prototypes,
7202     which can conflict with char $ac_func(); below.  */
7203 #include <assert.h>
7204 /* Override any gcc2 internal prototype to avoid an error.  */
7205 /* We use char because int might match the return type of a gcc2
7206     builtin and then its argument prototype would still apply.  */
7207 char $ac_func();
7208
7209 int main() {
7210
7211 /* The GNU C library defines this for functions which it implements
7212     to always fail with ENOSYS.  Some functions are actually named
7213     something starting with __ and the normal name is an alias.  */
7214 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7215 choke me
7216 #else
7217 $ac_func();
7218 #endif
7219
7220 ; return 0; }
7221 EOF
7222 if { (eval echo configure:7223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7223   rm -rf conftest*
7224   eval "ac_cv_func_$ac_func=yes"
7225 else
7226   echo "configure: failed program was:" >&5
7227   cat conftest.$ac_ext >&5
7228   rm -rf conftest*
7229   eval "ac_cv_func_$ac_func=no"
7230 fi
7231 rm -f conftest*
7232 fi
7233
7234 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7235   echo "$ac_t""yes" 1>&6
7236     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7237   cat >> confdefs.h <<EOF
7238 #define $ac_tr_func 1
7239 EOF
7240
7241 else
7242   echo "$ac_t""no" 1>&6
7243 fi
7244 done
7245
7246   fi
7247
7248
7249
7250
7251   ac_ext=C
7252 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7253 ac_cpp='$CXXCPP $CPPFLAGS'
7254 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7255 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7256 cross_compiling=$ac_cv_prog_cxx_cross
7257
7258   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
7259 echo "configure:7260: checking for isnanl declaration" >&5
7260   cat > conftest.$ac_ext <<EOF
7261 #line 7262 "configure"
7262 #include "confdefs.h"
7263 #include <math.h>
7264 int main() {
7265  isnanl(0);
7266 ; return 0; }
7267 EOF
7268 if { (eval echo configure:7269: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7269   rm -rf conftest*
7270   use_isnanl=yes
7271 else
7272   echo "configure: failed program was:" >&5
7273   cat conftest.$ac_ext >&5
7274   rm -rf conftest*
7275   use_isnanl=no
7276 fi
7277 rm -f conftest*
7278   echo "$ac_t""$use_isnanl" 1>&6
7279   ac_ext=c
7280 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7281 ac_cpp='$CPP $CPPFLAGS'
7282 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7283 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7284 cross_compiling=$ac_cv_prog_cc_cross
7285
7286   if test x$use_isnanl = x"yes"; then
7287     for ac_func in isnanl
7288 do
7289 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7290 echo "configure:7291: checking for $ac_func" >&5
7291 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7292   echo $ac_n "(cached) $ac_c" 1>&6
7293 else
7294   cat > conftest.$ac_ext <<EOF
7295 #line 7296 "configure"
7296 #include "confdefs.h"
7297 /* System header to define __stub macros and hopefully few prototypes,
7298     which can conflict with char $ac_func(); below.  */
7299 #include <assert.h>
7300 /* Override any gcc2 internal prototype to avoid an error.  */
7301 /* We use char because int might match the return type of a gcc2
7302     builtin and then its argument prototype would still apply.  */
7303 char $ac_func();
7304
7305 int main() {
7306
7307 /* The GNU C library defines this for functions which it implements
7308     to always fail with ENOSYS.  Some functions are actually named
7309     something starting with __ and the normal name is an alias.  */
7310 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7311 choke me
7312 #else
7313 $ac_func();
7314 #endif
7315
7316 ; return 0; }
7317 EOF
7318 if { (eval echo configure:7319: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7319   rm -rf conftest*
7320   eval "ac_cv_func_$ac_func=yes"
7321 else
7322   echo "configure: failed program was:" >&5
7323   cat conftest.$ac_ext >&5
7324   rm -rf conftest*
7325   eval "ac_cv_func_$ac_func=no"
7326 fi
7327 rm -f conftest*
7328 fi
7329
7330 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7331   echo "$ac_t""yes" 1>&6
7332     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7333   cat >> confdefs.h <<EOF
7334 #define $ac_tr_func 1
7335 EOF
7336
7337 else
7338   echo "$ac_t""no" 1>&6
7339 fi
7340 done
7341
7342   fi
7343
7344
7345
7346   ac_ext=C
7347 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7348 ac_cpp='$CXXCPP $CPPFLAGS'
7349 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7350 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7351 cross_compiling=$ac_cv_prog_cxx_cross
7352
7353   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
7354 echo "configure:7355: checking for isinfl declaration" >&5
7355   cat > conftest.$ac_ext <<EOF
7356 #line 7357 "configure"
7357 #include "confdefs.h"
7358 #include <math.h>
7359 int main() {
7360  isinfl(0);
7361 ; return 0; }
7362 EOF
7363 if { (eval echo configure:7364: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7364   rm -rf conftest*
7365   use_isinfl=yes
7366 else
7367   echo "configure: failed program was:" >&5
7368   cat conftest.$ac_ext >&5
7369   rm -rf conftest*
7370   use_isinfl=no
7371 fi
7372 rm -f conftest*
7373   echo "$ac_t""$use_isinfl" 1>&6
7374   ac_ext=c
7375 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7376 ac_cpp='$CPP $CPPFLAGS'
7377 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7378 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7379 cross_compiling=$ac_cv_prog_cc_cross
7380
7381   if test x$use_isinfl = x"yes"; then
7382     for ac_func in isinfl
7383 do
7384 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7385 echo "configure:7386: checking for $ac_func" >&5
7386 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7387   echo $ac_n "(cached) $ac_c" 1>&6
7388 else
7389   cat > conftest.$ac_ext <<EOF
7390 #line 7391 "configure"
7391 #include "confdefs.h"
7392 /* System header to define __stub macros and hopefully few prototypes,
7393     which can conflict with char $ac_func(); below.  */
7394 #include <assert.h>
7395 /* Override any gcc2 internal prototype to avoid an error.  */
7396 /* We use char because int might match the return type of a gcc2
7397     builtin and then its argument prototype would still apply.  */
7398 char $ac_func();
7399
7400 int main() {
7401
7402 /* The GNU C library defines this for functions which it implements
7403     to always fail with ENOSYS.  Some functions are actually named
7404     something starting with __ and the normal name is an alias.  */
7405 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7406 choke me
7407 #else
7408 $ac_func();
7409 #endif
7410
7411 ; return 0; }
7412 EOF
7413 if { (eval echo configure:7414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7414   rm -rf conftest*
7415   eval "ac_cv_func_$ac_func=yes"
7416 else
7417   echo "configure: failed program was:" >&5
7418   cat conftest.$ac_ext >&5
7419   rm -rf conftest*
7420   eval "ac_cv_func_$ac_func=no"
7421 fi
7422 rm -f conftest*
7423 fi
7424
7425 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7426   echo "$ac_t""yes" 1>&6
7427     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7428   cat >> confdefs.h <<EOF
7429 #define $ac_tr_func 1
7430 EOF
7431
7432 else
7433   echo "$ac_t""no" 1>&6
7434 fi
7435 done
7436
7437   fi
7438
7439
7440
7441   ac_ext=C
7442 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7443 ac_cpp='$CXXCPP $CPPFLAGS'
7444 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7445 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7446 cross_compiling=$ac_cv_prog_cxx_cross
7447
7448   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
7449 echo "configure:7450: checking for copysignl declaration" >&5
7450   cat > conftest.$ac_ext <<EOF
7451 #line 7452 "configure"
7452 #include "confdefs.h"
7453 #include <math.h>
7454 int main() {
7455  copysignl(0, 0);
7456 ; return 0; }
7457 EOF
7458 if { (eval echo configure:7459: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7459   rm -rf conftest*
7460   use_copysignl=yes
7461 else
7462   echo "configure: failed program was:" >&5
7463   cat conftest.$ac_ext >&5
7464   rm -rf conftest*
7465   use_copysignl=no
7466 fi
7467 rm -f conftest*
7468   echo "$ac_t""$use_copysignl" 1>&6
7469   ac_ext=c
7470 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7471 ac_cpp='$CPP $CPPFLAGS'
7472 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7473 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7474 cross_compiling=$ac_cv_prog_cc_cross
7475
7476   if test x$use_copysignl = x"yes"; then
7477     for ac_func in copysignl
7478 do
7479 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7480 echo "configure:7481: checking for $ac_func" >&5
7481 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7482   echo $ac_n "(cached) $ac_c" 1>&6
7483 else
7484   cat > conftest.$ac_ext <<EOF
7485 #line 7486 "configure"
7486 #include "confdefs.h"
7487 /* System header to define __stub macros and hopefully few prototypes,
7488     which can conflict with char $ac_func(); below.  */
7489 #include <assert.h>
7490 /* Override any gcc2 internal prototype to avoid an error.  */
7491 /* We use char because int might match the return type of a gcc2
7492     builtin and then its argument prototype would still apply.  */
7493 char $ac_func();
7494
7495 int main() {
7496
7497 /* The GNU C library defines this for functions which it implements
7498     to always fail with ENOSYS.  Some functions are actually named
7499     something starting with __ and the normal name is an alias.  */
7500 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7501 choke me
7502 #else
7503 $ac_func();
7504 #endif
7505
7506 ; return 0; }
7507 EOF
7508 if { (eval echo configure:7509: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7509   rm -rf conftest*
7510   eval "ac_cv_func_$ac_func=yes"
7511 else
7512   echo "configure: failed program was:" >&5
7513   cat conftest.$ac_ext >&5
7514   rm -rf conftest*
7515   eval "ac_cv_func_$ac_func=no"
7516 fi
7517 rm -f conftest*
7518 fi
7519
7520 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7521   echo "$ac_t""yes" 1>&6
7522     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7523   cat >> confdefs.h <<EOF
7524 #define $ac_tr_func 1
7525 EOF
7526
7527 else
7528   echo "$ac_t""no" 1>&6
7529 fi
7530 done
7531
7532   fi
7533
7534
7535
7536   ac_ext=C
7537 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7538 ac_cpp='$CXXCPP $CPPFLAGS'
7539 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7540 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7541 cross_compiling=$ac_cv_prog_cxx_cross
7542
7543   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
7544 echo "configure:7545: checking for acosl declaration" >&5
7545   cat > conftest.$ac_ext <<EOF
7546 #line 7547 "configure"
7547 #include "confdefs.h"
7548 #include <math.h>
7549 int main() {
7550  acosl(0);
7551 ; return 0; }
7552 EOF
7553 if { (eval echo configure:7554: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7554   rm -rf conftest*
7555   use_acosl=yes
7556 else
7557   echo "configure: failed program was:" >&5
7558   cat conftest.$ac_ext >&5
7559   rm -rf conftest*
7560   use_acosl=no
7561 fi
7562 rm -f conftest*
7563   echo "$ac_t""$use_acosl" 1>&6
7564   ac_ext=c
7565 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7566 ac_cpp='$CPP $CPPFLAGS'
7567 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7568 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7569 cross_compiling=$ac_cv_prog_cc_cross
7570
7571   if test x$use_acosl = x"yes"; then
7572     for ac_func in acosl
7573 do
7574 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7575 echo "configure:7576: checking for $ac_func" >&5
7576 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7577   echo $ac_n "(cached) $ac_c" 1>&6
7578 else
7579   cat > conftest.$ac_ext <<EOF
7580 #line 7581 "configure"
7581 #include "confdefs.h"
7582 /* System header to define __stub macros and hopefully few prototypes,
7583     which can conflict with char $ac_func(); below.  */
7584 #include <assert.h>
7585 /* Override any gcc2 internal prototype to avoid an error.  */
7586 /* We use char because int might match the return type of a gcc2
7587     builtin and then its argument prototype would still apply.  */
7588 char $ac_func();
7589
7590 int main() {
7591
7592 /* The GNU C library defines this for functions which it implements
7593     to always fail with ENOSYS.  Some functions are actually named
7594     something starting with __ and the normal name is an alias.  */
7595 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7596 choke me
7597 #else
7598 $ac_func();
7599 #endif
7600
7601 ; return 0; }
7602 EOF
7603 if { (eval echo configure:7604: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7604   rm -rf conftest*
7605   eval "ac_cv_func_$ac_func=yes"
7606 else
7607   echo "configure: failed program was:" >&5
7608   cat conftest.$ac_ext >&5
7609   rm -rf conftest*
7610   eval "ac_cv_func_$ac_func=no"
7611 fi
7612 rm -f conftest*
7613 fi
7614
7615 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7616   echo "$ac_t""yes" 1>&6
7617     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7618   cat >> confdefs.h <<EOF
7619 #define $ac_tr_func 1
7620 EOF
7621
7622 else
7623   echo "$ac_t""no" 1>&6
7624 fi
7625 done
7626
7627   fi
7628
7629
7630
7631   ac_ext=C
7632 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7633 ac_cpp='$CXXCPP $CPPFLAGS'
7634 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7635 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7636 cross_compiling=$ac_cv_prog_cxx_cross
7637
7638   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
7639 echo "configure:7640: checking for asinl declaration" >&5
7640   cat > conftest.$ac_ext <<EOF
7641 #line 7642 "configure"
7642 #include "confdefs.h"
7643 #include <math.h>
7644 int main() {
7645  asinl(0);
7646 ; return 0; }
7647 EOF
7648 if { (eval echo configure:7649: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7649   rm -rf conftest*
7650   use_asinl=yes
7651 else
7652   echo "configure: failed program was:" >&5
7653   cat conftest.$ac_ext >&5
7654   rm -rf conftest*
7655   use_asinl=no
7656 fi
7657 rm -f conftest*
7658   echo "$ac_t""$use_asinl" 1>&6
7659   ac_ext=c
7660 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7661 ac_cpp='$CPP $CPPFLAGS'
7662 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7663 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7664 cross_compiling=$ac_cv_prog_cc_cross
7665
7666   if test x$use_asinl = x"yes"; then
7667     for ac_func in asinl
7668 do
7669 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7670 echo "configure:7671: checking for $ac_func" >&5
7671 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7672   echo $ac_n "(cached) $ac_c" 1>&6
7673 else
7674   cat > conftest.$ac_ext <<EOF
7675 #line 7676 "configure"
7676 #include "confdefs.h"
7677 /* System header to define __stub macros and hopefully few prototypes,
7678     which can conflict with char $ac_func(); below.  */
7679 #include <assert.h>
7680 /* Override any gcc2 internal prototype to avoid an error.  */
7681 /* We use char because int might match the return type of a gcc2
7682     builtin and then its argument prototype would still apply.  */
7683 char $ac_func();
7684
7685 int main() {
7686
7687 /* The GNU C library defines this for functions which it implements
7688     to always fail with ENOSYS.  Some functions are actually named
7689     something starting with __ and the normal name is an alias.  */
7690 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7691 choke me
7692 #else
7693 $ac_func();
7694 #endif
7695
7696 ; return 0; }
7697 EOF
7698 if { (eval echo configure:7699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7699   rm -rf conftest*
7700   eval "ac_cv_func_$ac_func=yes"
7701 else
7702   echo "configure: failed program was:" >&5
7703   cat conftest.$ac_ext >&5
7704   rm -rf conftest*
7705   eval "ac_cv_func_$ac_func=no"
7706 fi
7707 rm -f conftest*
7708 fi
7709
7710 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7711   echo "$ac_t""yes" 1>&6
7712     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7713   cat >> confdefs.h <<EOF
7714 #define $ac_tr_func 1
7715 EOF
7716
7717 else
7718   echo "$ac_t""no" 1>&6
7719 fi
7720 done
7721
7722   fi
7723
7724
7725
7726   ac_ext=C
7727 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7728 ac_cpp='$CXXCPP $CPPFLAGS'
7729 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7730 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7731 cross_compiling=$ac_cv_prog_cxx_cross
7732
7733   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
7734 echo "configure:7735: checking for atanl declaration" >&5
7735   cat > conftest.$ac_ext <<EOF
7736 #line 7737 "configure"
7737 #include "confdefs.h"
7738 #include <math.h>
7739 int main() {
7740  atanl(0);
7741 ; return 0; }
7742 EOF
7743 if { (eval echo configure:7744: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7744   rm -rf conftest*
7745   use_atanl=yes
7746 else
7747   echo "configure: failed program was:" >&5
7748   cat conftest.$ac_ext >&5
7749   rm -rf conftest*
7750   use_atanl=no
7751 fi
7752 rm -f conftest*
7753   echo "$ac_t""$use_atanl" 1>&6
7754   ac_ext=c
7755 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7756 ac_cpp='$CPP $CPPFLAGS'
7757 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7758 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7759 cross_compiling=$ac_cv_prog_cc_cross
7760
7761   if test x$use_atanl = x"yes"; then
7762     for ac_func in atanl
7763 do
7764 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7765 echo "configure:7766: checking for $ac_func" >&5
7766 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7767   echo $ac_n "(cached) $ac_c" 1>&6
7768 else
7769   cat > conftest.$ac_ext <<EOF
7770 #line 7771 "configure"
7771 #include "confdefs.h"
7772 /* System header to define __stub macros and hopefully few prototypes,
7773     which can conflict with char $ac_func(); below.  */
7774 #include <assert.h>
7775 /* Override any gcc2 internal prototype to avoid an error.  */
7776 /* We use char because int might match the return type of a gcc2
7777     builtin and then its argument prototype would still apply.  */
7778 char $ac_func();
7779
7780 int main() {
7781
7782 /* The GNU C library defines this for functions which it implements
7783     to always fail with ENOSYS.  Some functions are actually named
7784     something starting with __ and the normal name is an alias.  */
7785 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7786 choke me
7787 #else
7788 $ac_func();
7789 #endif
7790
7791 ; return 0; }
7792 EOF
7793 if { (eval echo configure:7794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7794   rm -rf conftest*
7795   eval "ac_cv_func_$ac_func=yes"
7796 else
7797   echo "configure: failed program was:" >&5
7798   cat conftest.$ac_ext >&5
7799   rm -rf conftest*
7800   eval "ac_cv_func_$ac_func=no"
7801 fi
7802 rm -f conftest*
7803 fi
7804
7805 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7806   echo "$ac_t""yes" 1>&6
7807     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7808   cat >> confdefs.h <<EOF
7809 #define $ac_tr_func 1
7810 EOF
7811
7812 else
7813   echo "$ac_t""no" 1>&6
7814 fi
7815 done
7816
7817   fi
7818
7819
7820
7821   ac_ext=C
7822 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7823 ac_cpp='$CXXCPP $CPPFLAGS'
7824 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7825 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7826 cross_compiling=$ac_cv_prog_cxx_cross
7827
7828   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
7829 echo "configure:7830: checking for atan2l declaration" >&5
7830   cat > conftest.$ac_ext <<EOF
7831 #line 7832 "configure"
7832 #include "confdefs.h"
7833 #include <math.h>
7834 int main() {
7835  atan2l(0, 0);
7836 ; return 0; }
7837 EOF
7838 if { (eval echo configure:7839: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7839   rm -rf conftest*
7840   use_atan2l=yes
7841 else
7842   echo "configure: failed program was:" >&5
7843   cat conftest.$ac_ext >&5
7844   rm -rf conftest*
7845   use_atan2l=no
7846 fi
7847 rm -f conftest*
7848   echo "$ac_t""$use_atan2l" 1>&6
7849   ac_ext=c
7850 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7851 ac_cpp='$CPP $CPPFLAGS'
7852 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7853 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7854 cross_compiling=$ac_cv_prog_cc_cross
7855
7856   if test x$use_atan2l = x"yes"; then
7857     for ac_func in atan2l
7858 do
7859 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7860 echo "configure:7861: checking for $ac_func" >&5
7861 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7862   echo $ac_n "(cached) $ac_c" 1>&6
7863 else
7864   cat > conftest.$ac_ext <<EOF
7865 #line 7866 "configure"
7866 #include "confdefs.h"
7867 /* System header to define __stub macros and hopefully few prototypes,
7868     which can conflict with char $ac_func(); below.  */
7869 #include <assert.h>
7870 /* Override any gcc2 internal prototype to avoid an error.  */
7871 /* We use char because int might match the return type of a gcc2
7872     builtin and then its argument prototype would still apply.  */
7873 char $ac_func();
7874
7875 int main() {
7876
7877 /* The GNU C library defines this for functions which it implements
7878     to always fail with ENOSYS.  Some functions are actually named
7879     something starting with __ and the normal name is an alias.  */
7880 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7881 choke me
7882 #else
7883 $ac_func();
7884 #endif
7885
7886 ; return 0; }
7887 EOF
7888 if { (eval echo configure:7889: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7889   rm -rf conftest*
7890   eval "ac_cv_func_$ac_func=yes"
7891 else
7892   echo "configure: failed program was:" >&5
7893   cat conftest.$ac_ext >&5
7894   rm -rf conftest*
7895   eval "ac_cv_func_$ac_func=no"
7896 fi
7897 rm -f conftest*
7898 fi
7899
7900 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7901   echo "$ac_t""yes" 1>&6
7902     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7903   cat >> confdefs.h <<EOF
7904 #define $ac_tr_func 1
7905 EOF
7906
7907 else
7908   echo "$ac_t""no" 1>&6
7909 fi
7910 done
7911
7912   fi
7913
7914
7915
7916   ac_ext=C
7917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7918 ac_cpp='$CXXCPP $CPPFLAGS'
7919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7921 cross_compiling=$ac_cv_prog_cxx_cross
7922
7923   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
7924 echo "configure:7925: checking for ceill declaration" >&5
7925   cat > conftest.$ac_ext <<EOF
7926 #line 7927 "configure"
7927 #include "confdefs.h"
7928 #include <math.h>
7929 int main() {
7930  ceill(0);
7931 ; return 0; }
7932 EOF
7933 if { (eval echo configure:7934: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7934   rm -rf conftest*
7935   use_ceill=yes
7936 else
7937   echo "configure: failed program was:" >&5
7938   cat conftest.$ac_ext >&5
7939   rm -rf conftest*
7940   use_ceill=no
7941 fi
7942 rm -f conftest*
7943   echo "$ac_t""$use_ceill" 1>&6
7944   ac_ext=c
7945 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7946 ac_cpp='$CPP $CPPFLAGS'
7947 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7948 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7949 cross_compiling=$ac_cv_prog_cc_cross
7950
7951   if test x$use_ceill = x"yes"; then
7952     for ac_func in ceill
7953 do
7954 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7955 echo "configure:7956: checking for $ac_func" >&5
7956 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7957   echo $ac_n "(cached) $ac_c" 1>&6
7958 else
7959   cat > conftest.$ac_ext <<EOF
7960 #line 7961 "configure"
7961 #include "confdefs.h"
7962 /* System header to define __stub macros and hopefully few prototypes,
7963     which can conflict with char $ac_func(); below.  */
7964 #include <assert.h>
7965 /* Override any gcc2 internal prototype to avoid an error.  */
7966 /* We use char because int might match the return type of a gcc2
7967     builtin and then its argument prototype would still apply.  */
7968 char $ac_func();
7969
7970 int main() {
7971
7972 /* The GNU C library defines this for functions which it implements
7973     to always fail with ENOSYS.  Some functions are actually named
7974     something starting with __ and the normal name is an alias.  */
7975 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7976 choke me
7977 #else
7978 $ac_func();
7979 #endif
7980
7981 ; return 0; }
7982 EOF
7983 if { (eval echo configure:7984: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7984   rm -rf conftest*
7985   eval "ac_cv_func_$ac_func=yes"
7986 else
7987   echo "configure: failed program was:" >&5
7988   cat conftest.$ac_ext >&5
7989   rm -rf conftest*
7990   eval "ac_cv_func_$ac_func=no"
7991 fi
7992 rm -f conftest*
7993 fi
7994
7995 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7996   echo "$ac_t""yes" 1>&6
7997     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7998   cat >> confdefs.h <<EOF
7999 #define $ac_tr_func 1
8000 EOF
8001
8002 else
8003   echo "$ac_t""no" 1>&6
8004 fi
8005 done
8006
8007   fi
8008
8009
8010
8011   ac_ext=C
8012 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8013 ac_cpp='$CXXCPP $CPPFLAGS'
8014 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8015 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8016 cross_compiling=$ac_cv_prog_cxx_cross
8017
8018   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8019 echo "configure:8020: checking for cosl declaration" >&5
8020   cat > conftest.$ac_ext <<EOF
8021 #line 8022 "configure"
8022 #include "confdefs.h"
8023 #include <math.h>
8024 int main() {
8025  cosl(0);
8026 ; return 0; }
8027 EOF
8028 if { (eval echo configure:8029: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8029   rm -rf conftest*
8030   use_cosl=yes
8031 else
8032   echo "configure: failed program was:" >&5
8033   cat conftest.$ac_ext >&5
8034   rm -rf conftest*
8035   use_cosl=no
8036 fi
8037 rm -f conftest*
8038   echo "$ac_t""$use_cosl" 1>&6
8039   ac_ext=c
8040 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8041 ac_cpp='$CPP $CPPFLAGS'
8042 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8043 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8044 cross_compiling=$ac_cv_prog_cc_cross
8045
8046   if test x$use_cosl = x"yes"; then
8047     for ac_func in cosl
8048 do
8049 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8050 echo "configure:8051: checking for $ac_func" >&5
8051 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8052   echo $ac_n "(cached) $ac_c" 1>&6
8053 else
8054   cat > conftest.$ac_ext <<EOF
8055 #line 8056 "configure"
8056 #include "confdefs.h"
8057 /* System header to define __stub macros and hopefully few prototypes,
8058     which can conflict with char $ac_func(); below.  */
8059 #include <assert.h>
8060 /* Override any gcc2 internal prototype to avoid an error.  */
8061 /* We use char because int might match the return type of a gcc2
8062     builtin and then its argument prototype would still apply.  */
8063 char $ac_func();
8064
8065 int main() {
8066
8067 /* The GNU C library defines this for functions which it implements
8068     to always fail with ENOSYS.  Some functions are actually named
8069     something starting with __ and the normal name is an alias.  */
8070 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8071 choke me
8072 #else
8073 $ac_func();
8074 #endif
8075
8076 ; return 0; }
8077 EOF
8078 if { (eval echo configure:8079: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8079   rm -rf conftest*
8080   eval "ac_cv_func_$ac_func=yes"
8081 else
8082   echo "configure: failed program was:" >&5
8083   cat conftest.$ac_ext >&5
8084   rm -rf conftest*
8085   eval "ac_cv_func_$ac_func=no"
8086 fi
8087 rm -f conftest*
8088 fi
8089
8090 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8091   echo "$ac_t""yes" 1>&6
8092     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8093   cat >> confdefs.h <<EOF
8094 #define $ac_tr_func 1
8095 EOF
8096
8097 else
8098   echo "$ac_t""no" 1>&6
8099 fi
8100 done
8101
8102   fi
8103
8104
8105
8106   ac_ext=C
8107 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8108 ac_cpp='$CXXCPP $CPPFLAGS'
8109 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8110 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8111 cross_compiling=$ac_cv_prog_cxx_cross
8112
8113   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
8114 echo "configure:8115: checking for coshl declaration" >&5
8115   cat > conftest.$ac_ext <<EOF
8116 #line 8117 "configure"
8117 #include "confdefs.h"
8118 #include <math.h>
8119 int main() {
8120  coshl(0);
8121 ; return 0; }
8122 EOF
8123 if { (eval echo configure:8124: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8124   rm -rf conftest*
8125   use_coshl=yes
8126 else
8127   echo "configure: failed program was:" >&5
8128   cat conftest.$ac_ext >&5
8129   rm -rf conftest*
8130   use_coshl=no
8131 fi
8132 rm -f conftest*
8133   echo "$ac_t""$use_coshl" 1>&6
8134   ac_ext=c
8135 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8136 ac_cpp='$CPP $CPPFLAGS'
8137 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8138 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8139 cross_compiling=$ac_cv_prog_cc_cross
8140
8141   if test x$use_coshl = x"yes"; then
8142     for ac_func in coshl
8143 do
8144 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8145 echo "configure:8146: checking for $ac_func" >&5
8146 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8147   echo $ac_n "(cached) $ac_c" 1>&6
8148 else
8149   cat > conftest.$ac_ext <<EOF
8150 #line 8151 "configure"
8151 #include "confdefs.h"
8152 /* System header to define __stub macros and hopefully few prototypes,
8153     which can conflict with char $ac_func(); below.  */
8154 #include <assert.h>
8155 /* Override any gcc2 internal prototype to avoid an error.  */
8156 /* We use char because int might match the return type of a gcc2
8157     builtin and then its argument prototype would still apply.  */
8158 char $ac_func();
8159
8160 int main() {
8161
8162 /* The GNU C library defines this for functions which it implements
8163     to always fail with ENOSYS.  Some functions are actually named
8164     something starting with __ and the normal name is an alias.  */
8165 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8166 choke me
8167 #else
8168 $ac_func();
8169 #endif
8170
8171 ; return 0; }
8172 EOF
8173 if { (eval echo configure:8174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8174   rm -rf conftest*
8175   eval "ac_cv_func_$ac_func=yes"
8176 else
8177   echo "configure: failed program was:" >&5
8178   cat conftest.$ac_ext >&5
8179   rm -rf conftest*
8180   eval "ac_cv_func_$ac_func=no"
8181 fi
8182 rm -f conftest*
8183 fi
8184
8185 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8186   echo "$ac_t""yes" 1>&6
8187     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8188   cat >> confdefs.h <<EOF
8189 #define $ac_tr_func 1
8190 EOF
8191
8192 else
8193   echo "$ac_t""no" 1>&6
8194 fi
8195 done
8196
8197   fi
8198
8199
8200
8201   ac_ext=C
8202 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8203 ac_cpp='$CXXCPP $CPPFLAGS'
8204 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8205 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8206 cross_compiling=$ac_cv_prog_cxx_cross
8207
8208   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
8209 echo "configure:8210: checking for expl declaration" >&5
8210   cat > conftest.$ac_ext <<EOF
8211 #line 8212 "configure"
8212 #include "confdefs.h"
8213 #include <math.h>
8214 int main() {
8215  expl(0);
8216 ; return 0; }
8217 EOF
8218 if { (eval echo configure:8219: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8219   rm -rf conftest*
8220   use_expl=yes
8221 else
8222   echo "configure: failed program was:" >&5
8223   cat conftest.$ac_ext >&5
8224   rm -rf conftest*
8225   use_expl=no
8226 fi
8227 rm -f conftest*
8228   echo "$ac_t""$use_expl" 1>&6
8229   ac_ext=c
8230 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8231 ac_cpp='$CPP $CPPFLAGS'
8232 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8233 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8234 cross_compiling=$ac_cv_prog_cc_cross
8235
8236   if test x$use_expl = x"yes"; then
8237     for ac_func in expl
8238 do
8239 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8240 echo "configure:8241: checking for $ac_func" >&5
8241 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8242   echo $ac_n "(cached) $ac_c" 1>&6
8243 else
8244   cat > conftest.$ac_ext <<EOF
8245 #line 8246 "configure"
8246 #include "confdefs.h"
8247 /* System header to define __stub macros and hopefully few prototypes,
8248     which can conflict with char $ac_func(); below.  */
8249 #include <assert.h>
8250 /* Override any gcc2 internal prototype to avoid an error.  */
8251 /* We use char because int might match the return type of a gcc2
8252     builtin and then its argument prototype would still apply.  */
8253 char $ac_func();
8254
8255 int main() {
8256
8257 /* The GNU C library defines this for functions which it implements
8258     to always fail with ENOSYS.  Some functions are actually named
8259     something starting with __ and the normal name is an alias.  */
8260 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8261 choke me
8262 #else
8263 $ac_func();
8264 #endif
8265
8266 ; return 0; }
8267 EOF
8268 if { (eval echo configure:8269: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8269   rm -rf conftest*
8270   eval "ac_cv_func_$ac_func=yes"
8271 else
8272   echo "configure: failed program was:" >&5
8273   cat conftest.$ac_ext >&5
8274   rm -rf conftest*
8275   eval "ac_cv_func_$ac_func=no"
8276 fi
8277 rm -f conftest*
8278 fi
8279
8280 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8281   echo "$ac_t""yes" 1>&6
8282     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8283   cat >> confdefs.h <<EOF
8284 #define $ac_tr_func 1
8285 EOF
8286
8287 else
8288   echo "$ac_t""no" 1>&6
8289 fi
8290 done
8291
8292   fi
8293
8294
8295
8296   ac_ext=C
8297 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8298 ac_cpp='$CXXCPP $CPPFLAGS'
8299 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8300 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8301 cross_compiling=$ac_cv_prog_cxx_cross
8302
8303   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
8304 echo "configure:8305: checking for fabsl declaration" >&5
8305   cat > conftest.$ac_ext <<EOF
8306 #line 8307 "configure"
8307 #include "confdefs.h"
8308 #include <math.h>
8309 int main() {
8310  fabsl(0);
8311 ; return 0; }
8312 EOF
8313 if { (eval echo configure:8314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8314   rm -rf conftest*
8315   use_fabsl=yes
8316 else
8317   echo "configure: failed program was:" >&5
8318   cat conftest.$ac_ext >&5
8319   rm -rf conftest*
8320   use_fabsl=no
8321 fi
8322 rm -f conftest*
8323   echo "$ac_t""$use_fabsl" 1>&6
8324   ac_ext=c
8325 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8326 ac_cpp='$CPP $CPPFLAGS'
8327 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8328 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8329 cross_compiling=$ac_cv_prog_cc_cross
8330
8331   if test x$use_fabsl = x"yes"; then
8332     for ac_func in fabsl
8333 do
8334 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8335 echo "configure:8336: checking for $ac_func" >&5
8336 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8337   echo $ac_n "(cached) $ac_c" 1>&6
8338 else
8339   cat > conftest.$ac_ext <<EOF
8340 #line 8341 "configure"
8341 #include "confdefs.h"
8342 /* System header to define __stub macros and hopefully few prototypes,
8343     which can conflict with char $ac_func(); below.  */
8344 #include <assert.h>
8345 /* Override any gcc2 internal prototype to avoid an error.  */
8346 /* We use char because int might match the return type of a gcc2
8347     builtin and then its argument prototype would still apply.  */
8348 char $ac_func();
8349
8350 int main() {
8351
8352 /* The GNU C library defines this for functions which it implements
8353     to always fail with ENOSYS.  Some functions are actually named
8354     something starting with __ and the normal name is an alias.  */
8355 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8356 choke me
8357 #else
8358 $ac_func();
8359 #endif
8360
8361 ; return 0; }
8362 EOF
8363 if { (eval echo configure:8364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8364   rm -rf conftest*
8365   eval "ac_cv_func_$ac_func=yes"
8366 else
8367   echo "configure: failed program was:" >&5
8368   cat conftest.$ac_ext >&5
8369   rm -rf conftest*
8370   eval "ac_cv_func_$ac_func=no"
8371 fi
8372 rm -f conftest*
8373 fi
8374
8375 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8376   echo "$ac_t""yes" 1>&6
8377     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8378   cat >> confdefs.h <<EOF
8379 #define $ac_tr_func 1
8380 EOF
8381
8382 else
8383   echo "$ac_t""no" 1>&6
8384 fi
8385 done
8386
8387   fi
8388
8389
8390
8391   ac_ext=C
8392 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8393 ac_cpp='$CXXCPP $CPPFLAGS'
8394 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8395 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8396 cross_compiling=$ac_cv_prog_cxx_cross
8397
8398   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
8399 echo "configure:8400: checking for floorl declaration" >&5
8400   cat > conftest.$ac_ext <<EOF
8401 #line 8402 "configure"
8402 #include "confdefs.h"
8403 #include <math.h>
8404 int main() {
8405  floorl(0);
8406 ; return 0; }
8407 EOF
8408 if { (eval echo configure:8409: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8409   rm -rf conftest*
8410   use_floorl=yes
8411 else
8412   echo "configure: failed program was:" >&5
8413   cat conftest.$ac_ext >&5
8414   rm -rf conftest*
8415   use_floorl=no
8416 fi
8417 rm -f conftest*
8418   echo "$ac_t""$use_floorl" 1>&6
8419   ac_ext=c
8420 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8421 ac_cpp='$CPP $CPPFLAGS'
8422 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8423 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8424 cross_compiling=$ac_cv_prog_cc_cross
8425
8426   if test x$use_floorl = x"yes"; then
8427     for ac_func in floorl
8428 do
8429 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8430 echo "configure:8431: checking for $ac_func" >&5
8431 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8432   echo $ac_n "(cached) $ac_c" 1>&6
8433 else
8434   cat > conftest.$ac_ext <<EOF
8435 #line 8436 "configure"
8436 #include "confdefs.h"
8437 /* System header to define __stub macros and hopefully few prototypes,
8438     which can conflict with char $ac_func(); below.  */
8439 #include <assert.h>
8440 /* Override any gcc2 internal prototype to avoid an error.  */
8441 /* We use char because int might match the return type of a gcc2
8442     builtin and then its argument prototype would still apply.  */
8443 char $ac_func();
8444
8445 int main() {
8446
8447 /* The GNU C library defines this for functions which it implements
8448     to always fail with ENOSYS.  Some functions are actually named
8449     something starting with __ and the normal name is an alias.  */
8450 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8451 choke me
8452 #else
8453 $ac_func();
8454 #endif
8455
8456 ; return 0; }
8457 EOF
8458 if { (eval echo configure:8459: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8459   rm -rf conftest*
8460   eval "ac_cv_func_$ac_func=yes"
8461 else
8462   echo "configure: failed program was:" >&5
8463   cat conftest.$ac_ext >&5
8464   rm -rf conftest*
8465   eval "ac_cv_func_$ac_func=no"
8466 fi
8467 rm -f conftest*
8468 fi
8469
8470 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8471   echo "$ac_t""yes" 1>&6
8472     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8473   cat >> confdefs.h <<EOF
8474 #define $ac_tr_func 1
8475 EOF
8476
8477 else
8478   echo "$ac_t""no" 1>&6
8479 fi
8480 done
8481
8482   fi
8483
8484
8485
8486   ac_ext=C
8487 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8488 ac_cpp='$CXXCPP $CPPFLAGS'
8489 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8490 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8491 cross_compiling=$ac_cv_prog_cxx_cross
8492
8493   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
8494 echo "configure:8495: checking for fmodl declaration" >&5
8495   cat > conftest.$ac_ext <<EOF
8496 #line 8497 "configure"
8497 #include "confdefs.h"
8498 #include <math.h>
8499 int main() {
8500  fmodl(0, 0);
8501 ; return 0; }
8502 EOF
8503 if { (eval echo configure:8504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8504   rm -rf conftest*
8505   use_fmodl=yes
8506 else
8507   echo "configure: failed program was:" >&5
8508   cat conftest.$ac_ext >&5
8509   rm -rf conftest*
8510   use_fmodl=no
8511 fi
8512 rm -f conftest*
8513   echo "$ac_t""$use_fmodl" 1>&6
8514   ac_ext=c
8515 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8516 ac_cpp='$CPP $CPPFLAGS'
8517 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8518 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8519 cross_compiling=$ac_cv_prog_cc_cross
8520
8521   if test x$use_fmodl = x"yes"; then
8522     for ac_func in fmodl
8523 do
8524 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8525 echo "configure:8526: checking for $ac_func" >&5
8526 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8527   echo $ac_n "(cached) $ac_c" 1>&6
8528 else
8529   cat > conftest.$ac_ext <<EOF
8530 #line 8531 "configure"
8531 #include "confdefs.h"
8532 /* System header to define __stub macros and hopefully few prototypes,
8533     which can conflict with char $ac_func(); below.  */
8534 #include <assert.h>
8535 /* Override any gcc2 internal prototype to avoid an error.  */
8536 /* We use char because int might match the return type of a gcc2
8537     builtin and then its argument prototype would still apply.  */
8538 char $ac_func();
8539
8540 int main() {
8541
8542 /* The GNU C library defines this for functions which it implements
8543     to always fail with ENOSYS.  Some functions are actually named
8544     something starting with __ and the normal name is an alias.  */
8545 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8546 choke me
8547 #else
8548 $ac_func();
8549 #endif
8550
8551 ; return 0; }
8552 EOF
8553 if { (eval echo configure:8554: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8554   rm -rf conftest*
8555   eval "ac_cv_func_$ac_func=yes"
8556 else
8557   echo "configure: failed program was:" >&5
8558   cat conftest.$ac_ext >&5
8559   rm -rf conftest*
8560   eval "ac_cv_func_$ac_func=no"
8561 fi
8562 rm -f conftest*
8563 fi
8564
8565 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8566   echo "$ac_t""yes" 1>&6
8567     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8568   cat >> confdefs.h <<EOF
8569 #define $ac_tr_func 1
8570 EOF
8571
8572 else
8573   echo "$ac_t""no" 1>&6
8574 fi
8575 done
8576
8577   fi
8578
8579
8580
8581   ac_ext=C
8582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8583 ac_cpp='$CXXCPP $CPPFLAGS'
8584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8586 cross_compiling=$ac_cv_prog_cxx_cross
8587
8588   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
8589 echo "configure:8590: checking for frexpl declaration" >&5
8590   cat > conftest.$ac_ext <<EOF
8591 #line 8592 "configure"
8592 #include "confdefs.h"
8593 #include <math.h>
8594 int main() {
8595  frexpl(0, 0);
8596 ; return 0; }
8597 EOF
8598 if { (eval echo configure:8599: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8599   rm -rf conftest*
8600   use_frexpl=yes
8601 else
8602   echo "configure: failed program was:" >&5
8603   cat conftest.$ac_ext >&5
8604   rm -rf conftest*
8605   use_frexpl=no
8606 fi
8607 rm -f conftest*
8608   echo "$ac_t""$use_frexpl" 1>&6
8609   ac_ext=c
8610 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8611 ac_cpp='$CPP $CPPFLAGS'
8612 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8613 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8614 cross_compiling=$ac_cv_prog_cc_cross
8615
8616   if test x$use_frexpl = x"yes"; then
8617     for ac_func in frexpl
8618 do
8619 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8620 echo "configure:8621: checking for $ac_func" >&5
8621 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8622   echo $ac_n "(cached) $ac_c" 1>&6
8623 else
8624   cat > conftest.$ac_ext <<EOF
8625 #line 8626 "configure"
8626 #include "confdefs.h"
8627 /* System header to define __stub macros and hopefully few prototypes,
8628     which can conflict with char $ac_func(); below.  */
8629 #include <assert.h>
8630 /* Override any gcc2 internal prototype to avoid an error.  */
8631 /* We use char because int might match the return type of a gcc2
8632     builtin and then its argument prototype would still apply.  */
8633 char $ac_func();
8634
8635 int main() {
8636
8637 /* The GNU C library defines this for functions which it implements
8638     to always fail with ENOSYS.  Some functions are actually named
8639     something starting with __ and the normal name is an alias.  */
8640 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8641 choke me
8642 #else
8643 $ac_func();
8644 #endif
8645
8646 ; return 0; }
8647 EOF
8648 if { (eval echo configure:8649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8649   rm -rf conftest*
8650   eval "ac_cv_func_$ac_func=yes"
8651 else
8652   echo "configure: failed program was:" >&5
8653   cat conftest.$ac_ext >&5
8654   rm -rf conftest*
8655   eval "ac_cv_func_$ac_func=no"
8656 fi
8657 rm -f conftest*
8658 fi
8659
8660 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8661   echo "$ac_t""yes" 1>&6
8662     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8663   cat >> confdefs.h <<EOF
8664 #define $ac_tr_func 1
8665 EOF
8666
8667 else
8668   echo "$ac_t""no" 1>&6
8669 fi
8670 done
8671
8672   fi
8673
8674
8675
8676   ac_ext=C
8677 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8678 ac_cpp='$CXXCPP $CPPFLAGS'
8679 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8680 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8681 cross_compiling=$ac_cv_prog_cxx_cross
8682
8683   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
8684 echo "configure:8685: checking for ldexpl declaration" >&5
8685   cat > conftest.$ac_ext <<EOF
8686 #line 8687 "configure"
8687 #include "confdefs.h"
8688 #include <math.h>
8689 int main() {
8690  ldexpl(0, 0);
8691 ; return 0; }
8692 EOF
8693 if { (eval echo configure:8694: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8694   rm -rf conftest*
8695   use_ldexpl=yes
8696 else
8697   echo "configure: failed program was:" >&5
8698   cat conftest.$ac_ext >&5
8699   rm -rf conftest*
8700   use_ldexpl=no
8701 fi
8702 rm -f conftest*
8703   echo "$ac_t""$use_ldexpl" 1>&6
8704   ac_ext=c
8705 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8706 ac_cpp='$CPP $CPPFLAGS'
8707 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8708 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8709 cross_compiling=$ac_cv_prog_cc_cross
8710
8711   if test x$use_ldexpl = x"yes"; then
8712     for ac_func in ldexpl
8713 do
8714 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8715 echo "configure:8716: checking for $ac_func" >&5
8716 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8717   echo $ac_n "(cached) $ac_c" 1>&6
8718 else
8719   cat > conftest.$ac_ext <<EOF
8720 #line 8721 "configure"
8721 #include "confdefs.h"
8722 /* System header to define __stub macros and hopefully few prototypes,
8723     which can conflict with char $ac_func(); below.  */
8724 #include <assert.h>
8725 /* Override any gcc2 internal prototype to avoid an error.  */
8726 /* We use char because int might match the return type of a gcc2
8727     builtin and then its argument prototype would still apply.  */
8728 char $ac_func();
8729
8730 int main() {
8731
8732 /* The GNU C library defines this for functions which it implements
8733     to always fail with ENOSYS.  Some functions are actually named
8734     something starting with __ and the normal name is an alias.  */
8735 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8736 choke me
8737 #else
8738 $ac_func();
8739 #endif
8740
8741 ; return 0; }
8742 EOF
8743 if { (eval echo configure:8744: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8744   rm -rf conftest*
8745   eval "ac_cv_func_$ac_func=yes"
8746 else
8747   echo "configure: failed program was:" >&5
8748   cat conftest.$ac_ext >&5
8749   rm -rf conftest*
8750   eval "ac_cv_func_$ac_func=no"
8751 fi
8752 rm -f conftest*
8753 fi
8754
8755 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8756   echo "$ac_t""yes" 1>&6
8757     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8758   cat >> confdefs.h <<EOF
8759 #define $ac_tr_func 1
8760 EOF
8761
8762 else
8763   echo "$ac_t""no" 1>&6
8764 fi
8765 done
8766
8767   fi
8768
8769
8770
8771   ac_ext=C
8772 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8773 ac_cpp='$CXXCPP $CPPFLAGS'
8774 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8775 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8776 cross_compiling=$ac_cv_prog_cxx_cross
8777
8778   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
8779 echo "configure:8780: checking for logl declaration" >&5
8780   cat > conftest.$ac_ext <<EOF
8781 #line 8782 "configure"
8782 #include "confdefs.h"
8783 #include <math.h>
8784 int main() {
8785  logl(0);
8786 ; return 0; }
8787 EOF
8788 if { (eval echo configure:8789: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8789   rm -rf conftest*
8790   use_logl=yes
8791 else
8792   echo "configure: failed program was:" >&5
8793   cat conftest.$ac_ext >&5
8794   rm -rf conftest*
8795   use_logl=no
8796 fi
8797 rm -f conftest*
8798   echo "$ac_t""$use_logl" 1>&6
8799   ac_ext=c
8800 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8801 ac_cpp='$CPP $CPPFLAGS'
8802 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8803 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8804 cross_compiling=$ac_cv_prog_cc_cross
8805
8806   if test x$use_logl = x"yes"; then
8807     for ac_func in logl
8808 do
8809 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8810 echo "configure:8811: checking for $ac_func" >&5
8811 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8812   echo $ac_n "(cached) $ac_c" 1>&6
8813 else
8814   cat > conftest.$ac_ext <<EOF
8815 #line 8816 "configure"
8816 #include "confdefs.h"
8817 /* System header to define __stub macros and hopefully few prototypes,
8818     which can conflict with char $ac_func(); below.  */
8819 #include <assert.h>
8820 /* Override any gcc2 internal prototype to avoid an error.  */
8821 /* We use char because int might match the return type of a gcc2
8822     builtin and then its argument prototype would still apply.  */
8823 char $ac_func();
8824
8825 int main() {
8826
8827 /* The GNU C library defines this for functions which it implements
8828     to always fail with ENOSYS.  Some functions are actually named
8829     something starting with __ and the normal name is an alias.  */
8830 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8831 choke me
8832 #else
8833 $ac_func();
8834 #endif
8835
8836 ; return 0; }
8837 EOF
8838 if { (eval echo configure:8839: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8839   rm -rf conftest*
8840   eval "ac_cv_func_$ac_func=yes"
8841 else
8842   echo "configure: failed program was:" >&5
8843   cat conftest.$ac_ext >&5
8844   rm -rf conftest*
8845   eval "ac_cv_func_$ac_func=no"
8846 fi
8847 rm -f conftest*
8848 fi
8849
8850 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8851   echo "$ac_t""yes" 1>&6
8852     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8853   cat >> confdefs.h <<EOF
8854 #define $ac_tr_func 1
8855 EOF
8856
8857 else
8858   echo "$ac_t""no" 1>&6
8859 fi
8860 done
8861
8862   fi
8863
8864
8865
8866   ac_ext=C
8867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8868 ac_cpp='$CXXCPP $CPPFLAGS'
8869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8871 cross_compiling=$ac_cv_prog_cxx_cross
8872
8873   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
8874 echo "configure:8875: checking for log10l declaration" >&5
8875   cat > conftest.$ac_ext <<EOF
8876 #line 8877 "configure"
8877 #include "confdefs.h"
8878 #include <math.h>
8879 int main() {
8880  log10l(0);
8881 ; return 0; }
8882 EOF
8883 if { (eval echo configure:8884: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8884   rm -rf conftest*
8885   use_log10l=yes
8886 else
8887   echo "configure: failed program was:" >&5
8888   cat conftest.$ac_ext >&5
8889   rm -rf conftest*
8890   use_log10l=no
8891 fi
8892 rm -f conftest*
8893   echo "$ac_t""$use_log10l" 1>&6
8894   ac_ext=c
8895 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8896 ac_cpp='$CPP $CPPFLAGS'
8897 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8898 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8899 cross_compiling=$ac_cv_prog_cc_cross
8900
8901   if test x$use_log10l = x"yes"; then
8902     for ac_func in log10l
8903 do
8904 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8905 echo "configure:8906: checking for $ac_func" >&5
8906 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8907   echo $ac_n "(cached) $ac_c" 1>&6
8908 else
8909   cat > conftest.$ac_ext <<EOF
8910 #line 8911 "configure"
8911 #include "confdefs.h"
8912 /* System header to define __stub macros and hopefully few prototypes,
8913     which can conflict with char $ac_func(); below.  */
8914 #include <assert.h>
8915 /* Override any gcc2 internal prototype to avoid an error.  */
8916 /* We use char because int might match the return type of a gcc2
8917     builtin and then its argument prototype would still apply.  */
8918 char $ac_func();
8919
8920 int main() {
8921
8922 /* The GNU C library defines this for functions which it implements
8923     to always fail with ENOSYS.  Some functions are actually named
8924     something starting with __ and the normal name is an alias.  */
8925 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8926 choke me
8927 #else
8928 $ac_func();
8929 #endif
8930
8931 ; return 0; }
8932 EOF
8933 if { (eval echo configure:8934: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8934   rm -rf conftest*
8935   eval "ac_cv_func_$ac_func=yes"
8936 else
8937   echo "configure: failed program was:" >&5
8938   cat conftest.$ac_ext >&5
8939   rm -rf conftest*
8940   eval "ac_cv_func_$ac_func=no"
8941 fi
8942 rm -f conftest*
8943 fi
8944
8945 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8946   echo "$ac_t""yes" 1>&6
8947     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8948   cat >> confdefs.h <<EOF
8949 #define $ac_tr_func 1
8950 EOF
8951
8952 else
8953   echo "$ac_t""no" 1>&6
8954 fi
8955 done
8956
8957   fi
8958
8959
8960
8961   ac_ext=C
8962 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8963 ac_cpp='$CXXCPP $CPPFLAGS'
8964 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8965 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8966 cross_compiling=$ac_cv_prog_cxx_cross
8967
8968   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
8969 echo "configure:8970: checking for modfl declaration" >&5
8970   cat > conftest.$ac_ext <<EOF
8971 #line 8972 "configure"
8972 #include "confdefs.h"
8973 #include <math.h>
8974 int main() {
8975  modfl(0, 0);
8976 ; return 0; }
8977 EOF
8978 if { (eval echo configure:8979: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8979   rm -rf conftest*
8980   use_modfl=yes
8981 else
8982   echo "configure: failed program was:" >&5
8983   cat conftest.$ac_ext >&5
8984   rm -rf conftest*
8985   use_modfl=no
8986 fi
8987 rm -f conftest*
8988   echo "$ac_t""$use_modfl" 1>&6
8989   ac_ext=c
8990 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8991 ac_cpp='$CPP $CPPFLAGS'
8992 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8993 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8994 cross_compiling=$ac_cv_prog_cc_cross
8995
8996   if test x$use_modfl = x"yes"; then
8997     for ac_func in modfl
8998 do
8999 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9000 echo "configure:9001: checking for $ac_func" >&5
9001 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9002   echo $ac_n "(cached) $ac_c" 1>&6
9003 else
9004   cat > conftest.$ac_ext <<EOF
9005 #line 9006 "configure"
9006 #include "confdefs.h"
9007 /* System header to define __stub macros and hopefully few prototypes,
9008     which can conflict with char $ac_func(); below.  */
9009 #include <assert.h>
9010 /* Override any gcc2 internal prototype to avoid an error.  */
9011 /* We use char because int might match the return type of a gcc2
9012     builtin and then its argument prototype would still apply.  */
9013 char $ac_func();
9014
9015 int main() {
9016
9017 /* The GNU C library defines this for functions which it implements
9018     to always fail with ENOSYS.  Some functions are actually named
9019     something starting with __ and the normal name is an alias.  */
9020 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9021 choke me
9022 #else
9023 $ac_func();
9024 #endif
9025
9026 ; return 0; }
9027 EOF
9028 if { (eval echo configure:9029: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9029   rm -rf conftest*
9030   eval "ac_cv_func_$ac_func=yes"
9031 else
9032   echo "configure: failed program was:" >&5
9033   cat conftest.$ac_ext >&5
9034   rm -rf conftest*
9035   eval "ac_cv_func_$ac_func=no"
9036 fi
9037 rm -f conftest*
9038 fi
9039
9040 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9041   echo "$ac_t""yes" 1>&6
9042     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9043   cat >> confdefs.h <<EOF
9044 #define $ac_tr_func 1
9045 EOF
9046
9047 else
9048   echo "$ac_t""no" 1>&6
9049 fi
9050 done
9051
9052   fi
9053
9054
9055
9056   ac_ext=C
9057 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9058 ac_cpp='$CXXCPP $CPPFLAGS'
9059 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9060 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9061 cross_compiling=$ac_cv_prog_cxx_cross
9062
9063   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
9064 echo "configure:9065: checking for powl declaration" >&5
9065   cat > conftest.$ac_ext <<EOF
9066 #line 9067 "configure"
9067 #include "confdefs.h"
9068 #include <math.h>
9069 int main() {
9070  powl(0, 0);
9071 ; return 0; }
9072 EOF
9073 if { (eval echo configure:9074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9074   rm -rf conftest*
9075   use_powl=yes
9076 else
9077   echo "configure: failed program was:" >&5
9078   cat conftest.$ac_ext >&5
9079   rm -rf conftest*
9080   use_powl=no
9081 fi
9082 rm -f conftest*
9083   echo "$ac_t""$use_powl" 1>&6
9084   ac_ext=c
9085 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9086 ac_cpp='$CPP $CPPFLAGS'
9087 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9088 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9089 cross_compiling=$ac_cv_prog_cc_cross
9090
9091   if test x$use_powl = x"yes"; then
9092     for ac_func in powl
9093 do
9094 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9095 echo "configure:9096: checking for $ac_func" >&5
9096 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9097   echo $ac_n "(cached) $ac_c" 1>&6
9098 else
9099   cat > conftest.$ac_ext <<EOF
9100 #line 9101 "configure"
9101 #include "confdefs.h"
9102 /* System header to define __stub macros and hopefully few prototypes,
9103     which can conflict with char $ac_func(); below.  */
9104 #include <assert.h>
9105 /* Override any gcc2 internal prototype to avoid an error.  */
9106 /* We use char because int might match the return type of a gcc2
9107     builtin and then its argument prototype would still apply.  */
9108 char $ac_func();
9109
9110 int main() {
9111
9112 /* The GNU C library defines this for functions which it implements
9113     to always fail with ENOSYS.  Some functions are actually named
9114     something starting with __ and the normal name is an alias.  */
9115 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9116 choke me
9117 #else
9118 $ac_func();
9119 #endif
9120
9121 ; return 0; }
9122 EOF
9123 if { (eval echo configure:9124: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9124   rm -rf conftest*
9125   eval "ac_cv_func_$ac_func=yes"
9126 else
9127   echo "configure: failed program was:" >&5
9128   cat conftest.$ac_ext >&5
9129   rm -rf conftest*
9130   eval "ac_cv_func_$ac_func=no"
9131 fi
9132 rm -f conftest*
9133 fi
9134
9135 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9136   echo "$ac_t""yes" 1>&6
9137     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9138   cat >> confdefs.h <<EOF
9139 #define $ac_tr_func 1
9140 EOF
9141
9142 else
9143   echo "$ac_t""no" 1>&6
9144 fi
9145 done
9146
9147   fi
9148
9149
9150
9151   ac_ext=C
9152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9153 ac_cpp='$CXXCPP $CPPFLAGS'
9154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9156 cross_compiling=$ac_cv_prog_cxx_cross
9157
9158   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
9159 echo "configure:9160: checking for sinl declaration" >&5
9160   cat > conftest.$ac_ext <<EOF
9161 #line 9162 "configure"
9162 #include "confdefs.h"
9163 #include <math.h>
9164 int main() {
9165  sinl(0);
9166 ; return 0; }
9167 EOF
9168 if { (eval echo configure:9169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9169   rm -rf conftest*
9170   use_sinl=yes
9171 else
9172   echo "configure: failed program was:" >&5
9173   cat conftest.$ac_ext >&5
9174   rm -rf conftest*
9175   use_sinl=no
9176 fi
9177 rm -f conftest*
9178   echo "$ac_t""$use_sinl" 1>&6
9179   ac_ext=c
9180 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9181 ac_cpp='$CPP $CPPFLAGS'
9182 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9183 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9184 cross_compiling=$ac_cv_prog_cc_cross
9185
9186   if test x$use_sinl = x"yes"; then
9187     for ac_func in sinl
9188 do
9189 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9190 echo "configure:9191: checking for $ac_func" >&5
9191 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9192   echo $ac_n "(cached) $ac_c" 1>&6
9193 else
9194   cat > conftest.$ac_ext <<EOF
9195 #line 9196 "configure"
9196 #include "confdefs.h"
9197 /* System header to define __stub macros and hopefully few prototypes,
9198     which can conflict with char $ac_func(); below.  */
9199 #include <assert.h>
9200 /* Override any gcc2 internal prototype to avoid an error.  */
9201 /* We use char because int might match the return type of a gcc2
9202     builtin and then its argument prototype would still apply.  */
9203 char $ac_func();
9204
9205 int main() {
9206
9207 /* The GNU C library defines this for functions which it implements
9208     to always fail with ENOSYS.  Some functions are actually named
9209     something starting with __ and the normal name is an alias.  */
9210 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9211 choke me
9212 #else
9213 $ac_func();
9214 #endif
9215
9216 ; return 0; }
9217 EOF
9218 if { (eval echo configure:9219: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9219   rm -rf conftest*
9220   eval "ac_cv_func_$ac_func=yes"
9221 else
9222   echo "configure: failed program was:" >&5
9223   cat conftest.$ac_ext >&5
9224   rm -rf conftest*
9225   eval "ac_cv_func_$ac_func=no"
9226 fi
9227 rm -f conftest*
9228 fi
9229
9230 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9231   echo "$ac_t""yes" 1>&6
9232     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9233   cat >> confdefs.h <<EOF
9234 #define $ac_tr_func 1
9235 EOF
9236
9237 else
9238   echo "$ac_t""no" 1>&6
9239 fi
9240 done
9241
9242   fi
9243
9244
9245
9246   ac_ext=C
9247 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9248 ac_cpp='$CXXCPP $CPPFLAGS'
9249 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9250 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9251 cross_compiling=$ac_cv_prog_cxx_cross
9252
9253   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
9254 echo "configure:9255: checking for sinhl declaration" >&5
9255   cat > conftest.$ac_ext <<EOF
9256 #line 9257 "configure"
9257 #include "confdefs.h"
9258 #include <math.h>
9259 int main() {
9260  sinhl(0);
9261 ; return 0; }
9262 EOF
9263 if { (eval echo configure:9264: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9264   rm -rf conftest*
9265   use_sinhl=yes
9266 else
9267   echo "configure: failed program was:" >&5
9268   cat conftest.$ac_ext >&5
9269   rm -rf conftest*
9270   use_sinhl=no
9271 fi
9272 rm -f conftest*
9273   echo "$ac_t""$use_sinhl" 1>&6
9274   ac_ext=c
9275 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9276 ac_cpp='$CPP $CPPFLAGS'
9277 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9278 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9279 cross_compiling=$ac_cv_prog_cc_cross
9280
9281   if test x$use_sinhl = x"yes"; then
9282     for ac_func in sinhl
9283 do
9284 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9285 echo "configure:9286: checking for $ac_func" >&5
9286 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9287   echo $ac_n "(cached) $ac_c" 1>&6
9288 else
9289   cat > conftest.$ac_ext <<EOF
9290 #line 9291 "configure"
9291 #include "confdefs.h"
9292 /* System header to define __stub macros and hopefully few prototypes,
9293     which can conflict with char $ac_func(); below.  */
9294 #include <assert.h>
9295 /* Override any gcc2 internal prototype to avoid an error.  */
9296 /* We use char because int might match the return type of a gcc2
9297     builtin and then its argument prototype would still apply.  */
9298 char $ac_func();
9299
9300 int main() {
9301
9302 /* The GNU C library defines this for functions which it implements
9303     to always fail with ENOSYS.  Some functions are actually named
9304     something starting with __ and the normal name is an alias.  */
9305 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9306 choke me
9307 #else
9308 $ac_func();
9309 #endif
9310
9311 ; return 0; }
9312 EOF
9313 if { (eval echo configure:9314: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9314   rm -rf conftest*
9315   eval "ac_cv_func_$ac_func=yes"
9316 else
9317   echo "configure: failed program was:" >&5
9318   cat conftest.$ac_ext >&5
9319   rm -rf conftest*
9320   eval "ac_cv_func_$ac_func=no"
9321 fi
9322 rm -f conftest*
9323 fi
9324
9325 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9326   echo "$ac_t""yes" 1>&6
9327     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9328   cat >> confdefs.h <<EOF
9329 #define $ac_tr_func 1
9330 EOF
9331
9332 else
9333   echo "$ac_t""no" 1>&6
9334 fi
9335 done
9336
9337   fi
9338
9339
9340
9341   ac_ext=C
9342 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9343 ac_cpp='$CXXCPP $CPPFLAGS'
9344 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9345 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9346 cross_compiling=$ac_cv_prog_cxx_cross
9347
9348   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
9349 echo "configure:9350: checking for sqrtl declaration" >&5
9350   cat > conftest.$ac_ext <<EOF
9351 #line 9352 "configure"
9352 #include "confdefs.h"
9353 #include <math.h>
9354 int main() {
9355  sqrtl(0);
9356 ; return 0; }
9357 EOF
9358 if { (eval echo configure:9359: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9359   rm -rf conftest*
9360   use_sqrtl=yes
9361 else
9362   echo "configure: failed program was:" >&5
9363   cat conftest.$ac_ext >&5
9364   rm -rf conftest*
9365   use_sqrtl=no
9366 fi
9367 rm -f conftest*
9368   echo "$ac_t""$use_sqrtl" 1>&6
9369   ac_ext=c
9370 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9371 ac_cpp='$CPP $CPPFLAGS'
9372 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9373 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9374 cross_compiling=$ac_cv_prog_cc_cross
9375
9376   if test x$use_sqrtl = x"yes"; then
9377     for ac_func in sqrtl
9378 do
9379 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9380 echo "configure:9381: checking for $ac_func" >&5
9381 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9382   echo $ac_n "(cached) $ac_c" 1>&6
9383 else
9384   cat > conftest.$ac_ext <<EOF
9385 #line 9386 "configure"
9386 #include "confdefs.h"
9387 /* System header to define __stub macros and hopefully few prototypes,
9388     which can conflict with char $ac_func(); below.  */
9389 #include <assert.h>
9390 /* Override any gcc2 internal prototype to avoid an error.  */
9391 /* We use char because int might match the return type of a gcc2
9392     builtin and then its argument prototype would still apply.  */
9393 char $ac_func();
9394
9395 int main() {
9396
9397 /* The GNU C library defines this for functions which it implements
9398     to always fail with ENOSYS.  Some functions are actually named
9399     something starting with __ and the normal name is an alias.  */
9400 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9401 choke me
9402 #else
9403 $ac_func();
9404 #endif
9405
9406 ; return 0; }
9407 EOF
9408 if { (eval echo configure:9409: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9409   rm -rf conftest*
9410   eval "ac_cv_func_$ac_func=yes"
9411 else
9412   echo "configure: failed program was:" >&5
9413   cat conftest.$ac_ext >&5
9414   rm -rf conftest*
9415   eval "ac_cv_func_$ac_func=no"
9416 fi
9417 rm -f conftest*
9418 fi
9419
9420 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9421   echo "$ac_t""yes" 1>&6
9422     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9423   cat >> confdefs.h <<EOF
9424 #define $ac_tr_func 1
9425 EOF
9426
9427 else
9428   echo "$ac_t""no" 1>&6
9429 fi
9430 done
9431
9432   fi
9433
9434
9435
9436   ac_ext=C
9437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9438 ac_cpp='$CXXCPP $CPPFLAGS'
9439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9441 cross_compiling=$ac_cv_prog_cxx_cross
9442
9443   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
9444 echo "configure:9445: checking for tanl declaration" >&5
9445   cat > conftest.$ac_ext <<EOF
9446 #line 9447 "configure"
9447 #include "confdefs.h"
9448 #include <math.h>
9449 int main() {
9450  tanl(0);
9451 ; return 0; }
9452 EOF
9453 if { (eval echo configure:9454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9454   rm -rf conftest*
9455   use_tanl=yes
9456 else
9457   echo "configure: failed program was:" >&5
9458   cat conftest.$ac_ext >&5
9459   rm -rf conftest*
9460   use_tanl=no
9461 fi
9462 rm -f conftest*
9463   echo "$ac_t""$use_tanl" 1>&6
9464   ac_ext=c
9465 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9466 ac_cpp='$CPP $CPPFLAGS'
9467 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9468 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9469 cross_compiling=$ac_cv_prog_cc_cross
9470
9471   if test x$use_tanl = x"yes"; then
9472     for ac_func in tanl
9473 do
9474 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9475 echo "configure:9476: checking for $ac_func" >&5
9476 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9477   echo $ac_n "(cached) $ac_c" 1>&6
9478 else
9479   cat > conftest.$ac_ext <<EOF
9480 #line 9481 "configure"
9481 #include "confdefs.h"
9482 /* System header to define __stub macros and hopefully few prototypes,
9483     which can conflict with char $ac_func(); below.  */
9484 #include <assert.h>
9485 /* Override any gcc2 internal prototype to avoid an error.  */
9486 /* We use char because int might match the return type of a gcc2
9487     builtin and then its argument prototype would still apply.  */
9488 char $ac_func();
9489
9490 int main() {
9491
9492 /* The GNU C library defines this for functions which it implements
9493     to always fail with ENOSYS.  Some functions are actually named
9494     something starting with __ and the normal name is an alias.  */
9495 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9496 choke me
9497 #else
9498 $ac_func();
9499 #endif
9500
9501 ; return 0; }
9502 EOF
9503 if { (eval echo configure:9504: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9504   rm -rf conftest*
9505   eval "ac_cv_func_$ac_func=yes"
9506 else
9507   echo "configure: failed program was:" >&5
9508   cat conftest.$ac_ext >&5
9509   rm -rf conftest*
9510   eval "ac_cv_func_$ac_func=no"
9511 fi
9512 rm -f conftest*
9513 fi
9514
9515 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9516   echo "$ac_t""yes" 1>&6
9517     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9518   cat >> confdefs.h <<EOF
9519 #define $ac_tr_func 1
9520 EOF
9521
9522 else
9523   echo "$ac_t""no" 1>&6
9524 fi
9525 done
9526
9527   fi
9528
9529
9530
9531   ac_ext=C
9532 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9533 ac_cpp='$CXXCPP $CPPFLAGS'
9534 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9535 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9536 cross_compiling=$ac_cv_prog_cxx_cross
9537
9538   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
9539 echo "configure:9540: checking for tanhl declaration" >&5
9540   cat > conftest.$ac_ext <<EOF
9541 #line 9542 "configure"
9542 #include "confdefs.h"
9543 #include <math.h>
9544 int main() {
9545  tanhl(0);
9546 ; return 0; }
9547 EOF
9548 if { (eval echo configure:9549: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9549   rm -rf conftest*
9550   use_tanhl=yes
9551 else
9552   echo "configure: failed program was:" >&5
9553   cat conftest.$ac_ext >&5
9554   rm -rf conftest*
9555   use_tanhl=no
9556 fi
9557 rm -f conftest*
9558   echo "$ac_t""$use_tanhl" 1>&6
9559   ac_ext=c
9560 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9561 ac_cpp='$CPP $CPPFLAGS'
9562 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9563 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9564 cross_compiling=$ac_cv_prog_cc_cross
9565
9566   if test x$use_tanhl = x"yes"; then
9567     for ac_func in tanhl
9568 do
9569 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9570 echo "configure:9571: checking for $ac_func" >&5
9571 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9572   echo $ac_n "(cached) $ac_c" 1>&6
9573 else
9574   cat > conftest.$ac_ext <<EOF
9575 #line 9576 "configure"
9576 #include "confdefs.h"
9577 /* System header to define __stub macros and hopefully few prototypes,
9578     which can conflict with char $ac_func(); below.  */
9579 #include <assert.h>
9580 /* Override any gcc2 internal prototype to avoid an error.  */
9581 /* We use char because int might match the return type of a gcc2
9582     builtin and then its argument prototype would still apply.  */
9583 char $ac_func();
9584
9585 int main() {
9586
9587 /* The GNU C library defines this for functions which it implements
9588     to always fail with ENOSYS.  Some functions are actually named
9589     something starting with __ and the normal name is an alias.  */
9590 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9591 choke me
9592 #else
9593 $ac_func();
9594 #endif
9595
9596 ; return 0; }
9597 EOF
9598 if { (eval echo configure:9599: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9599   rm -rf conftest*
9600   eval "ac_cv_func_$ac_func=yes"
9601 else
9602   echo "configure: failed program was:" >&5
9603   cat conftest.$ac_ext >&5
9604   rm -rf conftest*
9605   eval "ac_cv_func_$ac_func=no"
9606 fi
9607 rm -f conftest*
9608 fi
9609
9610 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9611   echo "$ac_t""yes" 1>&6
9612     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9613   cat >> confdefs.h <<EOF
9614 #define $ac_tr_func 1
9615 EOF
9616
9617 else
9618   echo "$ac_t""no" 1>&6
9619 fi
9620 done
9621
9622   fi
9623
9624
9625
9626   ac_ext=C
9627 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9628 ac_cpp='$CXXCPP $CPPFLAGS'
9629 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9630 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9631 cross_compiling=$ac_cv_prog_cxx_cross
9632
9633   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
9634 echo "configure:9635: checking for sincosl declaration" >&5
9635   cat > conftest.$ac_ext <<EOF
9636 #line 9637 "configure"
9637 #include "confdefs.h"
9638 #include <math.h>
9639 int main() {
9640  sincosl(0, 0, 0);
9641 ; return 0; }
9642 EOF
9643 if { (eval echo configure:9644: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9644   rm -rf conftest*
9645   use_sincosl=yes
9646 else
9647   echo "configure: failed program was:" >&5
9648   cat conftest.$ac_ext >&5
9649   rm -rf conftest*
9650   use_sincosl=no
9651 fi
9652 rm -f conftest*
9653   echo "$ac_t""$use_sincosl" 1>&6
9654   ac_ext=c
9655 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9656 ac_cpp='$CPP $CPPFLAGS'
9657 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9658 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9659 cross_compiling=$ac_cv_prog_cc_cross
9660
9661   if test x$use_sincosl = x"yes"; then
9662     for ac_func in sincosl
9663 do
9664 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9665 echo "configure:9666: checking for $ac_func" >&5
9666 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9667   echo $ac_n "(cached) $ac_c" 1>&6
9668 else
9669   cat > conftest.$ac_ext <<EOF
9670 #line 9671 "configure"
9671 #include "confdefs.h"
9672 /* System header to define __stub macros and hopefully few prototypes,
9673     which can conflict with char $ac_func(); below.  */
9674 #include <assert.h>
9675 /* Override any gcc2 internal prototype to avoid an error.  */
9676 /* We use char because int might match the return type of a gcc2
9677     builtin and then its argument prototype would still apply.  */
9678 char $ac_func();
9679
9680 int main() {
9681
9682 /* The GNU C library defines this for functions which it implements
9683     to always fail with ENOSYS.  Some functions are actually named
9684     something starting with __ and the normal name is an alias.  */
9685 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9686 choke me
9687 #else
9688 $ac_func();
9689 #endif
9690
9691 ; return 0; }
9692 EOF
9693 if { (eval echo configure:9694: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9694   rm -rf conftest*
9695   eval "ac_cv_func_$ac_func=yes"
9696 else
9697   echo "configure: failed program was:" >&5
9698   cat conftest.$ac_ext >&5
9699   rm -rf conftest*
9700   eval "ac_cv_func_$ac_func=no"
9701 fi
9702 rm -f conftest*
9703 fi
9704
9705 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9706   echo "$ac_t""yes" 1>&6
9707     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9708   cat >> confdefs.h <<EOF
9709 #define $ac_tr_func 1
9710 EOF
9711
9712 else
9713   echo "$ac_t""no" 1>&6
9714 fi
9715 done
9716
9717   fi
9718
9719
9720
9721   ac_ext=C
9722 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9723 ac_cpp='$CXXCPP $CPPFLAGS'
9724 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9725 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9726 cross_compiling=$ac_cv_prog_cxx_cross
9727
9728   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
9729 echo "configure:9730: checking for finitel declaration" >&5
9730   cat > conftest.$ac_ext <<EOF
9731 #line 9732 "configure"
9732 #include "confdefs.h"
9733 #include <math.h>
9734 int main() {
9735  finitel(0);
9736 ; return 0; }
9737 EOF
9738 if { (eval echo configure:9739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9739   rm -rf conftest*
9740   use_finitel=yes
9741 else
9742   echo "configure: failed program was:" >&5
9743   cat conftest.$ac_ext >&5
9744   rm -rf conftest*
9745   use_finitel=no
9746 fi
9747 rm -f conftest*
9748   echo "$ac_t""$use_finitel" 1>&6
9749   ac_ext=c
9750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9751 ac_cpp='$CPP $CPPFLAGS'
9752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9754 cross_compiling=$ac_cv_prog_cc_cross
9755
9756   if test x$use_finitel = x"yes"; then
9757     for ac_func in finitel
9758 do
9759 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9760 echo "configure:9761: checking for $ac_func" >&5
9761 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9762   echo $ac_n "(cached) $ac_c" 1>&6
9763 else
9764   cat > conftest.$ac_ext <<EOF
9765 #line 9766 "configure"
9766 #include "confdefs.h"
9767 /* System header to define __stub macros and hopefully few prototypes,
9768     which can conflict with char $ac_func(); below.  */
9769 #include <assert.h>
9770 /* Override any gcc2 internal prototype to avoid an error.  */
9771 /* We use char because int might match the return type of a gcc2
9772     builtin and then its argument prototype would still apply.  */
9773 char $ac_func();
9774
9775 int main() {
9776
9777 /* The GNU C library defines this for functions which it implements
9778     to always fail with ENOSYS.  Some functions are actually named
9779     something starting with __ and the normal name is an alias.  */
9780 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9781 choke me
9782 #else
9783 $ac_func();
9784 #endif
9785
9786 ; return 0; }
9787 EOF
9788 if { (eval echo configure:9789: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9789   rm -rf conftest*
9790   eval "ac_cv_func_$ac_func=yes"
9791 else
9792   echo "configure: failed program was:" >&5
9793   cat conftest.$ac_ext >&5
9794   rm -rf conftest*
9795   eval "ac_cv_func_$ac_func=no"
9796 fi
9797 rm -f conftest*
9798 fi
9799
9800 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9801   echo "$ac_t""yes" 1>&6
9802     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9803   cat >> confdefs.h <<EOF
9804 #define $ac_tr_func 1
9805 EOF
9806
9807 else
9808   echo "$ac_t""no" 1>&6
9809 fi
9810 done
9811
9812   fi
9813
9814
9815
9816
9817   ac_ext=C
9818 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9819 ac_cpp='$CXXCPP $CPPFLAGS'
9820 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9821 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9822 cross_compiling=$ac_cv_prog_cxx_cross
9823
9824   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
9825 echo "configure:9826: checking for _isinf declaration" >&5
9826   cat > conftest.$ac_ext <<EOF
9827 #line 9828 "configure"
9828 #include "confdefs.h"
9829 #include <math.h>
9830 int main() {
9831  _isinf(0);
9832 ; return 0; }
9833 EOF
9834 if { (eval echo configure:9835: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9835   rm -rf conftest*
9836   use__isinf=yes
9837 else
9838   echo "configure: failed program was:" >&5
9839   cat conftest.$ac_ext >&5
9840   rm -rf conftest*
9841   use__isinf=no
9842 fi
9843 rm -f conftest*
9844   echo "$ac_t""$use__isinf" 1>&6
9845   ac_ext=c
9846 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9847 ac_cpp='$CPP $CPPFLAGS'
9848 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9849 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9850 cross_compiling=$ac_cv_prog_cc_cross
9851
9852   if test x$use__isinf = x"yes"; then
9853     for ac_func in _isinf
9854 do
9855 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9856 echo "configure:9857: checking for $ac_func" >&5
9857 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9858   echo $ac_n "(cached) $ac_c" 1>&6
9859 else
9860   cat > conftest.$ac_ext <<EOF
9861 #line 9862 "configure"
9862 #include "confdefs.h"
9863 /* System header to define __stub macros and hopefully few prototypes,
9864     which can conflict with char $ac_func(); below.  */
9865 #include <assert.h>
9866 /* Override any gcc2 internal prototype to avoid an error.  */
9867 /* We use char because int might match the return type of a gcc2
9868     builtin and then its argument prototype would still apply.  */
9869 char $ac_func();
9870
9871 int main() {
9872
9873 /* The GNU C library defines this for functions which it implements
9874     to always fail with ENOSYS.  Some functions are actually named
9875     something starting with __ and the normal name is an alias.  */
9876 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9877 choke me
9878 #else
9879 $ac_func();
9880 #endif
9881
9882 ; return 0; }
9883 EOF
9884 if { (eval echo configure:9885: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9885   rm -rf conftest*
9886   eval "ac_cv_func_$ac_func=yes"
9887 else
9888   echo "configure: failed program was:" >&5
9889   cat conftest.$ac_ext >&5
9890   rm -rf conftest*
9891   eval "ac_cv_func_$ac_func=no"
9892 fi
9893 rm -f conftest*
9894 fi
9895
9896 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9897   echo "$ac_t""yes" 1>&6
9898     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9899   cat >> confdefs.h <<EOF
9900 #define $ac_tr_func 1
9901 EOF
9902
9903 else
9904   echo "$ac_t""no" 1>&6
9905 fi
9906 done
9907
9908   fi
9909
9910
9911
9912   ac_ext=C
9913 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9914 ac_cpp='$CXXCPP $CPPFLAGS'
9915 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9916 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9917 cross_compiling=$ac_cv_prog_cxx_cross
9918
9919   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
9920 echo "configure:9921: checking for _isnan declaration" >&5
9921   cat > conftest.$ac_ext <<EOF
9922 #line 9923 "configure"
9923 #include "confdefs.h"
9924 #include <math.h>
9925 int main() {
9926  _isnan(0);
9927 ; return 0; }
9928 EOF
9929 if { (eval echo configure:9930: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9930   rm -rf conftest*
9931   use__isnan=yes
9932 else
9933   echo "configure: failed program was:" >&5
9934   cat conftest.$ac_ext >&5
9935   rm -rf conftest*
9936   use__isnan=no
9937 fi
9938 rm -f conftest*
9939   echo "$ac_t""$use__isnan" 1>&6
9940   ac_ext=c
9941 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9942 ac_cpp='$CPP $CPPFLAGS'
9943 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9944 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9945 cross_compiling=$ac_cv_prog_cc_cross
9946
9947   if test x$use__isnan = x"yes"; then
9948     for ac_func in _isnan
9949 do
9950 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9951 echo "configure:9952: checking for $ac_func" >&5
9952 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9953   echo $ac_n "(cached) $ac_c" 1>&6
9954 else
9955   cat > conftest.$ac_ext <<EOF
9956 #line 9957 "configure"
9957 #include "confdefs.h"
9958 /* System header to define __stub macros and hopefully few prototypes,
9959     which can conflict with char $ac_func(); below.  */
9960 #include <assert.h>
9961 /* Override any gcc2 internal prototype to avoid an error.  */
9962 /* We use char because int might match the return type of a gcc2
9963     builtin and then its argument prototype would still apply.  */
9964 char $ac_func();
9965
9966 int main() {
9967
9968 /* The GNU C library defines this for functions which it implements
9969     to always fail with ENOSYS.  Some functions are actually named
9970     something starting with __ and the normal name is an alias.  */
9971 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9972 choke me
9973 #else
9974 $ac_func();
9975 #endif
9976
9977 ; return 0; }
9978 EOF
9979 if { (eval echo configure:9980: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9980   rm -rf conftest*
9981   eval "ac_cv_func_$ac_func=yes"
9982 else
9983   echo "configure: failed program was:" >&5
9984   cat conftest.$ac_ext >&5
9985   rm -rf conftest*
9986   eval "ac_cv_func_$ac_func=no"
9987 fi
9988 rm -f conftest*
9989 fi
9990
9991 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9992   echo "$ac_t""yes" 1>&6
9993     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9994   cat >> confdefs.h <<EOF
9995 #define $ac_tr_func 1
9996 EOF
9997
9998 else
9999   echo "$ac_t""no" 1>&6
10000 fi
10001 done
10002
10003   fi
10004
10005
10006
10007   ac_ext=C
10008 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10009 ac_cpp='$CXXCPP $CPPFLAGS'
10010 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10011 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10012 cross_compiling=$ac_cv_prog_cxx_cross
10013
10014   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
10015 echo "configure:10016: checking for _finite declaration" >&5
10016   cat > conftest.$ac_ext <<EOF
10017 #line 10018 "configure"
10018 #include "confdefs.h"
10019 #include <math.h>
10020 int main() {
10021  _finite(0);
10022 ; return 0; }
10023 EOF
10024 if { (eval echo configure:10025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10025   rm -rf conftest*
10026   use__finite=yes
10027 else
10028   echo "configure: failed program was:" >&5
10029   cat conftest.$ac_ext >&5
10030   rm -rf conftest*
10031   use__finite=no
10032 fi
10033 rm -f conftest*
10034   echo "$ac_t""$use__finite" 1>&6
10035   ac_ext=c
10036 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10037 ac_cpp='$CPP $CPPFLAGS'
10038 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10039 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10040 cross_compiling=$ac_cv_prog_cc_cross
10041
10042   if test x$use__finite = x"yes"; then
10043     for ac_func in _finite
10044 do
10045 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10046 echo "configure:10047: checking for $ac_func" >&5
10047 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10048   echo $ac_n "(cached) $ac_c" 1>&6
10049 else
10050   cat > conftest.$ac_ext <<EOF
10051 #line 10052 "configure"
10052 #include "confdefs.h"
10053 /* System header to define __stub macros and hopefully few prototypes,
10054     which can conflict with char $ac_func(); below.  */
10055 #include <assert.h>
10056 /* Override any gcc2 internal prototype to avoid an error.  */
10057 /* We use char because int might match the return type of a gcc2
10058     builtin and then its argument prototype would still apply.  */
10059 char $ac_func();
10060
10061 int main() {
10062
10063 /* The GNU C library defines this for functions which it implements
10064     to always fail with ENOSYS.  Some functions are actually named
10065     something starting with __ and the normal name is an alias.  */
10066 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10067 choke me
10068 #else
10069 $ac_func();
10070 #endif
10071
10072 ; return 0; }
10073 EOF
10074 if { (eval echo configure:10075: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10075   rm -rf conftest*
10076   eval "ac_cv_func_$ac_func=yes"
10077 else
10078   echo "configure: failed program was:" >&5
10079   cat conftest.$ac_ext >&5
10080   rm -rf conftest*
10081   eval "ac_cv_func_$ac_func=no"
10082 fi
10083 rm -f conftest*
10084 fi
10085
10086 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10087   echo "$ac_t""yes" 1>&6
10088     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10089   cat >> confdefs.h <<EOF
10090 #define $ac_tr_func 1
10091 EOF
10092
10093 else
10094   echo "$ac_t""no" 1>&6
10095 fi
10096 done
10097
10098   fi
10099
10100
10101
10102   ac_ext=C
10103 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10104 ac_cpp='$CXXCPP $CPPFLAGS'
10105 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10106 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10107 cross_compiling=$ac_cv_prog_cxx_cross
10108
10109   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
10110 echo "configure:10111: checking for _copysign declaration" >&5
10111   cat > conftest.$ac_ext <<EOF
10112 #line 10113 "configure"
10113 #include "confdefs.h"
10114 #include <math.h>
10115 int main() {
10116  _copysign(0, 0);
10117 ; return 0; }
10118 EOF
10119 if { (eval echo configure:10120: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10120   rm -rf conftest*
10121   use__copysign=yes
10122 else
10123   echo "configure: failed program was:" >&5
10124   cat conftest.$ac_ext >&5
10125   rm -rf conftest*
10126   use__copysign=no
10127 fi
10128 rm -f conftest*
10129   echo "$ac_t""$use__copysign" 1>&6
10130   ac_ext=c
10131 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10132 ac_cpp='$CPP $CPPFLAGS'
10133 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10134 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10135 cross_compiling=$ac_cv_prog_cc_cross
10136
10137   if test x$use__copysign = x"yes"; then
10138     for ac_func in _copysign
10139 do
10140 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10141 echo "configure:10142: checking for $ac_func" >&5
10142 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10143   echo $ac_n "(cached) $ac_c" 1>&6
10144 else
10145   cat > conftest.$ac_ext <<EOF
10146 #line 10147 "configure"
10147 #include "confdefs.h"
10148 /* System header to define __stub macros and hopefully few prototypes,
10149     which can conflict with char $ac_func(); below.  */
10150 #include <assert.h>
10151 /* Override any gcc2 internal prototype to avoid an error.  */
10152 /* We use char because int might match the return type of a gcc2
10153     builtin and then its argument prototype would still apply.  */
10154 char $ac_func();
10155
10156 int main() {
10157
10158 /* The GNU C library defines this for functions which it implements
10159     to always fail with ENOSYS.  Some functions are actually named
10160     something starting with __ and the normal name is an alias.  */
10161 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10162 choke me
10163 #else
10164 $ac_func();
10165 #endif
10166
10167 ; return 0; }
10168 EOF
10169 if { (eval echo configure:10170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10170   rm -rf conftest*
10171   eval "ac_cv_func_$ac_func=yes"
10172 else
10173   echo "configure: failed program was:" >&5
10174   cat conftest.$ac_ext >&5
10175   rm -rf conftest*
10176   eval "ac_cv_func_$ac_func=no"
10177 fi
10178 rm -f conftest*
10179 fi
10180
10181 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10182   echo "$ac_t""yes" 1>&6
10183     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10184   cat >> confdefs.h <<EOF
10185 #define $ac_tr_func 1
10186 EOF
10187
10188 else
10189   echo "$ac_t""no" 1>&6
10190 fi
10191 done
10192
10193   fi
10194
10195
10196
10197   ac_ext=C
10198 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10199 ac_cpp='$CXXCPP $CPPFLAGS'
10200 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10201 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10202 cross_compiling=$ac_cv_prog_cxx_cross
10203
10204   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
10205 echo "configure:10206: checking for _sincos declaration" >&5
10206   cat > conftest.$ac_ext <<EOF
10207 #line 10208 "configure"
10208 #include "confdefs.h"
10209 #include <math.h>
10210 int main() {
10211  _sincos(0, 0, 0);
10212 ; return 0; }
10213 EOF
10214 if { (eval echo configure:10215: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10215   rm -rf conftest*
10216   use__sincos=yes
10217 else
10218   echo "configure: failed program was:" >&5
10219   cat conftest.$ac_ext >&5
10220   rm -rf conftest*
10221   use__sincos=no
10222 fi
10223 rm -f conftest*
10224   echo "$ac_t""$use__sincos" 1>&6
10225   ac_ext=c
10226 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10227 ac_cpp='$CPP $CPPFLAGS'
10228 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10229 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10230 cross_compiling=$ac_cv_prog_cc_cross
10231
10232   if test x$use__sincos = x"yes"; then
10233     for ac_func in _sincos
10234 do
10235 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10236 echo "configure:10237: checking for $ac_func" >&5
10237 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10238   echo $ac_n "(cached) $ac_c" 1>&6
10239 else
10240   cat > conftest.$ac_ext <<EOF
10241 #line 10242 "configure"
10242 #include "confdefs.h"
10243 /* System header to define __stub macros and hopefully few prototypes,
10244     which can conflict with char $ac_func(); below.  */
10245 #include <assert.h>
10246 /* Override any gcc2 internal prototype to avoid an error.  */
10247 /* We use char because int might match the return type of a gcc2
10248     builtin and then its argument prototype would still apply.  */
10249 char $ac_func();
10250
10251 int main() {
10252
10253 /* The GNU C library defines this for functions which it implements
10254     to always fail with ENOSYS.  Some functions are actually named
10255     something starting with __ and the normal name is an alias.  */
10256 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10257 choke me
10258 #else
10259 $ac_func();
10260 #endif
10261
10262 ; return 0; }
10263 EOF
10264 if { (eval echo configure:10265: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10265   rm -rf conftest*
10266   eval "ac_cv_func_$ac_func=yes"
10267 else
10268   echo "configure: failed program was:" >&5
10269   cat conftest.$ac_ext >&5
10270   rm -rf conftest*
10271   eval "ac_cv_func_$ac_func=no"
10272 fi
10273 rm -f conftest*
10274 fi
10275
10276 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10277   echo "$ac_t""yes" 1>&6
10278     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10279   cat >> confdefs.h <<EOF
10280 #define $ac_tr_func 1
10281 EOF
10282
10283 else
10284   echo "$ac_t""no" 1>&6
10285 fi
10286 done
10287
10288   fi
10289
10290
10291
10292   ac_ext=C
10293 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10294 ac_cpp='$CXXCPP $CPPFLAGS'
10295 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10296 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10297 cross_compiling=$ac_cv_prog_cxx_cross
10298
10299   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
10300 echo "configure:10301: checking for _fpclass declaration" >&5
10301   cat > conftest.$ac_ext <<EOF
10302 #line 10303 "configure"
10303 #include "confdefs.h"
10304 #include <math.h>
10305 int main() {
10306  _fpclass(0);
10307 ; return 0; }
10308 EOF
10309 if { (eval echo configure:10310: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10310   rm -rf conftest*
10311   use__fpclass=yes
10312 else
10313   echo "configure: failed program was:" >&5
10314   cat conftest.$ac_ext >&5
10315   rm -rf conftest*
10316   use__fpclass=no
10317 fi
10318 rm -f conftest*
10319   echo "$ac_t""$use__fpclass" 1>&6
10320   ac_ext=c
10321 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10322 ac_cpp='$CPP $CPPFLAGS'
10323 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10324 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10325 cross_compiling=$ac_cv_prog_cc_cross
10326
10327   if test x$use__fpclass = x"yes"; then
10328     for ac_func in _fpclass
10329 do
10330 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10331 echo "configure:10332: checking for $ac_func" >&5
10332 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10333   echo $ac_n "(cached) $ac_c" 1>&6
10334 else
10335   cat > conftest.$ac_ext <<EOF
10336 #line 10337 "configure"
10337 #include "confdefs.h"
10338 /* System header to define __stub macros and hopefully few prototypes,
10339     which can conflict with char $ac_func(); below.  */
10340 #include <assert.h>
10341 /* Override any gcc2 internal prototype to avoid an error.  */
10342 /* We use char because int might match the return type of a gcc2
10343     builtin and then its argument prototype would still apply.  */
10344 char $ac_func();
10345
10346 int main() {
10347
10348 /* The GNU C library defines this for functions which it implements
10349     to always fail with ENOSYS.  Some functions are actually named
10350     something starting with __ and the normal name is an alias.  */
10351 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10352 choke me
10353 #else
10354 $ac_func();
10355 #endif
10356
10357 ; return 0; }
10358 EOF
10359 if { (eval echo configure:10360: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10360   rm -rf conftest*
10361   eval "ac_cv_func_$ac_func=yes"
10362 else
10363   echo "configure: failed program was:" >&5
10364   cat conftest.$ac_ext >&5
10365   rm -rf conftest*
10366   eval "ac_cv_func_$ac_func=no"
10367 fi
10368 rm -f conftest*
10369 fi
10370
10371 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10372   echo "$ac_t""yes" 1>&6
10373     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10374   cat >> confdefs.h <<EOF
10375 #define $ac_tr_func 1
10376 EOF
10377
10378 else
10379   echo "$ac_t""no" 1>&6
10380 fi
10381 done
10382
10383   fi
10384
10385
10386
10387   ac_ext=C
10388 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10389 ac_cpp='$CXXCPP $CPPFLAGS'
10390 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10391 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10392 cross_compiling=$ac_cv_prog_cxx_cross
10393
10394   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
10395 echo "configure:10396: checking for _qfpclass declaration" >&5
10396   cat > conftest.$ac_ext <<EOF
10397 #line 10398 "configure"
10398 #include "confdefs.h"
10399 #include <math.h>
10400 int main() {
10401  _qfpclass(0);
10402 ; return 0; }
10403 EOF
10404 if { (eval echo configure:10405: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10405   rm -rf conftest*
10406   use__qfpclass=yes
10407 else
10408   echo "configure: failed program was:" >&5
10409   cat conftest.$ac_ext >&5
10410   rm -rf conftest*
10411   use__qfpclass=no
10412 fi
10413 rm -f conftest*
10414   echo "$ac_t""$use__qfpclass" 1>&6
10415   ac_ext=c
10416 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10417 ac_cpp='$CPP $CPPFLAGS'
10418 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10419 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10420 cross_compiling=$ac_cv_prog_cc_cross
10421
10422   if test x$use__qfpclass = x"yes"; then
10423     for ac_func in _qfpclass
10424 do
10425 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10426 echo "configure:10427: checking for $ac_func" >&5
10427 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10428   echo $ac_n "(cached) $ac_c" 1>&6
10429 else
10430   cat > conftest.$ac_ext <<EOF
10431 #line 10432 "configure"
10432 #include "confdefs.h"
10433 /* System header to define __stub macros and hopefully few prototypes,
10434     which can conflict with char $ac_func(); below.  */
10435 #include <assert.h>
10436 /* Override any gcc2 internal prototype to avoid an error.  */
10437 /* We use char because int might match the return type of a gcc2
10438     builtin and then its argument prototype would still apply.  */
10439 char $ac_func();
10440
10441 int main() {
10442
10443 /* The GNU C library defines this for functions which it implements
10444     to always fail with ENOSYS.  Some functions are actually named
10445     something starting with __ and the normal name is an alias.  */
10446 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10447 choke me
10448 #else
10449 $ac_func();
10450 #endif
10451
10452 ; return 0; }
10453 EOF
10454 if { (eval echo configure:10455: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10455   rm -rf conftest*
10456   eval "ac_cv_func_$ac_func=yes"
10457 else
10458   echo "configure: failed program was:" >&5
10459   cat conftest.$ac_ext >&5
10460   rm -rf conftest*
10461   eval "ac_cv_func_$ac_func=no"
10462 fi
10463 rm -f conftest*
10464 fi
10465
10466 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10467   echo "$ac_t""yes" 1>&6
10468     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10469   cat >> confdefs.h <<EOF
10470 #define $ac_tr_func 1
10471 EOF
10472
10473 else
10474   echo "$ac_t""no" 1>&6
10475 fi
10476 done
10477
10478   fi
10479
10480
10481
10482
10483   ac_ext=C
10484 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10485 ac_cpp='$CXXCPP $CPPFLAGS'
10486 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10487 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10488 cross_compiling=$ac_cv_prog_cxx_cross
10489
10490   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
10491 echo "configure:10492: checking for _isnanf declaration" >&5
10492   cat > conftest.$ac_ext <<EOF
10493 #line 10494 "configure"
10494 #include "confdefs.h"
10495 #include <math.h>
10496 int main() {
10497  _isnanf(0);
10498 ; return 0; }
10499 EOF
10500 if { (eval echo configure:10501: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10501   rm -rf conftest*
10502   use__isnanf=yes
10503 else
10504   echo "configure: failed program was:" >&5
10505   cat conftest.$ac_ext >&5
10506   rm -rf conftest*
10507   use__isnanf=no
10508 fi
10509 rm -f conftest*
10510   echo "$ac_t""$use__isnanf" 1>&6
10511   ac_ext=c
10512 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10513 ac_cpp='$CPP $CPPFLAGS'
10514 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10515 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10516 cross_compiling=$ac_cv_prog_cc_cross
10517
10518   if test x$use__isnanf = x"yes"; then
10519     for ac_func in _isnanf
10520 do
10521 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10522 echo "configure:10523: checking for $ac_func" >&5
10523 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10524   echo $ac_n "(cached) $ac_c" 1>&6
10525 else
10526   cat > conftest.$ac_ext <<EOF
10527 #line 10528 "configure"
10528 #include "confdefs.h"
10529 /* System header to define __stub macros and hopefully few prototypes,
10530     which can conflict with char $ac_func(); below.  */
10531 #include <assert.h>
10532 /* Override any gcc2 internal prototype to avoid an error.  */
10533 /* We use char because int might match the return type of a gcc2
10534     builtin and then its argument prototype would still apply.  */
10535 char $ac_func();
10536
10537 int main() {
10538
10539 /* The GNU C library defines this for functions which it implements
10540     to always fail with ENOSYS.  Some functions are actually named
10541     something starting with __ and the normal name is an alias.  */
10542 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10543 choke me
10544 #else
10545 $ac_func();
10546 #endif
10547
10548 ; return 0; }
10549 EOF
10550 if { (eval echo configure:10551: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10551   rm -rf conftest*
10552   eval "ac_cv_func_$ac_func=yes"
10553 else
10554   echo "configure: failed program was:" >&5
10555   cat conftest.$ac_ext >&5
10556   rm -rf conftest*
10557   eval "ac_cv_func_$ac_func=no"
10558 fi
10559 rm -f conftest*
10560 fi
10561
10562 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10563   echo "$ac_t""yes" 1>&6
10564     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10565   cat >> confdefs.h <<EOF
10566 #define $ac_tr_func 1
10567 EOF
10568
10569 else
10570   echo "$ac_t""no" 1>&6
10571 fi
10572 done
10573
10574   fi
10575
10576
10577
10578   ac_ext=C
10579 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10580 ac_cpp='$CXXCPP $CPPFLAGS'
10581 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10582 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10583 cross_compiling=$ac_cv_prog_cxx_cross
10584
10585   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
10586 echo "configure:10587: checking for _isinff declaration" >&5
10587   cat > conftest.$ac_ext <<EOF
10588 #line 10589 "configure"
10589 #include "confdefs.h"
10590 #include <math.h>
10591 int main() {
10592  _isinff(0);
10593 ; return 0; }
10594 EOF
10595 if { (eval echo configure:10596: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10596   rm -rf conftest*
10597   use__isinff=yes
10598 else
10599   echo "configure: failed program was:" >&5
10600   cat conftest.$ac_ext >&5
10601   rm -rf conftest*
10602   use__isinff=no
10603 fi
10604 rm -f conftest*
10605   echo "$ac_t""$use__isinff" 1>&6
10606   ac_ext=c
10607 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10608 ac_cpp='$CPP $CPPFLAGS'
10609 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10610 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10611 cross_compiling=$ac_cv_prog_cc_cross
10612
10613   if test x$use__isinff = x"yes"; then
10614     for ac_func in _isinff
10615 do
10616 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10617 echo "configure:10618: checking for $ac_func" >&5
10618 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10619   echo $ac_n "(cached) $ac_c" 1>&6
10620 else
10621   cat > conftest.$ac_ext <<EOF
10622 #line 10623 "configure"
10623 #include "confdefs.h"
10624 /* System header to define __stub macros and hopefully few prototypes,
10625     which can conflict with char $ac_func(); below.  */
10626 #include <assert.h>
10627 /* Override any gcc2 internal prototype to avoid an error.  */
10628 /* We use char because int might match the return type of a gcc2
10629     builtin and then its argument prototype would still apply.  */
10630 char $ac_func();
10631
10632 int main() {
10633
10634 /* The GNU C library defines this for functions which it implements
10635     to always fail with ENOSYS.  Some functions are actually named
10636     something starting with __ and the normal name is an alias.  */
10637 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10638 choke me
10639 #else
10640 $ac_func();
10641 #endif
10642
10643 ; return 0; }
10644 EOF
10645 if { (eval echo configure:10646: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10646   rm -rf conftest*
10647   eval "ac_cv_func_$ac_func=yes"
10648 else
10649   echo "configure: failed program was:" >&5
10650   cat conftest.$ac_ext >&5
10651   rm -rf conftest*
10652   eval "ac_cv_func_$ac_func=no"
10653 fi
10654 rm -f conftest*
10655 fi
10656
10657 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10658   echo "$ac_t""yes" 1>&6
10659     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10660   cat >> confdefs.h <<EOF
10661 #define $ac_tr_func 1
10662 EOF
10663
10664 else
10665   echo "$ac_t""no" 1>&6
10666 fi
10667 done
10668
10669   fi
10670
10671
10672
10673   ac_ext=C
10674 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10675 ac_cpp='$CXXCPP $CPPFLAGS'
10676 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10677 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10678 cross_compiling=$ac_cv_prog_cxx_cross
10679
10680   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
10681 echo "configure:10682: checking for _acosf declaration" >&5
10682   cat > conftest.$ac_ext <<EOF
10683 #line 10684 "configure"
10684 #include "confdefs.h"
10685 #include <math.h>
10686 int main() {
10687  _acosf(0);
10688 ; return 0; }
10689 EOF
10690 if { (eval echo configure:10691: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10691   rm -rf conftest*
10692   use__acosf=yes
10693 else
10694   echo "configure: failed program was:" >&5
10695   cat conftest.$ac_ext >&5
10696   rm -rf conftest*
10697   use__acosf=no
10698 fi
10699 rm -f conftest*
10700   echo "$ac_t""$use__acosf" 1>&6
10701   ac_ext=c
10702 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10703 ac_cpp='$CPP $CPPFLAGS'
10704 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10705 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10706 cross_compiling=$ac_cv_prog_cc_cross
10707
10708   if test x$use__acosf = x"yes"; then
10709     for ac_func in _acosf
10710 do
10711 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10712 echo "configure:10713: checking for $ac_func" >&5
10713 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10714   echo $ac_n "(cached) $ac_c" 1>&6
10715 else
10716   cat > conftest.$ac_ext <<EOF
10717 #line 10718 "configure"
10718 #include "confdefs.h"
10719 /* System header to define __stub macros and hopefully few prototypes,
10720     which can conflict with char $ac_func(); below.  */
10721 #include <assert.h>
10722 /* Override any gcc2 internal prototype to avoid an error.  */
10723 /* We use char because int might match the return type of a gcc2
10724     builtin and then its argument prototype would still apply.  */
10725 char $ac_func();
10726
10727 int main() {
10728
10729 /* The GNU C library defines this for functions which it implements
10730     to always fail with ENOSYS.  Some functions are actually named
10731     something starting with __ and the normal name is an alias.  */
10732 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10733 choke me
10734 #else
10735 $ac_func();
10736 #endif
10737
10738 ; return 0; }
10739 EOF
10740 if { (eval echo configure:10741: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10741   rm -rf conftest*
10742   eval "ac_cv_func_$ac_func=yes"
10743 else
10744   echo "configure: failed program was:" >&5
10745   cat conftest.$ac_ext >&5
10746   rm -rf conftest*
10747   eval "ac_cv_func_$ac_func=no"
10748 fi
10749 rm -f conftest*
10750 fi
10751
10752 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10753   echo "$ac_t""yes" 1>&6
10754     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10755   cat >> confdefs.h <<EOF
10756 #define $ac_tr_func 1
10757 EOF
10758
10759 else
10760   echo "$ac_t""no" 1>&6
10761 fi
10762 done
10763
10764   fi
10765
10766
10767
10768   ac_ext=C
10769 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10770 ac_cpp='$CXXCPP $CPPFLAGS'
10771 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10772 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10773 cross_compiling=$ac_cv_prog_cxx_cross
10774
10775   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
10776 echo "configure:10777: checking for _asinf declaration" >&5
10777   cat > conftest.$ac_ext <<EOF
10778 #line 10779 "configure"
10779 #include "confdefs.h"
10780 #include <math.h>
10781 int main() {
10782  _asinf(0);
10783 ; return 0; }
10784 EOF
10785 if { (eval echo configure:10786: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10786   rm -rf conftest*
10787   use__asinf=yes
10788 else
10789   echo "configure: failed program was:" >&5
10790   cat conftest.$ac_ext >&5
10791   rm -rf conftest*
10792   use__asinf=no
10793 fi
10794 rm -f conftest*
10795   echo "$ac_t""$use__asinf" 1>&6
10796   ac_ext=c
10797 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10798 ac_cpp='$CPP $CPPFLAGS'
10799 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10800 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10801 cross_compiling=$ac_cv_prog_cc_cross
10802
10803   if test x$use__asinf = x"yes"; then
10804     for ac_func in _asinf
10805 do
10806 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10807 echo "configure:10808: checking for $ac_func" >&5
10808 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10809   echo $ac_n "(cached) $ac_c" 1>&6
10810 else
10811   cat > conftest.$ac_ext <<EOF
10812 #line 10813 "configure"
10813 #include "confdefs.h"
10814 /* System header to define __stub macros and hopefully few prototypes,
10815     which can conflict with char $ac_func(); below.  */
10816 #include <assert.h>
10817 /* Override any gcc2 internal prototype to avoid an error.  */
10818 /* We use char because int might match the return type of a gcc2
10819     builtin and then its argument prototype would still apply.  */
10820 char $ac_func();
10821
10822 int main() {
10823
10824 /* The GNU C library defines this for functions which it implements
10825     to always fail with ENOSYS.  Some functions are actually named
10826     something starting with __ and the normal name is an alias.  */
10827 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10828 choke me
10829 #else
10830 $ac_func();
10831 #endif
10832
10833 ; return 0; }
10834 EOF
10835 if { (eval echo configure:10836: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10836   rm -rf conftest*
10837   eval "ac_cv_func_$ac_func=yes"
10838 else
10839   echo "configure: failed program was:" >&5
10840   cat conftest.$ac_ext >&5
10841   rm -rf conftest*
10842   eval "ac_cv_func_$ac_func=no"
10843 fi
10844 rm -f conftest*
10845 fi
10846
10847 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10848   echo "$ac_t""yes" 1>&6
10849     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10850   cat >> confdefs.h <<EOF
10851 #define $ac_tr_func 1
10852 EOF
10853
10854 else
10855   echo "$ac_t""no" 1>&6
10856 fi
10857 done
10858
10859   fi
10860
10861
10862
10863   ac_ext=C
10864 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10865 ac_cpp='$CXXCPP $CPPFLAGS'
10866 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10867 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10868 cross_compiling=$ac_cv_prog_cxx_cross
10869
10870   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
10871 echo "configure:10872: checking for _atanf declaration" >&5
10872   cat > conftest.$ac_ext <<EOF
10873 #line 10874 "configure"
10874 #include "confdefs.h"
10875 #include <math.h>
10876 int main() {
10877  _atanf(0);
10878 ; return 0; }
10879 EOF
10880 if { (eval echo configure:10881: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10881   rm -rf conftest*
10882   use__atanf=yes
10883 else
10884   echo "configure: failed program was:" >&5
10885   cat conftest.$ac_ext >&5
10886   rm -rf conftest*
10887   use__atanf=no
10888 fi
10889 rm -f conftest*
10890   echo "$ac_t""$use__atanf" 1>&6
10891   ac_ext=c
10892 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10893 ac_cpp='$CPP $CPPFLAGS'
10894 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10895 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10896 cross_compiling=$ac_cv_prog_cc_cross
10897
10898   if test x$use__atanf = x"yes"; then
10899     for ac_func in _atanf
10900 do
10901 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10902 echo "configure:10903: checking for $ac_func" >&5
10903 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10904   echo $ac_n "(cached) $ac_c" 1>&6
10905 else
10906   cat > conftest.$ac_ext <<EOF
10907 #line 10908 "configure"
10908 #include "confdefs.h"
10909 /* System header to define __stub macros and hopefully few prototypes,
10910     which can conflict with char $ac_func(); below.  */
10911 #include <assert.h>
10912 /* Override any gcc2 internal prototype to avoid an error.  */
10913 /* We use char because int might match the return type of a gcc2
10914     builtin and then its argument prototype would still apply.  */
10915 char $ac_func();
10916
10917 int main() {
10918
10919 /* The GNU C library defines this for functions which it implements
10920     to always fail with ENOSYS.  Some functions are actually named
10921     something starting with __ and the normal name is an alias.  */
10922 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10923 choke me
10924 #else
10925 $ac_func();
10926 #endif
10927
10928 ; return 0; }
10929 EOF
10930 if { (eval echo configure:10931: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10931   rm -rf conftest*
10932   eval "ac_cv_func_$ac_func=yes"
10933 else
10934   echo "configure: failed program was:" >&5
10935   cat conftest.$ac_ext >&5
10936   rm -rf conftest*
10937   eval "ac_cv_func_$ac_func=no"
10938 fi
10939 rm -f conftest*
10940 fi
10941
10942 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10943   echo "$ac_t""yes" 1>&6
10944     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10945   cat >> confdefs.h <<EOF
10946 #define $ac_tr_func 1
10947 EOF
10948
10949 else
10950   echo "$ac_t""no" 1>&6
10951 fi
10952 done
10953
10954   fi
10955
10956
10957
10958   ac_ext=C
10959 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10960 ac_cpp='$CXXCPP $CPPFLAGS'
10961 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10962 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10963 cross_compiling=$ac_cv_prog_cxx_cross
10964
10965   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
10966 echo "configure:10967: checking for _atan2f declaration" >&5
10967   cat > conftest.$ac_ext <<EOF
10968 #line 10969 "configure"
10969 #include "confdefs.h"
10970 #include <math.h>
10971 int main() {
10972  _atan2f(0, 0);
10973 ; return 0; }
10974 EOF
10975 if { (eval echo configure:10976: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10976   rm -rf conftest*
10977   use__atan2f=yes
10978 else
10979   echo "configure: failed program was:" >&5
10980   cat conftest.$ac_ext >&5
10981   rm -rf conftest*
10982   use__atan2f=no
10983 fi
10984 rm -f conftest*
10985   echo "$ac_t""$use__atan2f" 1>&6
10986   ac_ext=c
10987 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10988 ac_cpp='$CPP $CPPFLAGS'
10989 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10990 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10991 cross_compiling=$ac_cv_prog_cc_cross
10992
10993   if test x$use__atan2f = x"yes"; then
10994     for ac_func in _atan2f
10995 do
10996 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10997 echo "configure:10998: checking for $ac_func" >&5
10998 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10999   echo $ac_n "(cached) $ac_c" 1>&6
11000 else
11001   cat > conftest.$ac_ext <<EOF
11002 #line 11003 "configure"
11003 #include "confdefs.h"
11004 /* System header to define __stub macros and hopefully few prototypes,
11005     which can conflict with char $ac_func(); below.  */
11006 #include <assert.h>
11007 /* Override any gcc2 internal prototype to avoid an error.  */
11008 /* We use char because int might match the return type of a gcc2
11009     builtin and then its argument prototype would still apply.  */
11010 char $ac_func();
11011
11012 int main() {
11013
11014 /* The GNU C library defines this for functions which it implements
11015     to always fail with ENOSYS.  Some functions are actually named
11016     something starting with __ and the normal name is an alias.  */
11017 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11018 choke me
11019 #else
11020 $ac_func();
11021 #endif
11022
11023 ; return 0; }
11024 EOF
11025 if { (eval echo configure:11026: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11026   rm -rf conftest*
11027   eval "ac_cv_func_$ac_func=yes"
11028 else
11029   echo "configure: failed program was:" >&5
11030   cat conftest.$ac_ext >&5
11031   rm -rf conftest*
11032   eval "ac_cv_func_$ac_func=no"
11033 fi
11034 rm -f conftest*
11035 fi
11036
11037 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11038   echo "$ac_t""yes" 1>&6
11039     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11040   cat >> confdefs.h <<EOF
11041 #define $ac_tr_func 1
11042 EOF
11043
11044 else
11045   echo "$ac_t""no" 1>&6
11046 fi
11047 done
11048
11049   fi
11050
11051
11052
11053   ac_ext=C
11054 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11055 ac_cpp='$CXXCPP $CPPFLAGS'
11056 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11057 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11058 cross_compiling=$ac_cv_prog_cxx_cross
11059
11060   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
11061 echo "configure:11062: checking for _ceilf declaration" >&5
11062   cat > conftest.$ac_ext <<EOF
11063 #line 11064 "configure"
11064 #include "confdefs.h"
11065 #include <math.h>
11066 int main() {
11067  _ceilf(0);
11068 ; return 0; }
11069 EOF
11070 if { (eval echo configure:11071: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11071   rm -rf conftest*
11072   use__ceilf=yes
11073 else
11074   echo "configure: failed program was:" >&5
11075   cat conftest.$ac_ext >&5
11076   rm -rf conftest*
11077   use__ceilf=no
11078 fi
11079 rm -f conftest*
11080   echo "$ac_t""$use__ceilf" 1>&6
11081   ac_ext=c
11082 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11083 ac_cpp='$CPP $CPPFLAGS'
11084 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11085 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11086 cross_compiling=$ac_cv_prog_cc_cross
11087
11088   if test x$use__ceilf = x"yes"; then
11089     for ac_func in _ceilf
11090 do
11091 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11092 echo "configure:11093: checking for $ac_func" >&5
11093 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11094   echo $ac_n "(cached) $ac_c" 1>&6
11095 else
11096   cat > conftest.$ac_ext <<EOF
11097 #line 11098 "configure"
11098 #include "confdefs.h"
11099 /* System header to define __stub macros and hopefully few prototypes,
11100     which can conflict with char $ac_func(); below.  */
11101 #include <assert.h>
11102 /* Override any gcc2 internal prototype to avoid an error.  */
11103 /* We use char because int might match the return type of a gcc2
11104     builtin and then its argument prototype would still apply.  */
11105 char $ac_func();
11106
11107 int main() {
11108
11109 /* The GNU C library defines this for functions which it implements
11110     to always fail with ENOSYS.  Some functions are actually named
11111     something starting with __ and the normal name is an alias.  */
11112 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11113 choke me
11114 #else
11115 $ac_func();
11116 #endif
11117
11118 ; return 0; }
11119 EOF
11120 if { (eval echo configure:11121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11121   rm -rf conftest*
11122   eval "ac_cv_func_$ac_func=yes"
11123 else
11124   echo "configure: failed program was:" >&5
11125   cat conftest.$ac_ext >&5
11126   rm -rf conftest*
11127   eval "ac_cv_func_$ac_func=no"
11128 fi
11129 rm -f conftest*
11130 fi
11131
11132 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11133   echo "$ac_t""yes" 1>&6
11134     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11135   cat >> confdefs.h <<EOF
11136 #define $ac_tr_func 1
11137 EOF
11138
11139 else
11140   echo "$ac_t""no" 1>&6
11141 fi
11142 done
11143
11144   fi
11145
11146
11147
11148   ac_ext=C
11149 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11150 ac_cpp='$CXXCPP $CPPFLAGS'
11151 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11152 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11153 cross_compiling=$ac_cv_prog_cxx_cross
11154
11155   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
11156 echo "configure:11157: checking for _cosf declaration" >&5
11157   cat > conftest.$ac_ext <<EOF
11158 #line 11159 "configure"
11159 #include "confdefs.h"
11160 #include <math.h>
11161 int main() {
11162  _cosf(0);
11163 ; return 0; }
11164 EOF
11165 if { (eval echo configure:11166: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11166   rm -rf conftest*
11167   use__cosf=yes
11168 else
11169   echo "configure: failed program was:" >&5
11170   cat conftest.$ac_ext >&5
11171   rm -rf conftest*
11172   use__cosf=no
11173 fi
11174 rm -f conftest*
11175   echo "$ac_t""$use__cosf" 1>&6
11176   ac_ext=c
11177 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11178 ac_cpp='$CPP $CPPFLAGS'
11179 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11180 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11181 cross_compiling=$ac_cv_prog_cc_cross
11182
11183   if test x$use__cosf = x"yes"; then
11184     for ac_func in _cosf
11185 do
11186 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11187 echo "configure:11188: checking for $ac_func" >&5
11188 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11189   echo $ac_n "(cached) $ac_c" 1>&6
11190 else
11191   cat > conftest.$ac_ext <<EOF
11192 #line 11193 "configure"
11193 #include "confdefs.h"
11194 /* System header to define __stub macros and hopefully few prototypes,
11195     which can conflict with char $ac_func(); below.  */
11196 #include <assert.h>
11197 /* Override any gcc2 internal prototype to avoid an error.  */
11198 /* We use char because int might match the return type of a gcc2
11199     builtin and then its argument prototype would still apply.  */
11200 char $ac_func();
11201
11202 int main() {
11203
11204 /* The GNU C library defines this for functions which it implements
11205     to always fail with ENOSYS.  Some functions are actually named
11206     something starting with __ and the normal name is an alias.  */
11207 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11208 choke me
11209 #else
11210 $ac_func();
11211 #endif
11212
11213 ; return 0; }
11214 EOF
11215 if { (eval echo configure:11216: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11216   rm -rf conftest*
11217   eval "ac_cv_func_$ac_func=yes"
11218 else
11219   echo "configure: failed program was:" >&5
11220   cat conftest.$ac_ext >&5
11221   rm -rf conftest*
11222   eval "ac_cv_func_$ac_func=no"
11223 fi
11224 rm -f conftest*
11225 fi
11226
11227 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11228   echo "$ac_t""yes" 1>&6
11229     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11230   cat >> confdefs.h <<EOF
11231 #define $ac_tr_func 1
11232 EOF
11233
11234 else
11235   echo "$ac_t""no" 1>&6
11236 fi
11237 done
11238
11239   fi
11240
11241
11242
11243   ac_ext=C
11244 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11245 ac_cpp='$CXXCPP $CPPFLAGS'
11246 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11247 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11248 cross_compiling=$ac_cv_prog_cxx_cross
11249
11250   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
11251 echo "configure:11252: checking for _coshf declaration" >&5
11252   cat > conftest.$ac_ext <<EOF
11253 #line 11254 "configure"
11254 #include "confdefs.h"
11255 #include <math.h>
11256 int main() {
11257  _coshf(0);
11258 ; return 0; }
11259 EOF
11260 if { (eval echo configure:11261: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11261   rm -rf conftest*
11262   use__coshf=yes
11263 else
11264   echo "configure: failed program was:" >&5
11265   cat conftest.$ac_ext >&5
11266   rm -rf conftest*
11267   use__coshf=no
11268 fi
11269 rm -f conftest*
11270   echo "$ac_t""$use__coshf" 1>&6
11271   ac_ext=c
11272 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11273 ac_cpp='$CPP $CPPFLAGS'
11274 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11275 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11276 cross_compiling=$ac_cv_prog_cc_cross
11277
11278   if test x$use__coshf = x"yes"; then
11279     for ac_func in _coshf
11280 do
11281 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11282 echo "configure:11283: checking for $ac_func" >&5
11283 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11284   echo $ac_n "(cached) $ac_c" 1>&6
11285 else
11286   cat > conftest.$ac_ext <<EOF
11287 #line 11288 "configure"
11288 #include "confdefs.h"
11289 /* System header to define __stub macros and hopefully few prototypes,
11290     which can conflict with char $ac_func(); below.  */
11291 #include <assert.h>
11292 /* Override any gcc2 internal prototype to avoid an error.  */
11293 /* We use char because int might match the return type of a gcc2
11294     builtin and then its argument prototype would still apply.  */
11295 char $ac_func();
11296
11297 int main() {
11298
11299 /* The GNU C library defines this for functions which it implements
11300     to always fail with ENOSYS.  Some functions are actually named
11301     something starting with __ and the normal name is an alias.  */
11302 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11303 choke me
11304 #else
11305 $ac_func();
11306 #endif
11307
11308 ; return 0; }
11309 EOF
11310 if { (eval echo configure:11311: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11311   rm -rf conftest*
11312   eval "ac_cv_func_$ac_func=yes"
11313 else
11314   echo "configure: failed program was:" >&5
11315   cat conftest.$ac_ext >&5
11316   rm -rf conftest*
11317   eval "ac_cv_func_$ac_func=no"
11318 fi
11319 rm -f conftest*
11320 fi
11321
11322 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11323   echo "$ac_t""yes" 1>&6
11324     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11325   cat >> confdefs.h <<EOF
11326 #define $ac_tr_func 1
11327 EOF
11328
11329 else
11330   echo "$ac_t""no" 1>&6
11331 fi
11332 done
11333
11334   fi
11335
11336
11337
11338   ac_ext=C
11339 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11340 ac_cpp='$CXXCPP $CPPFLAGS'
11341 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11342 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11343 cross_compiling=$ac_cv_prog_cxx_cross
11344
11345   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
11346 echo "configure:11347: checking for _expf declaration" >&5
11347   cat > conftest.$ac_ext <<EOF
11348 #line 11349 "configure"
11349 #include "confdefs.h"
11350 #include <math.h>
11351 int main() {
11352  _expf(0);
11353 ; return 0; }
11354 EOF
11355 if { (eval echo configure:11356: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11356   rm -rf conftest*
11357   use__expf=yes
11358 else
11359   echo "configure: failed program was:" >&5
11360   cat conftest.$ac_ext >&5
11361   rm -rf conftest*
11362   use__expf=no
11363 fi
11364 rm -f conftest*
11365   echo "$ac_t""$use__expf" 1>&6
11366   ac_ext=c
11367 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11368 ac_cpp='$CPP $CPPFLAGS'
11369 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11370 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11371 cross_compiling=$ac_cv_prog_cc_cross
11372
11373   if test x$use__expf = x"yes"; then
11374     for ac_func in _expf
11375 do
11376 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11377 echo "configure:11378: checking for $ac_func" >&5
11378 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11379   echo $ac_n "(cached) $ac_c" 1>&6
11380 else
11381   cat > conftest.$ac_ext <<EOF
11382 #line 11383 "configure"
11383 #include "confdefs.h"
11384 /* System header to define __stub macros and hopefully few prototypes,
11385     which can conflict with char $ac_func(); below.  */
11386 #include <assert.h>
11387 /* Override any gcc2 internal prototype to avoid an error.  */
11388 /* We use char because int might match the return type of a gcc2
11389     builtin and then its argument prototype would still apply.  */
11390 char $ac_func();
11391
11392 int main() {
11393
11394 /* The GNU C library defines this for functions which it implements
11395     to always fail with ENOSYS.  Some functions are actually named
11396     something starting with __ and the normal name is an alias.  */
11397 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11398 choke me
11399 #else
11400 $ac_func();
11401 #endif
11402
11403 ; return 0; }
11404 EOF
11405 if { (eval echo configure:11406: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11406   rm -rf conftest*
11407   eval "ac_cv_func_$ac_func=yes"
11408 else
11409   echo "configure: failed program was:" >&5
11410   cat conftest.$ac_ext >&5
11411   rm -rf conftest*
11412   eval "ac_cv_func_$ac_func=no"
11413 fi
11414 rm -f conftest*
11415 fi
11416
11417 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11418   echo "$ac_t""yes" 1>&6
11419     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11420   cat >> confdefs.h <<EOF
11421 #define $ac_tr_func 1
11422 EOF
11423
11424 else
11425   echo "$ac_t""no" 1>&6
11426 fi
11427 done
11428
11429   fi
11430
11431
11432
11433   ac_ext=C
11434 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11435 ac_cpp='$CXXCPP $CPPFLAGS'
11436 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11437 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11438 cross_compiling=$ac_cv_prog_cxx_cross
11439
11440   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
11441 echo "configure:11442: checking for _fabsf declaration" >&5
11442   cat > conftest.$ac_ext <<EOF
11443 #line 11444 "configure"
11444 #include "confdefs.h"
11445 #include <math.h>
11446 int main() {
11447  _fabsf(0);
11448 ; return 0; }
11449 EOF
11450 if { (eval echo configure:11451: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11451   rm -rf conftest*
11452   use__fabsf=yes
11453 else
11454   echo "configure: failed program was:" >&5
11455   cat conftest.$ac_ext >&5
11456   rm -rf conftest*
11457   use__fabsf=no
11458 fi
11459 rm -f conftest*
11460   echo "$ac_t""$use__fabsf" 1>&6
11461   ac_ext=c
11462 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11463 ac_cpp='$CPP $CPPFLAGS'
11464 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11465 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11466 cross_compiling=$ac_cv_prog_cc_cross
11467
11468   if test x$use__fabsf = x"yes"; then
11469     for ac_func in _fabsf
11470 do
11471 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11472 echo "configure:11473: checking for $ac_func" >&5
11473 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11474   echo $ac_n "(cached) $ac_c" 1>&6
11475 else
11476   cat > conftest.$ac_ext <<EOF
11477 #line 11478 "configure"
11478 #include "confdefs.h"
11479 /* System header to define __stub macros and hopefully few prototypes,
11480     which can conflict with char $ac_func(); below.  */
11481 #include <assert.h>
11482 /* Override any gcc2 internal prototype to avoid an error.  */
11483 /* We use char because int might match the return type of a gcc2
11484     builtin and then its argument prototype would still apply.  */
11485 char $ac_func();
11486
11487 int main() {
11488
11489 /* The GNU C library defines this for functions which it implements
11490     to always fail with ENOSYS.  Some functions are actually named
11491     something starting with __ and the normal name is an alias.  */
11492 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11493 choke me
11494 #else
11495 $ac_func();
11496 #endif
11497
11498 ; return 0; }
11499 EOF
11500 if { (eval echo configure:11501: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11501   rm -rf conftest*
11502   eval "ac_cv_func_$ac_func=yes"
11503 else
11504   echo "configure: failed program was:" >&5
11505   cat conftest.$ac_ext >&5
11506   rm -rf conftest*
11507   eval "ac_cv_func_$ac_func=no"
11508 fi
11509 rm -f conftest*
11510 fi
11511
11512 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11513   echo "$ac_t""yes" 1>&6
11514     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11515   cat >> confdefs.h <<EOF
11516 #define $ac_tr_func 1
11517 EOF
11518
11519 else
11520   echo "$ac_t""no" 1>&6
11521 fi
11522 done
11523
11524   fi
11525
11526
11527
11528   ac_ext=C
11529 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11530 ac_cpp='$CXXCPP $CPPFLAGS'
11531 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11532 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11533 cross_compiling=$ac_cv_prog_cxx_cross
11534
11535   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
11536 echo "configure:11537: checking for _floorf declaration" >&5
11537   cat > conftest.$ac_ext <<EOF
11538 #line 11539 "configure"
11539 #include "confdefs.h"
11540 #include <math.h>
11541 int main() {
11542  _floorf(0);
11543 ; return 0; }
11544 EOF
11545 if { (eval echo configure:11546: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11546   rm -rf conftest*
11547   use__floorf=yes
11548 else
11549   echo "configure: failed program was:" >&5
11550   cat conftest.$ac_ext >&5
11551   rm -rf conftest*
11552   use__floorf=no
11553 fi
11554 rm -f conftest*
11555   echo "$ac_t""$use__floorf" 1>&6
11556   ac_ext=c
11557 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11558 ac_cpp='$CPP $CPPFLAGS'
11559 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11560 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11561 cross_compiling=$ac_cv_prog_cc_cross
11562
11563   if test x$use__floorf = x"yes"; then
11564     for ac_func in _floorf
11565 do
11566 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11567 echo "configure:11568: checking for $ac_func" >&5
11568 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11569   echo $ac_n "(cached) $ac_c" 1>&6
11570 else
11571   cat > conftest.$ac_ext <<EOF
11572 #line 11573 "configure"
11573 #include "confdefs.h"
11574 /* System header to define __stub macros and hopefully few prototypes,
11575     which can conflict with char $ac_func(); below.  */
11576 #include <assert.h>
11577 /* Override any gcc2 internal prototype to avoid an error.  */
11578 /* We use char because int might match the return type of a gcc2
11579     builtin and then its argument prototype would still apply.  */
11580 char $ac_func();
11581
11582 int main() {
11583
11584 /* The GNU C library defines this for functions which it implements
11585     to always fail with ENOSYS.  Some functions are actually named
11586     something starting with __ and the normal name is an alias.  */
11587 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11588 choke me
11589 #else
11590 $ac_func();
11591 #endif
11592
11593 ; return 0; }
11594 EOF
11595 if { (eval echo configure:11596: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11596   rm -rf conftest*
11597   eval "ac_cv_func_$ac_func=yes"
11598 else
11599   echo "configure: failed program was:" >&5
11600   cat conftest.$ac_ext >&5
11601   rm -rf conftest*
11602   eval "ac_cv_func_$ac_func=no"
11603 fi
11604 rm -f conftest*
11605 fi
11606
11607 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11608   echo "$ac_t""yes" 1>&6
11609     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11610   cat >> confdefs.h <<EOF
11611 #define $ac_tr_func 1
11612 EOF
11613
11614 else
11615   echo "$ac_t""no" 1>&6
11616 fi
11617 done
11618
11619   fi
11620
11621
11622
11623   ac_ext=C
11624 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11625 ac_cpp='$CXXCPP $CPPFLAGS'
11626 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11627 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11628 cross_compiling=$ac_cv_prog_cxx_cross
11629
11630   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
11631 echo "configure:11632: checking for _fmodf declaration" >&5
11632   cat > conftest.$ac_ext <<EOF
11633 #line 11634 "configure"
11634 #include "confdefs.h"
11635 #include <math.h>
11636 int main() {
11637  _fmodf(0, 0);
11638 ; return 0; }
11639 EOF
11640 if { (eval echo configure:11641: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11641   rm -rf conftest*
11642   use__fmodf=yes
11643 else
11644   echo "configure: failed program was:" >&5
11645   cat conftest.$ac_ext >&5
11646   rm -rf conftest*
11647   use__fmodf=no
11648 fi
11649 rm -f conftest*
11650   echo "$ac_t""$use__fmodf" 1>&6
11651   ac_ext=c
11652 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11653 ac_cpp='$CPP $CPPFLAGS'
11654 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11655 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11656 cross_compiling=$ac_cv_prog_cc_cross
11657
11658   if test x$use__fmodf = x"yes"; then
11659     for ac_func in _fmodf
11660 do
11661 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11662 echo "configure:11663: checking for $ac_func" >&5
11663 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11664   echo $ac_n "(cached) $ac_c" 1>&6
11665 else
11666   cat > conftest.$ac_ext <<EOF
11667 #line 11668 "configure"
11668 #include "confdefs.h"
11669 /* System header to define __stub macros and hopefully few prototypes,
11670     which can conflict with char $ac_func(); below.  */
11671 #include <assert.h>
11672 /* Override any gcc2 internal prototype to avoid an error.  */
11673 /* We use char because int might match the return type of a gcc2
11674     builtin and then its argument prototype would still apply.  */
11675 char $ac_func();
11676
11677 int main() {
11678
11679 /* The GNU C library defines this for functions which it implements
11680     to always fail with ENOSYS.  Some functions are actually named
11681     something starting with __ and the normal name is an alias.  */
11682 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11683 choke me
11684 #else
11685 $ac_func();
11686 #endif
11687
11688 ; return 0; }
11689 EOF
11690 if { (eval echo configure:11691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11691   rm -rf conftest*
11692   eval "ac_cv_func_$ac_func=yes"
11693 else
11694   echo "configure: failed program was:" >&5
11695   cat conftest.$ac_ext >&5
11696   rm -rf conftest*
11697   eval "ac_cv_func_$ac_func=no"
11698 fi
11699 rm -f conftest*
11700 fi
11701
11702 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11703   echo "$ac_t""yes" 1>&6
11704     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11705   cat >> confdefs.h <<EOF
11706 #define $ac_tr_func 1
11707 EOF
11708
11709 else
11710   echo "$ac_t""no" 1>&6
11711 fi
11712 done
11713
11714   fi
11715
11716
11717
11718   ac_ext=C
11719 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11720 ac_cpp='$CXXCPP $CPPFLAGS'
11721 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11722 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11723 cross_compiling=$ac_cv_prog_cxx_cross
11724
11725   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
11726 echo "configure:11727: checking for _frexpf declaration" >&5
11727   cat > conftest.$ac_ext <<EOF
11728 #line 11729 "configure"
11729 #include "confdefs.h"
11730 #include <math.h>
11731 int main() {
11732  _frexpf(0, 0);
11733 ; return 0; }
11734 EOF
11735 if { (eval echo configure:11736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11736   rm -rf conftest*
11737   use__frexpf=yes
11738 else
11739   echo "configure: failed program was:" >&5
11740   cat conftest.$ac_ext >&5
11741   rm -rf conftest*
11742   use__frexpf=no
11743 fi
11744 rm -f conftest*
11745   echo "$ac_t""$use__frexpf" 1>&6
11746   ac_ext=c
11747 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11748 ac_cpp='$CPP $CPPFLAGS'
11749 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11750 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11751 cross_compiling=$ac_cv_prog_cc_cross
11752
11753   if test x$use__frexpf = x"yes"; then
11754     for ac_func in _frexpf
11755 do
11756 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11757 echo "configure:11758: checking for $ac_func" >&5
11758 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11759   echo $ac_n "(cached) $ac_c" 1>&6
11760 else
11761   cat > conftest.$ac_ext <<EOF
11762 #line 11763 "configure"
11763 #include "confdefs.h"
11764 /* System header to define __stub macros and hopefully few prototypes,
11765     which can conflict with char $ac_func(); below.  */
11766 #include <assert.h>
11767 /* Override any gcc2 internal prototype to avoid an error.  */
11768 /* We use char because int might match the return type of a gcc2
11769     builtin and then its argument prototype would still apply.  */
11770 char $ac_func();
11771
11772 int main() {
11773
11774 /* The GNU C library defines this for functions which it implements
11775     to always fail with ENOSYS.  Some functions are actually named
11776     something starting with __ and the normal name is an alias.  */
11777 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11778 choke me
11779 #else
11780 $ac_func();
11781 #endif
11782
11783 ; return 0; }
11784 EOF
11785 if { (eval echo configure:11786: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11786   rm -rf conftest*
11787   eval "ac_cv_func_$ac_func=yes"
11788 else
11789   echo "configure: failed program was:" >&5
11790   cat conftest.$ac_ext >&5
11791   rm -rf conftest*
11792   eval "ac_cv_func_$ac_func=no"
11793 fi
11794 rm -f conftest*
11795 fi
11796
11797 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11798   echo "$ac_t""yes" 1>&6
11799     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11800   cat >> confdefs.h <<EOF
11801 #define $ac_tr_func 1
11802 EOF
11803
11804 else
11805   echo "$ac_t""no" 1>&6
11806 fi
11807 done
11808
11809   fi
11810
11811
11812
11813   ac_ext=C
11814 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11815 ac_cpp='$CXXCPP $CPPFLAGS'
11816 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11817 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11818 cross_compiling=$ac_cv_prog_cxx_cross
11819
11820   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
11821 echo "configure:11822: checking for _ldexpf declaration" >&5
11822   cat > conftest.$ac_ext <<EOF
11823 #line 11824 "configure"
11824 #include "confdefs.h"
11825 #include <math.h>
11826 int main() {
11827  _ldexpf(0, 0);
11828 ; return 0; }
11829 EOF
11830 if { (eval echo configure:11831: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11831   rm -rf conftest*
11832   use__ldexpf=yes
11833 else
11834   echo "configure: failed program was:" >&5
11835   cat conftest.$ac_ext >&5
11836   rm -rf conftest*
11837   use__ldexpf=no
11838 fi
11839 rm -f conftest*
11840   echo "$ac_t""$use__ldexpf" 1>&6
11841   ac_ext=c
11842 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11843 ac_cpp='$CPP $CPPFLAGS'
11844 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11845 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11846 cross_compiling=$ac_cv_prog_cc_cross
11847
11848   if test x$use__ldexpf = x"yes"; then
11849     for ac_func in _ldexpf
11850 do
11851 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11852 echo "configure:11853: checking for $ac_func" >&5
11853 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11854   echo $ac_n "(cached) $ac_c" 1>&6
11855 else
11856   cat > conftest.$ac_ext <<EOF
11857 #line 11858 "configure"
11858 #include "confdefs.h"
11859 /* System header to define __stub macros and hopefully few prototypes,
11860     which can conflict with char $ac_func(); below.  */
11861 #include <assert.h>
11862 /* Override any gcc2 internal prototype to avoid an error.  */
11863 /* We use char because int might match the return type of a gcc2
11864     builtin and then its argument prototype would still apply.  */
11865 char $ac_func();
11866
11867 int main() {
11868
11869 /* The GNU C library defines this for functions which it implements
11870     to always fail with ENOSYS.  Some functions are actually named
11871     something starting with __ and the normal name is an alias.  */
11872 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11873 choke me
11874 #else
11875 $ac_func();
11876 #endif
11877
11878 ; return 0; }
11879 EOF
11880 if { (eval echo configure:11881: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11881   rm -rf conftest*
11882   eval "ac_cv_func_$ac_func=yes"
11883 else
11884   echo "configure: failed program was:" >&5
11885   cat conftest.$ac_ext >&5
11886   rm -rf conftest*
11887   eval "ac_cv_func_$ac_func=no"
11888 fi
11889 rm -f conftest*
11890 fi
11891
11892 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11893   echo "$ac_t""yes" 1>&6
11894     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11895   cat >> confdefs.h <<EOF
11896 #define $ac_tr_func 1
11897 EOF
11898
11899 else
11900   echo "$ac_t""no" 1>&6
11901 fi
11902 done
11903
11904   fi
11905
11906
11907
11908   ac_ext=C
11909 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11910 ac_cpp='$CXXCPP $CPPFLAGS'
11911 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11912 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11913 cross_compiling=$ac_cv_prog_cxx_cross
11914
11915   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
11916 echo "configure:11917: checking for _logf declaration" >&5
11917   cat > conftest.$ac_ext <<EOF
11918 #line 11919 "configure"
11919 #include "confdefs.h"
11920 #include <math.h>
11921 int main() {
11922  _logf(0);
11923 ; return 0; }
11924 EOF
11925 if { (eval echo configure:11926: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11926   rm -rf conftest*
11927   use__logf=yes
11928 else
11929   echo "configure: failed program was:" >&5
11930   cat conftest.$ac_ext >&5
11931   rm -rf conftest*
11932   use__logf=no
11933 fi
11934 rm -f conftest*
11935   echo "$ac_t""$use__logf" 1>&6
11936   ac_ext=c
11937 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11938 ac_cpp='$CPP $CPPFLAGS'
11939 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11940 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11941 cross_compiling=$ac_cv_prog_cc_cross
11942
11943   if test x$use__logf = x"yes"; then
11944     for ac_func in _logf
11945 do
11946 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11947 echo "configure:11948: checking for $ac_func" >&5
11948 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11949   echo $ac_n "(cached) $ac_c" 1>&6
11950 else
11951   cat > conftest.$ac_ext <<EOF
11952 #line 11953 "configure"
11953 #include "confdefs.h"
11954 /* System header to define __stub macros and hopefully few prototypes,
11955     which can conflict with char $ac_func(); below.  */
11956 #include <assert.h>
11957 /* Override any gcc2 internal prototype to avoid an error.  */
11958 /* We use char because int might match the return type of a gcc2
11959     builtin and then its argument prototype would still apply.  */
11960 char $ac_func();
11961
11962 int main() {
11963
11964 /* The GNU C library defines this for functions which it implements
11965     to always fail with ENOSYS.  Some functions are actually named
11966     something starting with __ and the normal name is an alias.  */
11967 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11968 choke me
11969 #else
11970 $ac_func();
11971 #endif
11972
11973 ; return 0; }
11974 EOF
11975 if { (eval echo configure:11976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11976   rm -rf conftest*
11977   eval "ac_cv_func_$ac_func=yes"
11978 else
11979   echo "configure: failed program was:" >&5
11980   cat conftest.$ac_ext >&5
11981   rm -rf conftest*
11982   eval "ac_cv_func_$ac_func=no"
11983 fi
11984 rm -f conftest*
11985 fi
11986
11987 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11988   echo "$ac_t""yes" 1>&6
11989     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11990   cat >> confdefs.h <<EOF
11991 #define $ac_tr_func 1
11992 EOF
11993
11994 else
11995   echo "$ac_t""no" 1>&6
11996 fi
11997 done
11998
11999   fi
12000
12001
12002
12003   ac_ext=C
12004 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12005 ac_cpp='$CXXCPP $CPPFLAGS'
12006 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12007 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12008 cross_compiling=$ac_cv_prog_cxx_cross
12009
12010   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
12011 echo "configure:12012: checking for _log10f declaration" >&5
12012   cat > conftest.$ac_ext <<EOF
12013 #line 12014 "configure"
12014 #include "confdefs.h"
12015 #include <math.h>
12016 int main() {
12017  _log10f(0);
12018 ; return 0; }
12019 EOF
12020 if { (eval echo configure:12021: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12021   rm -rf conftest*
12022   use__log10f=yes
12023 else
12024   echo "configure: failed program was:" >&5
12025   cat conftest.$ac_ext >&5
12026   rm -rf conftest*
12027   use__log10f=no
12028 fi
12029 rm -f conftest*
12030   echo "$ac_t""$use__log10f" 1>&6
12031   ac_ext=c
12032 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12033 ac_cpp='$CPP $CPPFLAGS'
12034 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12035 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12036 cross_compiling=$ac_cv_prog_cc_cross
12037
12038   if test x$use__log10f = x"yes"; then
12039     for ac_func in _log10f
12040 do
12041 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12042 echo "configure:12043: checking for $ac_func" >&5
12043 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12044   echo $ac_n "(cached) $ac_c" 1>&6
12045 else
12046   cat > conftest.$ac_ext <<EOF
12047 #line 12048 "configure"
12048 #include "confdefs.h"
12049 /* System header to define __stub macros and hopefully few prototypes,
12050     which can conflict with char $ac_func(); below.  */
12051 #include <assert.h>
12052 /* Override any gcc2 internal prototype to avoid an error.  */
12053 /* We use char because int might match the return type of a gcc2
12054     builtin and then its argument prototype would still apply.  */
12055 char $ac_func();
12056
12057 int main() {
12058
12059 /* The GNU C library defines this for functions which it implements
12060     to always fail with ENOSYS.  Some functions are actually named
12061     something starting with __ and the normal name is an alias.  */
12062 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12063 choke me
12064 #else
12065 $ac_func();
12066 #endif
12067
12068 ; return 0; }
12069 EOF
12070 if { (eval echo configure:12071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12071   rm -rf conftest*
12072   eval "ac_cv_func_$ac_func=yes"
12073 else
12074   echo "configure: failed program was:" >&5
12075   cat conftest.$ac_ext >&5
12076   rm -rf conftest*
12077   eval "ac_cv_func_$ac_func=no"
12078 fi
12079 rm -f conftest*
12080 fi
12081
12082 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12083   echo "$ac_t""yes" 1>&6
12084     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12085   cat >> confdefs.h <<EOF
12086 #define $ac_tr_func 1
12087 EOF
12088
12089 else
12090   echo "$ac_t""no" 1>&6
12091 fi
12092 done
12093
12094   fi
12095
12096
12097
12098   ac_ext=C
12099 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12100 ac_cpp='$CXXCPP $CPPFLAGS'
12101 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12102 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12103 cross_compiling=$ac_cv_prog_cxx_cross
12104
12105   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
12106 echo "configure:12107: checking for _modff declaration" >&5
12107   cat > conftest.$ac_ext <<EOF
12108 #line 12109 "configure"
12109 #include "confdefs.h"
12110 #include <math.h>
12111 int main() {
12112  _modff(0, 0);
12113 ; return 0; }
12114 EOF
12115 if { (eval echo configure:12116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12116   rm -rf conftest*
12117   use__modff=yes
12118 else
12119   echo "configure: failed program was:" >&5
12120   cat conftest.$ac_ext >&5
12121   rm -rf conftest*
12122   use__modff=no
12123 fi
12124 rm -f conftest*
12125   echo "$ac_t""$use__modff" 1>&6
12126   ac_ext=c
12127 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12128 ac_cpp='$CPP $CPPFLAGS'
12129 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12130 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12131 cross_compiling=$ac_cv_prog_cc_cross
12132
12133   if test x$use__modff = x"yes"; then
12134     for ac_func in _modff
12135 do
12136 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12137 echo "configure:12138: checking for $ac_func" >&5
12138 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12139   echo $ac_n "(cached) $ac_c" 1>&6
12140 else
12141   cat > conftest.$ac_ext <<EOF
12142 #line 12143 "configure"
12143 #include "confdefs.h"
12144 /* System header to define __stub macros and hopefully few prototypes,
12145     which can conflict with char $ac_func(); below.  */
12146 #include <assert.h>
12147 /* Override any gcc2 internal prototype to avoid an error.  */
12148 /* We use char because int might match the return type of a gcc2
12149     builtin and then its argument prototype would still apply.  */
12150 char $ac_func();
12151
12152 int main() {
12153
12154 /* The GNU C library defines this for functions which it implements
12155     to always fail with ENOSYS.  Some functions are actually named
12156     something starting with __ and the normal name is an alias.  */
12157 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12158 choke me
12159 #else
12160 $ac_func();
12161 #endif
12162
12163 ; return 0; }
12164 EOF
12165 if { (eval echo configure:12166: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12166   rm -rf conftest*
12167   eval "ac_cv_func_$ac_func=yes"
12168 else
12169   echo "configure: failed program was:" >&5
12170   cat conftest.$ac_ext >&5
12171   rm -rf conftest*
12172   eval "ac_cv_func_$ac_func=no"
12173 fi
12174 rm -f conftest*
12175 fi
12176
12177 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12178   echo "$ac_t""yes" 1>&6
12179     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12180   cat >> confdefs.h <<EOF
12181 #define $ac_tr_func 1
12182 EOF
12183
12184 else
12185   echo "$ac_t""no" 1>&6
12186 fi
12187 done
12188
12189   fi
12190
12191
12192
12193   ac_ext=C
12194 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12195 ac_cpp='$CXXCPP $CPPFLAGS'
12196 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12197 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12198 cross_compiling=$ac_cv_prog_cxx_cross
12199
12200   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
12201 echo "configure:12202: checking for _powf declaration" >&5
12202   cat > conftest.$ac_ext <<EOF
12203 #line 12204 "configure"
12204 #include "confdefs.h"
12205 #include <math.h>
12206 int main() {
12207  _powf(0, 0);
12208 ; return 0; }
12209 EOF
12210 if { (eval echo configure:12211: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12211   rm -rf conftest*
12212   use__powf=yes
12213 else
12214   echo "configure: failed program was:" >&5
12215   cat conftest.$ac_ext >&5
12216   rm -rf conftest*
12217   use__powf=no
12218 fi
12219 rm -f conftest*
12220   echo "$ac_t""$use__powf" 1>&6
12221   ac_ext=c
12222 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12223 ac_cpp='$CPP $CPPFLAGS'
12224 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12225 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12226 cross_compiling=$ac_cv_prog_cc_cross
12227
12228   if test x$use__powf = x"yes"; then
12229     for ac_func in _powf
12230 do
12231 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12232 echo "configure:12233: checking for $ac_func" >&5
12233 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12234   echo $ac_n "(cached) $ac_c" 1>&6
12235 else
12236   cat > conftest.$ac_ext <<EOF
12237 #line 12238 "configure"
12238 #include "confdefs.h"
12239 /* System header to define __stub macros and hopefully few prototypes,
12240     which can conflict with char $ac_func(); below.  */
12241 #include <assert.h>
12242 /* Override any gcc2 internal prototype to avoid an error.  */
12243 /* We use char because int might match the return type of a gcc2
12244     builtin and then its argument prototype would still apply.  */
12245 char $ac_func();
12246
12247 int main() {
12248
12249 /* The GNU C library defines this for functions which it implements
12250     to always fail with ENOSYS.  Some functions are actually named
12251     something starting with __ and the normal name is an alias.  */
12252 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12253 choke me
12254 #else
12255 $ac_func();
12256 #endif
12257
12258 ; return 0; }
12259 EOF
12260 if { (eval echo configure:12261: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12261   rm -rf conftest*
12262   eval "ac_cv_func_$ac_func=yes"
12263 else
12264   echo "configure: failed program was:" >&5
12265   cat conftest.$ac_ext >&5
12266   rm -rf conftest*
12267   eval "ac_cv_func_$ac_func=no"
12268 fi
12269 rm -f conftest*
12270 fi
12271
12272 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12273   echo "$ac_t""yes" 1>&6
12274     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12275   cat >> confdefs.h <<EOF
12276 #define $ac_tr_func 1
12277 EOF
12278
12279 else
12280   echo "$ac_t""no" 1>&6
12281 fi
12282 done
12283
12284   fi
12285
12286
12287
12288   ac_ext=C
12289 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12290 ac_cpp='$CXXCPP $CPPFLAGS'
12291 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12292 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12293 cross_compiling=$ac_cv_prog_cxx_cross
12294
12295   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
12296 echo "configure:12297: checking for _sinf declaration" >&5
12297   cat > conftest.$ac_ext <<EOF
12298 #line 12299 "configure"
12299 #include "confdefs.h"
12300 #include <math.h>
12301 int main() {
12302  _sinf(0);
12303 ; return 0; }
12304 EOF
12305 if { (eval echo configure:12306: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12306   rm -rf conftest*
12307   use__sinf=yes
12308 else
12309   echo "configure: failed program was:" >&5
12310   cat conftest.$ac_ext >&5
12311   rm -rf conftest*
12312   use__sinf=no
12313 fi
12314 rm -f conftest*
12315   echo "$ac_t""$use__sinf" 1>&6
12316   ac_ext=c
12317 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12318 ac_cpp='$CPP $CPPFLAGS'
12319 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12320 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12321 cross_compiling=$ac_cv_prog_cc_cross
12322
12323   if test x$use__sinf = x"yes"; then
12324     for ac_func in _sinf
12325 do
12326 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12327 echo "configure:12328: checking for $ac_func" >&5
12328 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12329   echo $ac_n "(cached) $ac_c" 1>&6
12330 else
12331   cat > conftest.$ac_ext <<EOF
12332 #line 12333 "configure"
12333 #include "confdefs.h"
12334 /* System header to define __stub macros and hopefully few prototypes,
12335     which can conflict with char $ac_func(); below.  */
12336 #include <assert.h>
12337 /* Override any gcc2 internal prototype to avoid an error.  */
12338 /* We use char because int might match the return type of a gcc2
12339     builtin and then its argument prototype would still apply.  */
12340 char $ac_func();
12341
12342 int main() {
12343
12344 /* The GNU C library defines this for functions which it implements
12345     to always fail with ENOSYS.  Some functions are actually named
12346     something starting with __ and the normal name is an alias.  */
12347 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12348 choke me
12349 #else
12350 $ac_func();
12351 #endif
12352
12353 ; return 0; }
12354 EOF
12355 if { (eval echo configure:12356: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12356   rm -rf conftest*
12357   eval "ac_cv_func_$ac_func=yes"
12358 else
12359   echo "configure: failed program was:" >&5
12360   cat conftest.$ac_ext >&5
12361   rm -rf conftest*
12362   eval "ac_cv_func_$ac_func=no"
12363 fi
12364 rm -f conftest*
12365 fi
12366
12367 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12368   echo "$ac_t""yes" 1>&6
12369     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12370   cat >> confdefs.h <<EOF
12371 #define $ac_tr_func 1
12372 EOF
12373
12374 else
12375   echo "$ac_t""no" 1>&6
12376 fi
12377 done
12378
12379   fi
12380
12381
12382
12383   ac_ext=C
12384 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12385 ac_cpp='$CXXCPP $CPPFLAGS'
12386 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12387 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12388 cross_compiling=$ac_cv_prog_cxx_cross
12389
12390   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
12391 echo "configure:12392: checking for _sinhf declaration" >&5
12392   cat > conftest.$ac_ext <<EOF
12393 #line 12394 "configure"
12394 #include "confdefs.h"
12395 #include <math.h>
12396 int main() {
12397  _sinhf(0);
12398 ; return 0; }
12399 EOF
12400 if { (eval echo configure:12401: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12401   rm -rf conftest*
12402   use__sinhf=yes
12403 else
12404   echo "configure: failed program was:" >&5
12405   cat conftest.$ac_ext >&5
12406   rm -rf conftest*
12407   use__sinhf=no
12408 fi
12409 rm -f conftest*
12410   echo "$ac_t""$use__sinhf" 1>&6
12411   ac_ext=c
12412 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12413 ac_cpp='$CPP $CPPFLAGS'
12414 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12415 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12416 cross_compiling=$ac_cv_prog_cc_cross
12417
12418   if test x$use__sinhf = x"yes"; then
12419     for ac_func in _sinhf
12420 do
12421 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12422 echo "configure:12423: checking for $ac_func" >&5
12423 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12424   echo $ac_n "(cached) $ac_c" 1>&6
12425 else
12426   cat > conftest.$ac_ext <<EOF
12427 #line 12428 "configure"
12428 #include "confdefs.h"
12429 /* System header to define __stub macros and hopefully few prototypes,
12430     which can conflict with char $ac_func(); below.  */
12431 #include <assert.h>
12432 /* Override any gcc2 internal prototype to avoid an error.  */
12433 /* We use char because int might match the return type of a gcc2
12434     builtin and then its argument prototype would still apply.  */
12435 char $ac_func();
12436
12437 int main() {
12438
12439 /* The GNU C library defines this for functions which it implements
12440     to always fail with ENOSYS.  Some functions are actually named
12441     something starting with __ and the normal name is an alias.  */
12442 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12443 choke me
12444 #else
12445 $ac_func();
12446 #endif
12447
12448 ; return 0; }
12449 EOF
12450 if { (eval echo configure:12451: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12451   rm -rf conftest*
12452   eval "ac_cv_func_$ac_func=yes"
12453 else
12454   echo "configure: failed program was:" >&5
12455   cat conftest.$ac_ext >&5
12456   rm -rf conftest*
12457   eval "ac_cv_func_$ac_func=no"
12458 fi
12459 rm -f conftest*
12460 fi
12461
12462 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12463   echo "$ac_t""yes" 1>&6
12464     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12465   cat >> confdefs.h <<EOF
12466 #define $ac_tr_func 1
12467 EOF
12468
12469 else
12470   echo "$ac_t""no" 1>&6
12471 fi
12472 done
12473
12474   fi
12475
12476
12477
12478   ac_ext=C
12479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12480 ac_cpp='$CXXCPP $CPPFLAGS'
12481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12483 cross_compiling=$ac_cv_prog_cxx_cross
12484
12485   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
12486 echo "configure:12487: checking for _sqrtf declaration" >&5
12487   cat > conftest.$ac_ext <<EOF
12488 #line 12489 "configure"
12489 #include "confdefs.h"
12490 #include <math.h>
12491 int main() {
12492  _sqrtf(0);
12493 ; return 0; }
12494 EOF
12495 if { (eval echo configure:12496: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12496   rm -rf conftest*
12497   use__sqrtf=yes
12498 else
12499   echo "configure: failed program was:" >&5
12500   cat conftest.$ac_ext >&5
12501   rm -rf conftest*
12502   use__sqrtf=no
12503 fi
12504 rm -f conftest*
12505   echo "$ac_t""$use__sqrtf" 1>&6
12506   ac_ext=c
12507 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12508 ac_cpp='$CPP $CPPFLAGS'
12509 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12510 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12511 cross_compiling=$ac_cv_prog_cc_cross
12512
12513   if test x$use__sqrtf = x"yes"; then
12514     for ac_func in _sqrtf
12515 do
12516 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12517 echo "configure:12518: checking for $ac_func" >&5
12518 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12519   echo $ac_n "(cached) $ac_c" 1>&6
12520 else
12521   cat > conftest.$ac_ext <<EOF
12522 #line 12523 "configure"
12523 #include "confdefs.h"
12524 /* System header to define __stub macros and hopefully few prototypes,
12525     which can conflict with char $ac_func(); below.  */
12526 #include <assert.h>
12527 /* Override any gcc2 internal prototype to avoid an error.  */
12528 /* We use char because int might match the return type of a gcc2
12529     builtin and then its argument prototype would still apply.  */
12530 char $ac_func();
12531
12532 int main() {
12533
12534 /* The GNU C library defines this for functions which it implements
12535     to always fail with ENOSYS.  Some functions are actually named
12536     something starting with __ and the normal name is an alias.  */
12537 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12538 choke me
12539 #else
12540 $ac_func();
12541 #endif
12542
12543 ; return 0; }
12544 EOF
12545 if { (eval echo configure:12546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12546   rm -rf conftest*
12547   eval "ac_cv_func_$ac_func=yes"
12548 else
12549   echo "configure: failed program was:" >&5
12550   cat conftest.$ac_ext >&5
12551   rm -rf conftest*
12552   eval "ac_cv_func_$ac_func=no"
12553 fi
12554 rm -f conftest*
12555 fi
12556
12557 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12558   echo "$ac_t""yes" 1>&6
12559     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12560   cat >> confdefs.h <<EOF
12561 #define $ac_tr_func 1
12562 EOF
12563
12564 else
12565   echo "$ac_t""no" 1>&6
12566 fi
12567 done
12568
12569   fi
12570
12571
12572
12573   ac_ext=C
12574 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12575 ac_cpp='$CXXCPP $CPPFLAGS'
12576 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12577 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12578 cross_compiling=$ac_cv_prog_cxx_cross
12579
12580   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
12581 echo "configure:12582: checking for _tanf declaration" >&5
12582   cat > conftest.$ac_ext <<EOF
12583 #line 12584 "configure"
12584 #include "confdefs.h"
12585 #include <math.h>
12586 int main() {
12587  _tanf(0);
12588 ; return 0; }
12589 EOF
12590 if { (eval echo configure:12591: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12591   rm -rf conftest*
12592   use__tanf=yes
12593 else
12594   echo "configure: failed program was:" >&5
12595   cat conftest.$ac_ext >&5
12596   rm -rf conftest*
12597   use__tanf=no
12598 fi
12599 rm -f conftest*
12600   echo "$ac_t""$use__tanf" 1>&6
12601   ac_ext=c
12602 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12603 ac_cpp='$CPP $CPPFLAGS'
12604 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12605 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12606 cross_compiling=$ac_cv_prog_cc_cross
12607
12608   if test x$use__tanf = x"yes"; then
12609     for ac_func in _tanf
12610 do
12611 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12612 echo "configure:12613: checking for $ac_func" >&5
12613 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12614   echo $ac_n "(cached) $ac_c" 1>&6
12615 else
12616   cat > conftest.$ac_ext <<EOF
12617 #line 12618 "configure"
12618 #include "confdefs.h"
12619 /* System header to define __stub macros and hopefully few prototypes,
12620     which can conflict with char $ac_func(); below.  */
12621 #include <assert.h>
12622 /* Override any gcc2 internal prototype to avoid an error.  */
12623 /* We use char because int might match the return type of a gcc2
12624     builtin and then its argument prototype would still apply.  */
12625 char $ac_func();
12626
12627 int main() {
12628
12629 /* The GNU C library defines this for functions which it implements
12630     to always fail with ENOSYS.  Some functions are actually named
12631     something starting with __ and the normal name is an alias.  */
12632 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12633 choke me
12634 #else
12635 $ac_func();
12636 #endif
12637
12638 ; return 0; }
12639 EOF
12640 if { (eval echo configure:12641: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12641   rm -rf conftest*
12642   eval "ac_cv_func_$ac_func=yes"
12643 else
12644   echo "configure: failed program was:" >&5
12645   cat conftest.$ac_ext >&5
12646   rm -rf conftest*
12647   eval "ac_cv_func_$ac_func=no"
12648 fi
12649 rm -f conftest*
12650 fi
12651
12652 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12653   echo "$ac_t""yes" 1>&6
12654     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12655   cat >> confdefs.h <<EOF
12656 #define $ac_tr_func 1
12657 EOF
12658
12659 else
12660   echo "$ac_t""no" 1>&6
12661 fi
12662 done
12663
12664   fi
12665
12666
12667
12668   ac_ext=C
12669 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12670 ac_cpp='$CXXCPP $CPPFLAGS'
12671 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12672 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12673 cross_compiling=$ac_cv_prog_cxx_cross
12674
12675   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
12676 echo "configure:12677: checking for _tanhf declaration" >&5
12677   cat > conftest.$ac_ext <<EOF
12678 #line 12679 "configure"
12679 #include "confdefs.h"
12680 #include <math.h>
12681 int main() {
12682  _tanhf(0);
12683 ; return 0; }
12684 EOF
12685 if { (eval echo configure:12686: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12686   rm -rf conftest*
12687   use__tanhf=yes
12688 else
12689   echo "configure: failed program was:" >&5
12690   cat conftest.$ac_ext >&5
12691   rm -rf conftest*
12692   use__tanhf=no
12693 fi
12694 rm -f conftest*
12695   echo "$ac_t""$use__tanhf" 1>&6
12696   ac_ext=c
12697 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12698 ac_cpp='$CPP $CPPFLAGS'
12699 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12700 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12701 cross_compiling=$ac_cv_prog_cc_cross
12702
12703   if test x$use__tanhf = x"yes"; then
12704     for ac_func in _tanhf
12705 do
12706 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12707 echo "configure:12708: checking for $ac_func" >&5
12708 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12709   echo $ac_n "(cached) $ac_c" 1>&6
12710 else
12711   cat > conftest.$ac_ext <<EOF
12712 #line 12713 "configure"
12713 #include "confdefs.h"
12714 /* System header to define __stub macros and hopefully few prototypes,
12715     which can conflict with char $ac_func(); below.  */
12716 #include <assert.h>
12717 /* Override any gcc2 internal prototype to avoid an error.  */
12718 /* We use char because int might match the return type of a gcc2
12719     builtin and then its argument prototype would still apply.  */
12720 char $ac_func();
12721
12722 int main() {
12723
12724 /* The GNU C library defines this for functions which it implements
12725     to always fail with ENOSYS.  Some functions are actually named
12726     something starting with __ and the normal name is an alias.  */
12727 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12728 choke me
12729 #else
12730 $ac_func();
12731 #endif
12732
12733 ; return 0; }
12734 EOF
12735 if { (eval echo configure:12736: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12736   rm -rf conftest*
12737   eval "ac_cv_func_$ac_func=yes"
12738 else
12739   echo "configure: failed program was:" >&5
12740   cat conftest.$ac_ext >&5
12741   rm -rf conftest*
12742   eval "ac_cv_func_$ac_func=no"
12743 fi
12744 rm -f conftest*
12745 fi
12746
12747 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12748   echo "$ac_t""yes" 1>&6
12749     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12750   cat >> confdefs.h <<EOF
12751 #define $ac_tr_func 1
12752 EOF
12753
12754 else
12755   echo "$ac_t""no" 1>&6
12756 fi
12757 done
12758
12759   fi
12760
12761
12762
12763   ac_ext=C
12764 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12765 ac_cpp='$CXXCPP $CPPFLAGS'
12766 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12767 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12768 cross_compiling=$ac_cv_prog_cxx_cross
12769
12770   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
12771 echo "configure:12772: checking for _sincosf declaration" >&5
12772   cat > conftest.$ac_ext <<EOF
12773 #line 12774 "configure"
12774 #include "confdefs.h"
12775 #include <math.h>
12776 int main() {
12777  _sincosf(0, 0, 0);
12778 ; return 0; }
12779 EOF
12780 if { (eval echo configure:12781: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12781   rm -rf conftest*
12782   use__sincosf=yes
12783 else
12784   echo "configure: failed program was:" >&5
12785   cat conftest.$ac_ext >&5
12786   rm -rf conftest*
12787   use__sincosf=no
12788 fi
12789 rm -f conftest*
12790   echo "$ac_t""$use__sincosf" 1>&6
12791   ac_ext=c
12792 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12793 ac_cpp='$CPP $CPPFLAGS'
12794 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12795 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12796 cross_compiling=$ac_cv_prog_cc_cross
12797
12798   if test x$use__sincosf = x"yes"; then
12799     for ac_func in _sincosf
12800 do
12801 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12802 echo "configure:12803: checking for $ac_func" >&5
12803 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12804   echo $ac_n "(cached) $ac_c" 1>&6
12805 else
12806   cat > conftest.$ac_ext <<EOF
12807 #line 12808 "configure"
12808 #include "confdefs.h"
12809 /* System header to define __stub macros and hopefully few prototypes,
12810     which can conflict with char $ac_func(); below.  */
12811 #include <assert.h>
12812 /* Override any gcc2 internal prototype to avoid an error.  */
12813 /* We use char because int might match the return type of a gcc2
12814     builtin and then its argument prototype would still apply.  */
12815 char $ac_func();
12816
12817 int main() {
12818
12819 /* The GNU C library defines this for functions which it implements
12820     to always fail with ENOSYS.  Some functions are actually named
12821     something starting with __ and the normal name is an alias.  */
12822 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12823 choke me
12824 #else
12825 $ac_func();
12826 #endif
12827
12828 ; return 0; }
12829 EOF
12830 if { (eval echo configure:12831: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12831   rm -rf conftest*
12832   eval "ac_cv_func_$ac_func=yes"
12833 else
12834   echo "configure: failed program was:" >&5
12835   cat conftest.$ac_ext >&5
12836   rm -rf conftest*
12837   eval "ac_cv_func_$ac_func=no"
12838 fi
12839 rm -f conftest*
12840 fi
12841
12842 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12843   echo "$ac_t""yes" 1>&6
12844     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12845   cat >> confdefs.h <<EOF
12846 #define $ac_tr_func 1
12847 EOF
12848
12849 else
12850   echo "$ac_t""no" 1>&6
12851 fi
12852 done
12853
12854   fi
12855
12856
12857
12858   ac_ext=C
12859 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12860 ac_cpp='$CXXCPP $CPPFLAGS'
12861 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12862 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12863 cross_compiling=$ac_cv_prog_cxx_cross
12864
12865   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
12866 echo "configure:12867: checking for _finitef declaration" >&5
12867   cat > conftest.$ac_ext <<EOF
12868 #line 12869 "configure"
12869 #include "confdefs.h"
12870 #include <math.h>
12871 int main() {
12872  _finitef(0);
12873 ; return 0; }
12874 EOF
12875 if { (eval echo configure:12876: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12876   rm -rf conftest*
12877   use__finitef=yes
12878 else
12879   echo "configure: failed program was:" >&5
12880   cat conftest.$ac_ext >&5
12881   rm -rf conftest*
12882   use__finitef=no
12883 fi
12884 rm -f conftest*
12885   echo "$ac_t""$use__finitef" 1>&6
12886   ac_ext=c
12887 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12888 ac_cpp='$CPP $CPPFLAGS'
12889 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12890 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12891 cross_compiling=$ac_cv_prog_cc_cross
12892
12893   if test x$use__finitef = x"yes"; then
12894     for ac_func in _finitef
12895 do
12896 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12897 echo "configure:12898: checking for $ac_func" >&5
12898 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12899   echo $ac_n "(cached) $ac_c" 1>&6
12900 else
12901   cat > conftest.$ac_ext <<EOF
12902 #line 12903 "configure"
12903 #include "confdefs.h"
12904 /* System header to define __stub macros and hopefully few prototypes,
12905     which can conflict with char $ac_func(); below.  */
12906 #include <assert.h>
12907 /* Override any gcc2 internal prototype to avoid an error.  */
12908 /* We use char because int might match the return type of a gcc2
12909     builtin and then its argument prototype would still apply.  */
12910 char $ac_func();
12911
12912 int main() {
12913
12914 /* The GNU C library defines this for functions which it implements
12915     to always fail with ENOSYS.  Some functions are actually named
12916     something starting with __ and the normal name is an alias.  */
12917 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12918 choke me
12919 #else
12920 $ac_func();
12921 #endif
12922
12923 ; return 0; }
12924 EOF
12925 if { (eval echo configure:12926: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12926   rm -rf conftest*
12927   eval "ac_cv_func_$ac_func=yes"
12928 else
12929   echo "configure: failed program was:" >&5
12930   cat conftest.$ac_ext >&5
12931   rm -rf conftest*
12932   eval "ac_cv_func_$ac_func=no"
12933 fi
12934 rm -f conftest*
12935 fi
12936
12937 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12938   echo "$ac_t""yes" 1>&6
12939     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12940   cat >> confdefs.h <<EOF
12941 #define $ac_tr_func 1
12942 EOF
12943
12944 else
12945   echo "$ac_t""no" 1>&6
12946 fi
12947 done
12948
12949   fi
12950
12951
12952
12953
12954   ac_ext=C
12955 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12956 ac_cpp='$CXXCPP $CPPFLAGS'
12957 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12958 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12959 cross_compiling=$ac_cv_prog_cxx_cross
12960
12961   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
12962 echo "configure:12963: checking for _isnanl declaration" >&5
12963   cat > conftest.$ac_ext <<EOF
12964 #line 12965 "configure"
12965 #include "confdefs.h"
12966 #include <math.h>
12967 int main() {
12968  _isnanl(0);
12969 ; return 0; }
12970 EOF
12971 if { (eval echo configure:12972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12972   rm -rf conftest*
12973   use__isnanl=yes
12974 else
12975   echo "configure: failed program was:" >&5
12976   cat conftest.$ac_ext >&5
12977   rm -rf conftest*
12978   use__isnanl=no
12979 fi
12980 rm -f conftest*
12981   echo "$ac_t""$use__isnanl" 1>&6
12982   ac_ext=c
12983 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12984 ac_cpp='$CPP $CPPFLAGS'
12985 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12986 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12987 cross_compiling=$ac_cv_prog_cc_cross
12988
12989   if test x$use__isnanl = x"yes"; then
12990     for ac_func in _isnanl
12991 do
12992 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12993 echo "configure:12994: checking for $ac_func" >&5
12994 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12995   echo $ac_n "(cached) $ac_c" 1>&6
12996 else
12997   cat > conftest.$ac_ext <<EOF
12998 #line 12999 "configure"
12999 #include "confdefs.h"
13000 /* System header to define __stub macros and hopefully few prototypes,
13001     which can conflict with char $ac_func(); below.  */
13002 #include <assert.h>
13003 /* Override any gcc2 internal prototype to avoid an error.  */
13004 /* We use char because int might match the return type of a gcc2
13005     builtin and then its argument prototype would still apply.  */
13006 char $ac_func();
13007
13008 int main() {
13009
13010 /* The GNU C library defines this for functions which it implements
13011     to always fail with ENOSYS.  Some functions are actually named
13012     something starting with __ and the normal name is an alias.  */
13013 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13014 choke me
13015 #else
13016 $ac_func();
13017 #endif
13018
13019 ; return 0; }
13020 EOF
13021 if { (eval echo configure:13022: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13022   rm -rf conftest*
13023   eval "ac_cv_func_$ac_func=yes"
13024 else
13025   echo "configure: failed program was:" >&5
13026   cat conftest.$ac_ext >&5
13027   rm -rf conftest*
13028   eval "ac_cv_func_$ac_func=no"
13029 fi
13030 rm -f conftest*
13031 fi
13032
13033 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13034   echo "$ac_t""yes" 1>&6
13035     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13036   cat >> confdefs.h <<EOF
13037 #define $ac_tr_func 1
13038 EOF
13039
13040 else
13041   echo "$ac_t""no" 1>&6
13042 fi
13043 done
13044
13045   fi
13046
13047
13048
13049   ac_ext=C
13050 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13051 ac_cpp='$CXXCPP $CPPFLAGS'
13052 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13053 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13054 cross_compiling=$ac_cv_prog_cxx_cross
13055
13056   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
13057 echo "configure:13058: checking for _isinfl declaration" >&5
13058   cat > conftest.$ac_ext <<EOF
13059 #line 13060 "configure"
13060 #include "confdefs.h"
13061 #include <math.h>
13062 int main() {
13063  _isinfl(0);
13064 ; return 0; }
13065 EOF
13066 if { (eval echo configure:13067: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13067   rm -rf conftest*
13068   use__isinfl=yes
13069 else
13070   echo "configure: failed program was:" >&5
13071   cat conftest.$ac_ext >&5
13072   rm -rf conftest*
13073   use__isinfl=no
13074 fi
13075 rm -f conftest*
13076   echo "$ac_t""$use__isinfl" 1>&6
13077   ac_ext=c
13078 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13079 ac_cpp='$CPP $CPPFLAGS'
13080 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13081 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13082 cross_compiling=$ac_cv_prog_cc_cross
13083
13084   if test x$use__isinfl = x"yes"; then
13085     for ac_func in _isinfl
13086 do
13087 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13088 echo "configure:13089: checking for $ac_func" >&5
13089 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13090   echo $ac_n "(cached) $ac_c" 1>&6
13091 else
13092   cat > conftest.$ac_ext <<EOF
13093 #line 13094 "configure"
13094 #include "confdefs.h"
13095 /* System header to define __stub macros and hopefully few prototypes,
13096     which can conflict with char $ac_func(); below.  */
13097 #include <assert.h>
13098 /* Override any gcc2 internal prototype to avoid an error.  */
13099 /* We use char because int might match the return type of a gcc2
13100     builtin and then its argument prototype would still apply.  */
13101 char $ac_func();
13102
13103 int main() {
13104
13105 /* The GNU C library defines this for functions which it implements
13106     to always fail with ENOSYS.  Some functions are actually named
13107     something starting with __ and the normal name is an alias.  */
13108 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13109 choke me
13110 #else
13111 $ac_func();
13112 #endif
13113
13114 ; return 0; }
13115 EOF
13116 if { (eval echo configure:13117: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13117   rm -rf conftest*
13118   eval "ac_cv_func_$ac_func=yes"
13119 else
13120   echo "configure: failed program was:" >&5
13121   cat conftest.$ac_ext >&5
13122   rm -rf conftest*
13123   eval "ac_cv_func_$ac_func=no"
13124 fi
13125 rm -f conftest*
13126 fi
13127
13128 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13129   echo "$ac_t""yes" 1>&6
13130     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13131   cat >> confdefs.h <<EOF
13132 #define $ac_tr_func 1
13133 EOF
13134
13135 else
13136   echo "$ac_t""no" 1>&6
13137 fi
13138 done
13139
13140   fi
13141
13142
13143
13144   ac_ext=C
13145 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13146 ac_cpp='$CXXCPP $CPPFLAGS'
13147 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13148 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13149 cross_compiling=$ac_cv_prog_cxx_cross
13150
13151   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
13152 echo "configure:13153: checking for _copysignl declaration" >&5
13153   cat > conftest.$ac_ext <<EOF
13154 #line 13155 "configure"
13155 #include "confdefs.h"
13156 #include <math.h>
13157 int main() {
13158  _copysignl(0, 0);
13159 ; return 0; }
13160 EOF
13161 if { (eval echo configure:13162: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13162   rm -rf conftest*
13163   use__copysignl=yes
13164 else
13165   echo "configure: failed program was:" >&5
13166   cat conftest.$ac_ext >&5
13167   rm -rf conftest*
13168   use__copysignl=no
13169 fi
13170 rm -f conftest*
13171   echo "$ac_t""$use__copysignl" 1>&6
13172   ac_ext=c
13173 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13174 ac_cpp='$CPP $CPPFLAGS'
13175 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13176 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13177 cross_compiling=$ac_cv_prog_cc_cross
13178
13179   if test x$use__copysignl = x"yes"; then
13180     for ac_func in _copysignl
13181 do
13182 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13183 echo "configure:13184: checking for $ac_func" >&5
13184 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13185   echo $ac_n "(cached) $ac_c" 1>&6
13186 else
13187   cat > conftest.$ac_ext <<EOF
13188 #line 13189 "configure"
13189 #include "confdefs.h"
13190 /* System header to define __stub macros and hopefully few prototypes,
13191     which can conflict with char $ac_func(); below.  */
13192 #include <assert.h>
13193 /* Override any gcc2 internal prototype to avoid an error.  */
13194 /* We use char because int might match the return type of a gcc2
13195     builtin and then its argument prototype would still apply.  */
13196 char $ac_func();
13197
13198 int main() {
13199
13200 /* The GNU C library defines this for functions which it implements
13201     to always fail with ENOSYS.  Some functions are actually named
13202     something starting with __ and the normal name is an alias.  */
13203 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13204 choke me
13205 #else
13206 $ac_func();
13207 #endif
13208
13209 ; return 0; }
13210 EOF
13211 if { (eval echo configure:13212: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13212   rm -rf conftest*
13213   eval "ac_cv_func_$ac_func=yes"
13214 else
13215   echo "configure: failed program was:" >&5
13216   cat conftest.$ac_ext >&5
13217   rm -rf conftest*
13218   eval "ac_cv_func_$ac_func=no"
13219 fi
13220 rm -f conftest*
13221 fi
13222
13223 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13224   echo "$ac_t""yes" 1>&6
13225     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13226   cat >> confdefs.h <<EOF
13227 #define $ac_tr_func 1
13228 EOF
13229
13230 else
13231   echo "$ac_t""no" 1>&6
13232 fi
13233 done
13234
13235   fi
13236
13237
13238
13239   ac_ext=C
13240 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13241 ac_cpp='$CXXCPP $CPPFLAGS'
13242 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13243 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13244 cross_compiling=$ac_cv_prog_cxx_cross
13245
13246   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
13247 echo "configure:13248: checking for _acosl declaration" >&5
13248   cat > conftest.$ac_ext <<EOF
13249 #line 13250 "configure"
13250 #include "confdefs.h"
13251 #include <math.h>
13252 int main() {
13253  _acosl(0);
13254 ; return 0; }
13255 EOF
13256 if { (eval echo configure:13257: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13257   rm -rf conftest*
13258   use__acosl=yes
13259 else
13260   echo "configure: failed program was:" >&5
13261   cat conftest.$ac_ext >&5
13262   rm -rf conftest*
13263   use__acosl=no
13264 fi
13265 rm -f conftest*
13266   echo "$ac_t""$use__acosl" 1>&6
13267   ac_ext=c
13268 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13269 ac_cpp='$CPP $CPPFLAGS'
13270 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13271 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13272 cross_compiling=$ac_cv_prog_cc_cross
13273
13274   if test x$use__acosl = x"yes"; then
13275     for ac_func in _acosl
13276 do
13277 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13278 echo "configure:13279: checking for $ac_func" >&5
13279 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13280   echo $ac_n "(cached) $ac_c" 1>&6
13281 else
13282   cat > conftest.$ac_ext <<EOF
13283 #line 13284 "configure"
13284 #include "confdefs.h"
13285 /* System header to define __stub macros and hopefully few prototypes,
13286     which can conflict with char $ac_func(); below.  */
13287 #include <assert.h>
13288 /* Override any gcc2 internal prototype to avoid an error.  */
13289 /* We use char because int might match the return type of a gcc2
13290     builtin and then its argument prototype would still apply.  */
13291 char $ac_func();
13292
13293 int main() {
13294
13295 /* The GNU C library defines this for functions which it implements
13296     to always fail with ENOSYS.  Some functions are actually named
13297     something starting with __ and the normal name is an alias.  */
13298 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13299 choke me
13300 #else
13301 $ac_func();
13302 #endif
13303
13304 ; return 0; }
13305 EOF
13306 if { (eval echo configure:13307: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13307   rm -rf conftest*
13308   eval "ac_cv_func_$ac_func=yes"
13309 else
13310   echo "configure: failed program was:" >&5
13311   cat conftest.$ac_ext >&5
13312   rm -rf conftest*
13313   eval "ac_cv_func_$ac_func=no"
13314 fi
13315 rm -f conftest*
13316 fi
13317
13318 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13319   echo "$ac_t""yes" 1>&6
13320     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13321   cat >> confdefs.h <<EOF
13322 #define $ac_tr_func 1
13323 EOF
13324
13325 else
13326   echo "$ac_t""no" 1>&6
13327 fi
13328 done
13329
13330   fi
13331
13332
13333
13334   ac_ext=C
13335 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13336 ac_cpp='$CXXCPP $CPPFLAGS'
13337 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13338 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13339 cross_compiling=$ac_cv_prog_cxx_cross
13340
13341   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
13342 echo "configure:13343: checking for _asinl declaration" >&5
13343   cat > conftest.$ac_ext <<EOF
13344 #line 13345 "configure"
13345 #include "confdefs.h"
13346 #include <math.h>
13347 int main() {
13348  _asinl(0);
13349 ; return 0; }
13350 EOF
13351 if { (eval echo configure:13352: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13352   rm -rf conftest*
13353   use__asinl=yes
13354 else
13355   echo "configure: failed program was:" >&5
13356   cat conftest.$ac_ext >&5
13357   rm -rf conftest*
13358   use__asinl=no
13359 fi
13360 rm -f conftest*
13361   echo "$ac_t""$use__asinl" 1>&6
13362   ac_ext=c
13363 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13364 ac_cpp='$CPP $CPPFLAGS'
13365 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13366 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13367 cross_compiling=$ac_cv_prog_cc_cross
13368
13369   if test x$use__asinl = x"yes"; then
13370     for ac_func in _asinl
13371 do
13372 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13373 echo "configure:13374: checking for $ac_func" >&5
13374 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13375   echo $ac_n "(cached) $ac_c" 1>&6
13376 else
13377   cat > conftest.$ac_ext <<EOF
13378 #line 13379 "configure"
13379 #include "confdefs.h"
13380 /* System header to define __stub macros and hopefully few prototypes,
13381     which can conflict with char $ac_func(); below.  */
13382 #include <assert.h>
13383 /* Override any gcc2 internal prototype to avoid an error.  */
13384 /* We use char because int might match the return type of a gcc2
13385     builtin and then its argument prototype would still apply.  */
13386 char $ac_func();
13387
13388 int main() {
13389
13390 /* The GNU C library defines this for functions which it implements
13391     to always fail with ENOSYS.  Some functions are actually named
13392     something starting with __ and the normal name is an alias.  */
13393 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13394 choke me
13395 #else
13396 $ac_func();
13397 #endif
13398
13399 ; return 0; }
13400 EOF
13401 if { (eval echo configure:13402: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13402   rm -rf conftest*
13403   eval "ac_cv_func_$ac_func=yes"
13404 else
13405   echo "configure: failed program was:" >&5
13406   cat conftest.$ac_ext >&5
13407   rm -rf conftest*
13408   eval "ac_cv_func_$ac_func=no"
13409 fi
13410 rm -f conftest*
13411 fi
13412
13413 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13414   echo "$ac_t""yes" 1>&6
13415     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13416   cat >> confdefs.h <<EOF
13417 #define $ac_tr_func 1
13418 EOF
13419
13420 else
13421   echo "$ac_t""no" 1>&6
13422 fi
13423 done
13424
13425   fi
13426
13427
13428
13429   ac_ext=C
13430 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13431 ac_cpp='$CXXCPP $CPPFLAGS'
13432 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13433 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13434 cross_compiling=$ac_cv_prog_cxx_cross
13435
13436   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
13437 echo "configure:13438: checking for _atanl declaration" >&5
13438   cat > conftest.$ac_ext <<EOF
13439 #line 13440 "configure"
13440 #include "confdefs.h"
13441 #include <math.h>
13442 int main() {
13443  _atanl(0);
13444 ; return 0; }
13445 EOF
13446 if { (eval echo configure:13447: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13447   rm -rf conftest*
13448   use__atanl=yes
13449 else
13450   echo "configure: failed program was:" >&5
13451   cat conftest.$ac_ext >&5
13452   rm -rf conftest*
13453   use__atanl=no
13454 fi
13455 rm -f conftest*
13456   echo "$ac_t""$use__atanl" 1>&6
13457   ac_ext=c
13458 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13459 ac_cpp='$CPP $CPPFLAGS'
13460 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13461 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13462 cross_compiling=$ac_cv_prog_cc_cross
13463
13464   if test x$use__atanl = x"yes"; then
13465     for ac_func in _atanl
13466 do
13467 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13468 echo "configure:13469: checking for $ac_func" >&5
13469 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13470   echo $ac_n "(cached) $ac_c" 1>&6
13471 else
13472   cat > conftest.$ac_ext <<EOF
13473 #line 13474 "configure"
13474 #include "confdefs.h"
13475 /* System header to define __stub macros and hopefully few prototypes,
13476     which can conflict with char $ac_func(); below.  */
13477 #include <assert.h>
13478 /* Override any gcc2 internal prototype to avoid an error.  */
13479 /* We use char because int might match the return type of a gcc2
13480     builtin and then its argument prototype would still apply.  */
13481 char $ac_func();
13482
13483 int main() {
13484
13485 /* The GNU C library defines this for functions which it implements
13486     to always fail with ENOSYS.  Some functions are actually named
13487     something starting with __ and the normal name is an alias.  */
13488 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13489 choke me
13490 #else
13491 $ac_func();
13492 #endif
13493
13494 ; return 0; }
13495 EOF
13496 if { (eval echo configure:13497: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13497   rm -rf conftest*
13498   eval "ac_cv_func_$ac_func=yes"
13499 else
13500   echo "configure: failed program was:" >&5
13501   cat conftest.$ac_ext >&5
13502   rm -rf conftest*
13503   eval "ac_cv_func_$ac_func=no"
13504 fi
13505 rm -f conftest*
13506 fi
13507
13508 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13509   echo "$ac_t""yes" 1>&6
13510     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13511   cat >> confdefs.h <<EOF
13512 #define $ac_tr_func 1
13513 EOF
13514
13515 else
13516   echo "$ac_t""no" 1>&6
13517 fi
13518 done
13519
13520   fi
13521
13522
13523
13524   ac_ext=C
13525 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13526 ac_cpp='$CXXCPP $CPPFLAGS'
13527 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13528 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13529 cross_compiling=$ac_cv_prog_cxx_cross
13530
13531   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
13532 echo "configure:13533: checking for _atan2l declaration" >&5
13533   cat > conftest.$ac_ext <<EOF
13534 #line 13535 "configure"
13535 #include "confdefs.h"
13536 #include <math.h>
13537 int main() {
13538  _atan2l(0, 0);
13539 ; return 0; }
13540 EOF
13541 if { (eval echo configure:13542: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13542   rm -rf conftest*
13543   use__atan2l=yes
13544 else
13545   echo "configure: failed program was:" >&5
13546   cat conftest.$ac_ext >&5
13547   rm -rf conftest*
13548   use__atan2l=no
13549 fi
13550 rm -f conftest*
13551   echo "$ac_t""$use__atan2l" 1>&6
13552   ac_ext=c
13553 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13554 ac_cpp='$CPP $CPPFLAGS'
13555 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13556 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13557 cross_compiling=$ac_cv_prog_cc_cross
13558
13559   if test x$use__atan2l = x"yes"; then
13560     for ac_func in _atan2l
13561 do
13562 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13563 echo "configure:13564: checking for $ac_func" >&5
13564 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13565   echo $ac_n "(cached) $ac_c" 1>&6
13566 else
13567   cat > conftest.$ac_ext <<EOF
13568 #line 13569 "configure"
13569 #include "confdefs.h"
13570 /* System header to define __stub macros and hopefully few prototypes,
13571     which can conflict with char $ac_func(); below.  */
13572 #include <assert.h>
13573 /* Override any gcc2 internal prototype to avoid an error.  */
13574 /* We use char because int might match the return type of a gcc2
13575     builtin and then its argument prototype would still apply.  */
13576 char $ac_func();
13577
13578 int main() {
13579
13580 /* The GNU C library defines this for functions which it implements
13581     to always fail with ENOSYS.  Some functions are actually named
13582     something starting with __ and the normal name is an alias.  */
13583 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13584 choke me
13585 #else
13586 $ac_func();
13587 #endif
13588
13589 ; return 0; }
13590 EOF
13591 if { (eval echo configure:13592: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13592   rm -rf conftest*
13593   eval "ac_cv_func_$ac_func=yes"
13594 else
13595   echo "configure: failed program was:" >&5
13596   cat conftest.$ac_ext >&5
13597   rm -rf conftest*
13598   eval "ac_cv_func_$ac_func=no"
13599 fi
13600 rm -f conftest*
13601 fi
13602
13603 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13604   echo "$ac_t""yes" 1>&6
13605     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13606   cat >> confdefs.h <<EOF
13607 #define $ac_tr_func 1
13608 EOF
13609
13610 else
13611   echo "$ac_t""no" 1>&6
13612 fi
13613 done
13614
13615   fi
13616
13617
13618
13619   ac_ext=C
13620 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13621 ac_cpp='$CXXCPP $CPPFLAGS'
13622 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13623 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13624 cross_compiling=$ac_cv_prog_cxx_cross
13625
13626   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
13627 echo "configure:13628: checking for _ceill declaration" >&5
13628   cat > conftest.$ac_ext <<EOF
13629 #line 13630 "configure"
13630 #include "confdefs.h"
13631 #include <math.h>
13632 int main() {
13633  _ceill(0);
13634 ; return 0; }
13635 EOF
13636 if { (eval echo configure:13637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13637   rm -rf conftest*
13638   use__ceill=yes
13639 else
13640   echo "configure: failed program was:" >&5
13641   cat conftest.$ac_ext >&5
13642   rm -rf conftest*
13643   use__ceill=no
13644 fi
13645 rm -f conftest*
13646   echo "$ac_t""$use__ceill" 1>&6
13647   ac_ext=c
13648 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13649 ac_cpp='$CPP $CPPFLAGS'
13650 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13651 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13652 cross_compiling=$ac_cv_prog_cc_cross
13653
13654   if test x$use__ceill = x"yes"; then
13655     for ac_func in _ceill
13656 do
13657 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13658 echo "configure:13659: checking for $ac_func" >&5
13659 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13660   echo $ac_n "(cached) $ac_c" 1>&6
13661 else
13662   cat > conftest.$ac_ext <<EOF
13663 #line 13664 "configure"
13664 #include "confdefs.h"
13665 /* System header to define __stub macros and hopefully few prototypes,
13666     which can conflict with char $ac_func(); below.  */
13667 #include <assert.h>
13668 /* Override any gcc2 internal prototype to avoid an error.  */
13669 /* We use char because int might match the return type of a gcc2
13670     builtin and then its argument prototype would still apply.  */
13671 char $ac_func();
13672
13673 int main() {
13674
13675 /* The GNU C library defines this for functions which it implements
13676     to always fail with ENOSYS.  Some functions are actually named
13677     something starting with __ and the normal name is an alias.  */
13678 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13679 choke me
13680 #else
13681 $ac_func();
13682 #endif
13683
13684 ; return 0; }
13685 EOF
13686 if { (eval echo configure:13687: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13687   rm -rf conftest*
13688   eval "ac_cv_func_$ac_func=yes"
13689 else
13690   echo "configure: failed program was:" >&5
13691   cat conftest.$ac_ext >&5
13692   rm -rf conftest*
13693   eval "ac_cv_func_$ac_func=no"
13694 fi
13695 rm -f conftest*
13696 fi
13697
13698 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13699   echo "$ac_t""yes" 1>&6
13700     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13701   cat >> confdefs.h <<EOF
13702 #define $ac_tr_func 1
13703 EOF
13704
13705 else
13706   echo "$ac_t""no" 1>&6
13707 fi
13708 done
13709
13710   fi
13711
13712
13713
13714   ac_ext=C
13715 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13716 ac_cpp='$CXXCPP $CPPFLAGS'
13717 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13718 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13719 cross_compiling=$ac_cv_prog_cxx_cross
13720
13721   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
13722 echo "configure:13723: checking for _cosl declaration" >&5
13723   cat > conftest.$ac_ext <<EOF
13724 #line 13725 "configure"
13725 #include "confdefs.h"
13726 #include <math.h>
13727 int main() {
13728  _cosl(0);
13729 ; return 0; }
13730 EOF
13731 if { (eval echo configure:13732: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13732   rm -rf conftest*
13733   use__cosl=yes
13734 else
13735   echo "configure: failed program was:" >&5
13736   cat conftest.$ac_ext >&5
13737   rm -rf conftest*
13738   use__cosl=no
13739 fi
13740 rm -f conftest*
13741   echo "$ac_t""$use__cosl" 1>&6
13742   ac_ext=c
13743 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13744 ac_cpp='$CPP $CPPFLAGS'
13745 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13746 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13747 cross_compiling=$ac_cv_prog_cc_cross
13748
13749   if test x$use__cosl = x"yes"; then
13750     for ac_func in _cosl
13751 do
13752 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13753 echo "configure:13754: checking for $ac_func" >&5
13754 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13755   echo $ac_n "(cached) $ac_c" 1>&6
13756 else
13757   cat > conftest.$ac_ext <<EOF
13758 #line 13759 "configure"
13759 #include "confdefs.h"
13760 /* System header to define __stub macros and hopefully few prototypes,
13761     which can conflict with char $ac_func(); below.  */
13762 #include <assert.h>
13763 /* Override any gcc2 internal prototype to avoid an error.  */
13764 /* We use char because int might match the return type of a gcc2
13765     builtin and then its argument prototype would still apply.  */
13766 char $ac_func();
13767
13768 int main() {
13769
13770 /* The GNU C library defines this for functions which it implements
13771     to always fail with ENOSYS.  Some functions are actually named
13772     something starting with __ and the normal name is an alias.  */
13773 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13774 choke me
13775 #else
13776 $ac_func();
13777 #endif
13778
13779 ; return 0; }
13780 EOF
13781 if { (eval echo configure:13782: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13782   rm -rf conftest*
13783   eval "ac_cv_func_$ac_func=yes"
13784 else
13785   echo "configure: failed program was:" >&5
13786   cat conftest.$ac_ext >&5
13787   rm -rf conftest*
13788   eval "ac_cv_func_$ac_func=no"
13789 fi
13790 rm -f conftest*
13791 fi
13792
13793 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13794   echo "$ac_t""yes" 1>&6
13795     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13796   cat >> confdefs.h <<EOF
13797 #define $ac_tr_func 1
13798 EOF
13799
13800 else
13801   echo "$ac_t""no" 1>&6
13802 fi
13803 done
13804
13805   fi
13806
13807
13808
13809   ac_ext=C
13810 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13811 ac_cpp='$CXXCPP $CPPFLAGS'
13812 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13813 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13814 cross_compiling=$ac_cv_prog_cxx_cross
13815
13816   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
13817 echo "configure:13818: checking for _coshl declaration" >&5
13818   cat > conftest.$ac_ext <<EOF
13819 #line 13820 "configure"
13820 #include "confdefs.h"
13821 #include <math.h>
13822 int main() {
13823  _coshl(0);
13824 ; return 0; }
13825 EOF
13826 if { (eval echo configure:13827: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13827   rm -rf conftest*
13828   use__coshl=yes
13829 else
13830   echo "configure: failed program was:" >&5
13831   cat conftest.$ac_ext >&5
13832   rm -rf conftest*
13833   use__coshl=no
13834 fi
13835 rm -f conftest*
13836   echo "$ac_t""$use__coshl" 1>&6
13837   ac_ext=c
13838 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13839 ac_cpp='$CPP $CPPFLAGS'
13840 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13841 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13842 cross_compiling=$ac_cv_prog_cc_cross
13843
13844   if test x$use__coshl = x"yes"; then
13845     for ac_func in _coshl
13846 do
13847 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13848 echo "configure:13849: checking for $ac_func" >&5
13849 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13850   echo $ac_n "(cached) $ac_c" 1>&6
13851 else
13852   cat > conftest.$ac_ext <<EOF
13853 #line 13854 "configure"
13854 #include "confdefs.h"
13855 /* System header to define __stub macros and hopefully few prototypes,
13856     which can conflict with char $ac_func(); below.  */
13857 #include <assert.h>
13858 /* Override any gcc2 internal prototype to avoid an error.  */
13859 /* We use char because int might match the return type of a gcc2
13860     builtin and then its argument prototype would still apply.  */
13861 char $ac_func();
13862
13863 int main() {
13864
13865 /* The GNU C library defines this for functions which it implements
13866     to always fail with ENOSYS.  Some functions are actually named
13867     something starting with __ and the normal name is an alias.  */
13868 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13869 choke me
13870 #else
13871 $ac_func();
13872 #endif
13873
13874 ; return 0; }
13875 EOF
13876 if { (eval echo configure:13877: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13877   rm -rf conftest*
13878   eval "ac_cv_func_$ac_func=yes"
13879 else
13880   echo "configure: failed program was:" >&5
13881   cat conftest.$ac_ext >&5
13882   rm -rf conftest*
13883   eval "ac_cv_func_$ac_func=no"
13884 fi
13885 rm -f conftest*
13886 fi
13887
13888 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13889   echo "$ac_t""yes" 1>&6
13890     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13891   cat >> confdefs.h <<EOF
13892 #define $ac_tr_func 1
13893 EOF
13894
13895 else
13896   echo "$ac_t""no" 1>&6
13897 fi
13898 done
13899
13900   fi
13901
13902
13903
13904   ac_ext=C
13905 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13906 ac_cpp='$CXXCPP $CPPFLAGS'
13907 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13908 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13909 cross_compiling=$ac_cv_prog_cxx_cross
13910
13911   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
13912 echo "configure:13913: checking for _expl declaration" >&5
13913   cat > conftest.$ac_ext <<EOF
13914 #line 13915 "configure"
13915 #include "confdefs.h"
13916 #include <math.h>
13917 int main() {
13918  _expl(0);
13919 ; return 0; }
13920 EOF
13921 if { (eval echo configure:13922: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13922   rm -rf conftest*
13923   use__expl=yes
13924 else
13925   echo "configure: failed program was:" >&5
13926   cat conftest.$ac_ext >&5
13927   rm -rf conftest*
13928   use__expl=no
13929 fi
13930 rm -f conftest*
13931   echo "$ac_t""$use__expl" 1>&6
13932   ac_ext=c
13933 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13934 ac_cpp='$CPP $CPPFLAGS'
13935 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13936 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13937 cross_compiling=$ac_cv_prog_cc_cross
13938
13939   if test x$use__expl = x"yes"; then
13940     for ac_func in _expl
13941 do
13942 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13943 echo "configure:13944: checking for $ac_func" >&5
13944 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13945   echo $ac_n "(cached) $ac_c" 1>&6
13946 else
13947   cat > conftest.$ac_ext <<EOF
13948 #line 13949 "configure"
13949 #include "confdefs.h"
13950 /* System header to define __stub macros and hopefully few prototypes,
13951     which can conflict with char $ac_func(); below.  */
13952 #include <assert.h>
13953 /* Override any gcc2 internal prototype to avoid an error.  */
13954 /* We use char because int might match the return type of a gcc2
13955     builtin and then its argument prototype would still apply.  */
13956 char $ac_func();
13957
13958 int main() {
13959
13960 /* The GNU C library defines this for functions which it implements
13961     to always fail with ENOSYS.  Some functions are actually named
13962     something starting with __ and the normal name is an alias.  */
13963 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13964 choke me
13965 #else
13966 $ac_func();
13967 #endif
13968
13969 ; return 0; }
13970 EOF
13971 if { (eval echo configure:13972: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13972   rm -rf conftest*
13973   eval "ac_cv_func_$ac_func=yes"
13974 else
13975   echo "configure: failed program was:" >&5
13976   cat conftest.$ac_ext >&5
13977   rm -rf conftest*
13978   eval "ac_cv_func_$ac_func=no"
13979 fi
13980 rm -f conftest*
13981 fi
13982
13983 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13984   echo "$ac_t""yes" 1>&6
13985     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13986   cat >> confdefs.h <<EOF
13987 #define $ac_tr_func 1
13988 EOF
13989
13990 else
13991   echo "$ac_t""no" 1>&6
13992 fi
13993 done
13994
13995   fi
13996
13997
13998
13999   ac_ext=C
14000 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14001 ac_cpp='$CXXCPP $CPPFLAGS'
14002 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14003 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14004 cross_compiling=$ac_cv_prog_cxx_cross
14005
14006   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
14007 echo "configure:14008: checking for _fabsl declaration" >&5
14008   cat > conftest.$ac_ext <<EOF
14009 #line 14010 "configure"
14010 #include "confdefs.h"
14011 #include <math.h>
14012 int main() {
14013  _fabsl(0);
14014 ; return 0; }
14015 EOF
14016 if { (eval echo configure:14017: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14017   rm -rf conftest*
14018   use__fabsl=yes
14019 else
14020   echo "configure: failed program was:" >&5
14021   cat conftest.$ac_ext >&5
14022   rm -rf conftest*
14023   use__fabsl=no
14024 fi
14025 rm -f conftest*
14026   echo "$ac_t""$use__fabsl" 1>&6
14027   ac_ext=c
14028 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14029 ac_cpp='$CPP $CPPFLAGS'
14030 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14031 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14032 cross_compiling=$ac_cv_prog_cc_cross
14033
14034   if test x$use__fabsl = x"yes"; then
14035     for ac_func in _fabsl
14036 do
14037 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14038 echo "configure:14039: checking for $ac_func" >&5
14039 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14040   echo $ac_n "(cached) $ac_c" 1>&6
14041 else
14042   cat > conftest.$ac_ext <<EOF
14043 #line 14044 "configure"
14044 #include "confdefs.h"
14045 /* System header to define __stub macros and hopefully few prototypes,
14046     which can conflict with char $ac_func(); below.  */
14047 #include <assert.h>
14048 /* Override any gcc2 internal prototype to avoid an error.  */
14049 /* We use char because int might match the return type of a gcc2
14050     builtin and then its argument prototype would still apply.  */
14051 char $ac_func();
14052
14053 int main() {
14054
14055 /* The GNU C library defines this for functions which it implements
14056     to always fail with ENOSYS.  Some functions are actually named
14057     something starting with __ and the normal name is an alias.  */
14058 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14059 choke me
14060 #else
14061 $ac_func();
14062 #endif
14063
14064 ; return 0; }
14065 EOF
14066 if { (eval echo configure:14067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14067   rm -rf conftest*
14068   eval "ac_cv_func_$ac_func=yes"
14069 else
14070   echo "configure: failed program was:" >&5
14071   cat conftest.$ac_ext >&5
14072   rm -rf conftest*
14073   eval "ac_cv_func_$ac_func=no"
14074 fi
14075 rm -f conftest*
14076 fi
14077
14078 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14079   echo "$ac_t""yes" 1>&6
14080     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14081   cat >> confdefs.h <<EOF
14082 #define $ac_tr_func 1
14083 EOF
14084
14085 else
14086   echo "$ac_t""no" 1>&6
14087 fi
14088 done
14089
14090   fi
14091
14092
14093
14094   ac_ext=C
14095 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14096 ac_cpp='$CXXCPP $CPPFLAGS'
14097 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14098 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14099 cross_compiling=$ac_cv_prog_cxx_cross
14100
14101   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
14102 echo "configure:14103: checking for _floorl declaration" >&5
14103   cat > conftest.$ac_ext <<EOF
14104 #line 14105 "configure"
14105 #include "confdefs.h"
14106 #include <math.h>
14107 int main() {
14108  _floorl(0);
14109 ; return 0; }
14110 EOF
14111 if { (eval echo configure:14112: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14112   rm -rf conftest*
14113   use__floorl=yes
14114 else
14115   echo "configure: failed program was:" >&5
14116   cat conftest.$ac_ext >&5
14117   rm -rf conftest*
14118   use__floorl=no
14119 fi
14120 rm -f conftest*
14121   echo "$ac_t""$use__floorl" 1>&6
14122   ac_ext=c
14123 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14124 ac_cpp='$CPP $CPPFLAGS'
14125 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14126 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14127 cross_compiling=$ac_cv_prog_cc_cross
14128
14129   if test x$use__floorl = x"yes"; then
14130     for ac_func in _floorl
14131 do
14132 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14133 echo "configure:14134: checking for $ac_func" >&5
14134 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14135   echo $ac_n "(cached) $ac_c" 1>&6
14136 else
14137   cat > conftest.$ac_ext <<EOF
14138 #line 14139 "configure"
14139 #include "confdefs.h"
14140 /* System header to define __stub macros and hopefully few prototypes,
14141     which can conflict with char $ac_func(); below.  */
14142 #include <assert.h>
14143 /* Override any gcc2 internal prototype to avoid an error.  */
14144 /* We use char because int might match the return type of a gcc2
14145     builtin and then its argument prototype would still apply.  */
14146 char $ac_func();
14147
14148 int main() {
14149
14150 /* The GNU C library defines this for functions which it implements
14151     to always fail with ENOSYS.  Some functions are actually named
14152     something starting with __ and the normal name is an alias.  */
14153 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14154 choke me
14155 #else
14156 $ac_func();
14157 #endif
14158
14159 ; return 0; }
14160 EOF
14161 if { (eval echo configure:14162: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14162   rm -rf conftest*
14163   eval "ac_cv_func_$ac_func=yes"
14164 else
14165   echo "configure: failed program was:" >&5
14166   cat conftest.$ac_ext >&5
14167   rm -rf conftest*
14168   eval "ac_cv_func_$ac_func=no"
14169 fi
14170 rm -f conftest*
14171 fi
14172
14173 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14174   echo "$ac_t""yes" 1>&6
14175     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14176   cat >> confdefs.h <<EOF
14177 #define $ac_tr_func 1
14178 EOF
14179
14180 else
14181   echo "$ac_t""no" 1>&6
14182 fi
14183 done
14184
14185   fi
14186
14187
14188
14189   ac_ext=C
14190 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14191 ac_cpp='$CXXCPP $CPPFLAGS'
14192 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14193 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14194 cross_compiling=$ac_cv_prog_cxx_cross
14195
14196   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
14197 echo "configure:14198: checking for _fmodl declaration" >&5
14198   cat > conftest.$ac_ext <<EOF
14199 #line 14200 "configure"
14200 #include "confdefs.h"
14201 #include <math.h>
14202 int main() {
14203  _fmodl(0, 0);
14204 ; return 0; }
14205 EOF
14206 if { (eval echo configure:14207: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14207   rm -rf conftest*
14208   use__fmodl=yes
14209 else
14210   echo "configure: failed program was:" >&5
14211   cat conftest.$ac_ext >&5
14212   rm -rf conftest*
14213   use__fmodl=no
14214 fi
14215 rm -f conftest*
14216   echo "$ac_t""$use__fmodl" 1>&6
14217   ac_ext=c
14218 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14219 ac_cpp='$CPP $CPPFLAGS'
14220 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14221 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14222 cross_compiling=$ac_cv_prog_cc_cross
14223
14224   if test x$use__fmodl = x"yes"; then
14225     for ac_func in _fmodl
14226 do
14227 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14228 echo "configure:14229: checking for $ac_func" >&5
14229 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14230   echo $ac_n "(cached) $ac_c" 1>&6
14231 else
14232   cat > conftest.$ac_ext <<EOF
14233 #line 14234 "configure"
14234 #include "confdefs.h"
14235 /* System header to define __stub macros and hopefully few prototypes,
14236     which can conflict with char $ac_func(); below.  */
14237 #include <assert.h>
14238 /* Override any gcc2 internal prototype to avoid an error.  */
14239 /* We use char because int might match the return type of a gcc2
14240     builtin and then its argument prototype would still apply.  */
14241 char $ac_func();
14242
14243 int main() {
14244
14245 /* The GNU C library defines this for functions which it implements
14246     to always fail with ENOSYS.  Some functions are actually named
14247     something starting with __ and the normal name is an alias.  */
14248 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14249 choke me
14250 #else
14251 $ac_func();
14252 #endif
14253
14254 ; return 0; }
14255 EOF
14256 if { (eval echo configure:14257: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14257   rm -rf conftest*
14258   eval "ac_cv_func_$ac_func=yes"
14259 else
14260   echo "configure: failed program was:" >&5
14261   cat conftest.$ac_ext >&5
14262   rm -rf conftest*
14263   eval "ac_cv_func_$ac_func=no"
14264 fi
14265 rm -f conftest*
14266 fi
14267
14268 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14269   echo "$ac_t""yes" 1>&6
14270     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14271   cat >> confdefs.h <<EOF
14272 #define $ac_tr_func 1
14273 EOF
14274
14275 else
14276   echo "$ac_t""no" 1>&6
14277 fi
14278 done
14279
14280   fi
14281
14282
14283
14284   ac_ext=C
14285 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14286 ac_cpp='$CXXCPP $CPPFLAGS'
14287 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14288 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14289 cross_compiling=$ac_cv_prog_cxx_cross
14290
14291   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
14292 echo "configure:14293: checking for _frexpl declaration" >&5
14293   cat > conftest.$ac_ext <<EOF
14294 #line 14295 "configure"
14295 #include "confdefs.h"
14296 #include <math.h>
14297 int main() {
14298  _frexpl(0, 0);
14299 ; return 0; }
14300 EOF
14301 if { (eval echo configure:14302: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14302   rm -rf conftest*
14303   use__frexpl=yes
14304 else
14305   echo "configure: failed program was:" >&5
14306   cat conftest.$ac_ext >&5
14307   rm -rf conftest*
14308   use__frexpl=no
14309 fi
14310 rm -f conftest*
14311   echo "$ac_t""$use__frexpl" 1>&6
14312   ac_ext=c
14313 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14314 ac_cpp='$CPP $CPPFLAGS'
14315 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14316 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14317 cross_compiling=$ac_cv_prog_cc_cross
14318
14319   if test x$use__frexpl = x"yes"; then
14320     for ac_func in _frexpl
14321 do
14322 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14323 echo "configure:14324: checking for $ac_func" >&5
14324 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14325   echo $ac_n "(cached) $ac_c" 1>&6
14326 else
14327   cat > conftest.$ac_ext <<EOF
14328 #line 14329 "configure"
14329 #include "confdefs.h"
14330 /* System header to define __stub macros and hopefully few prototypes,
14331     which can conflict with char $ac_func(); below.  */
14332 #include <assert.h>
14333 /* Override any gcc2 internal prototype to avoid an error.  */
14334 /* We use char because int might match the return type of a gcc2
14335     builtin and then its argument prototype would still apply.  */
14336 char $ac_func();
14337
14338 int main() {
14339
14340 /* The GNU C library defines this for functions which it implements
14341     to always fail with ENOSYS.  Some functions are actually named
14342     something starting with __ and the normal name is an alias.  */
14343 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14344 choke me
14345 #else
14346 $ac_func();
14347 #endif
14348
14349 ; return 0; }
14350 EOF
14351 if { (eval echo configure:14352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14352   rm -rf conftest*
14353   eval "ac_cv_func_$ac_func=yes"
14354 else
14355   echo "configure: failed program was:" >&5
14356   cat conftest.$ac_ext >&5
14357   rm -rf conftest*
14358   eval "ac_cv_func_$ac_func=no"
14359 fi
14360 rm -f conftest*
14361 fi
14362
14363 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14364   echo "$ac_t""yes" 1>&6
14365     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14366   cat >> confdefs.h <<EOF
14367 #define $ac_tr_func 1
14368 EOF
14369
14370 else
14371   echo "$ac_t""no" 1>&6
14372 fi
14373 done
14374
14375   fi
14376
14377
14378
14379   ac_ext=C
14380 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14381 ac_cpp='$CXXCPP $CPPFLAGS'
14382 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14383 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14384 cross_compiling=$ac_cv_prog_cxx_cross
14385
14386   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
14387 echo "configure:14388: checking for _ldexpl declaration" >&5
14388   cat > conftest.$ac_ext <<EOF
14389 #line 14390 "configure"
14390 #include "confdefs.h"
14391 #include <math.h>
14392 int main() {
14393  _ldexpl(0, 0);
14394 ; return 0; }
14395 EOF
14396 if { (eval echo configure:14397: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14397   rm -rf conftest*
14398   use__ldexpl=yes
14399 else
14400   echo "configure: failed program was:" >&5
14401   cat conftest.$ac_ext >&5
14402   rm -rf conftest*
14403   use__ldexpl=no
14404 fi
14405 rm -f conftest*
14406   echo "$ac_t""$use__ldexpl" 1>&6
14407   ac_ext=c
14408 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14409 ac_cpp='$CPP $CPPFLAGS'
14410 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14411 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14412 cross_compiling=$ac_cv_prog_cc_cross
14413
14414   if test x$use__ldexpl = x"yes"; then
14415     for ac_func in _ldexpl
14416 do
14417 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14418 echo "configure:14419: checking for $ac_func" >&5
14419 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14420   echo $ac_n "(cached) $ac_c" 1>&6
14421 else
14422   cat > conftest.$ac_ext <<EOF
14423 #line 14424 "configure"
14424 #include "confdefs.h"
14425 /* System header to define __stub macros and hopefully few prototypes,
14426     which can conflict with char $ac_func(); below.  */
14427 #include <assert.h>
14428 /* Override any gcc2 internal prototype to avoid an error.  */
14429 /* We use char because int might match the return type of a gcc2
14430     builtin and then its argument prototype would still apply.  */
14431 char $ac_func();
14432
14433 int main() {
14434
14435 /* The GNU C library defines this for functions which it implements
14436     to always fail with ENOSYS.  Some functions are actually named
14437     something starting with __ and the normal name is an alias.  */
14438 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14439 choke me
14440 #else
14441 $ac_func();
14442 #endif
14443
14444 ; return 0; }
14445 EOF
14446 if { (eval echo configure:14447: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14447   rm -rf conftest*
14448   eval "ac_cv_func_$ac_func=yes"
14449 else
14450   echo "configure: failed program was:" >&5
14451   cat conftest.$ac_ext >&5
14452   rm -rf conftest*
14453   eval "ac_cv_func_$ac_func=no"
14454 fi
14455 rm -f conftest*
14456 fi
14457
14458 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14459   echo "$ac_t""yes" 1>&6
14460     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14461   cat >> confdefs.h <<EOF
14462 #define $ac_tr_func 1
14463 EOF
14464
14465 else
14466   echo "$ac_t""no" 1>&6
14467 fi
14468 done
14469
14470   fi
14471
14472
14473
14474   ac_ext=C
14475 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14476 ac_cpp='$CXXCPP $CPPFLAGS'
14477 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14478 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14479 cross_compiling=$ac_cv_prog_cxx_cross
14480
14481   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
14482 echo "configure:14483: checking for _logl declaration" >&5
14483   cat > conftest.$ac_ext <<EOF
14484 #line 14485 "configure"
14485 #include "confdefs.h"
14486 #include <math.h>
14487 int main() {
14488  _logl(0);
14489 ; return 0; }
14490 EOF
14491 if { (eval echo configure:14492: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14492   rm -rf conftest*
14493   use__logl=yes
14494 else
14495   echo "configure: failed program was:" >&5
14496   cat conftest.$ac_ext >&5
14497   rm -rf conftest*
14498   use__logl=no
14499 fi
14500 rm -f conftest*
14501   echo "$ac_t""$use__logl" 1>&6
14502   ac_ext=c
14503 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14504 ac_cpp='$CPP $CPPFLAGS'
14505 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14506 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14507 cross_compiling=$ac_cv_prog_cc_cross
14508
14509   if test x$use__logl = x"yes"; then
14510     for ac_func in _logl
14511 do
14512 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14513 echo "configure:14514: checking for $ac_func" >&5
14514 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14515   echo $ac_n "(cached) $ac_c" 1>&6
14516 else
14517   cat > conftest.$ac_ext <<EOF
14518 #line 14519 "configure"
14519 #include "confdefs.h"
14520 /* System header to define __stub macros and hopefully few prototypes,
14521     which can conflict with char $ac_func(); below.  */
14522 #include <assert.h>
14523 /* Override any gcc2 internal prototype to avoid an error.  */
14524 /* We use char because int might match the return type of a gcc2
14525     builtin and then its argument prototype would still apply.  */
14526 char $ac_func();
14527
14528 int main() {
14529
14530 /* The GNU C library defines this for functions which it implements
14531     to always fail with ENOSYS.  Some functions are actually named
14532     something starting with __ and the normal name is an alias.  */
14533 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14534 choke me
14535 #else
14536 $ac_func();
14537 #endif
14538
14539 ; return 0; }
14540 EOF
14541 if { (eval echo configure:14542: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14542   rm -rf conftest*
14543   eval "ac_cv_func_$ac_func=yes"
14544 else
14545   echo "configure: failed program was:" >&5
14546   cat conftest.$ac_ext >&5
14547   rm -rf conftest*
14548   eval "ac_cv_func_$ac_func=no"
14549 fi
14550 rm -f conftest*
14551 fi
14552
14553 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14554   echo "$ac_t""yes" 1>&6
14555     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14556   cat >> confdefs.h <<EOF
14557 #define $ac_tr_func 1
14558 EOF
14559
14560 else
14561   echo "$ac_t""no" 1>&6
14562 fi
14563 done
14564
14565   fi
14566
14567
14568
14569   ac_ext=C
14570 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14571 ac_cpp='$CXXCPP $CPPFLAGS'
14572 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14573 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14574 cross_compiling=$ac_cv_prog_cxx_cross
14575
14576   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
14577 echo "configure:14578: checking for _log10l declaration" >&5
14578   cat > conftest.$ac_ext <<EOF
14579 #line 14580 "configure"
14580 #include "confdefs.h"
14581 #include <math.h>
14582 int main() {
14583  _log10l(0);
14584 ; return 0; }
14585 EOF
14586 if { (eval echo configure:14587: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14587   rm -rf conftest*
14588   use__log10l=yes
14589 else
14590   echo "configure: failed program was:" >&5
14591   cat conftest.$ac_ext >&5
14592   rm -rf conftest*
14593   use__log10l=no
14594 fi
14595 rm -f conftest*
14596   echo "$ac_t""$use__log10l" 1>&6
14597   ac_ext=c
14598 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14599 ac_cpp='$CPP $CPPFLAGS'
14600 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14601 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14602 cross_compiling=$ac_cv_prog_cc_cross
14603
14604   if test x$use__log10l = x"yes"; then
14605     for ac_func in _log10l
14606 do
14607 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14608 echo "configure:14609: checking for $ac_func" >&5
14609 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14610   echo $ac_n "(cached) $ac_c" 1>&6
14611 else
14612   cat > conftest.$ac_ext <<EOF
14613 #line 14614 "configure"
14614 #include "confdefs.h"
14615 /* System header to define __stub macros and hopefully few prototypes,
14616     which can conflict with char $ac_func(); below.  */
14617 #include <assert.h>
14618 /* Override any gcc2 internal prototype to avoid an error.  */
14619 /* We use char because int might match the return type of a gcc2
14620     builtin and then its argument prototype would still apply.  */
14621 char $ac_func();
14622
14623 int main() {
14624
14625 /* The GNU C library defines this for functions which it implements
14626     to always fail with ENOSYS.  Some functions are actually named
14627     something starting with __ and the normal name is an alias.  */
14628 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14629 choke me
14630 #else
14631 $ac_func();
14632 #endif
14633
14634 ; return 0; }
14635 EOF
14636 if { (eval echo configure:14637: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14637   rm -rf conftest*
14638   eval "ac_cv_func_$ac_func=yes"
14639 else
14640   echo "configure: failed program was:" >&5
14641   cat conftest.$ac_ext >&5
14642   rm -rf conftest*
14643   eval "ac_cv_func_$ac_func=no"
14644 fi
14645 rm -f conftest*
14646 fi
14647
14648 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14649   echo "$ac_t""yes" 1>&6
14650     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14651   cat >> confdefs.h <<EOF
14652 #define $ac_tr_func 1
14653 EOF
14654
14655 else
14656   echo "$ac_t""no" 1>&6
14657 fi
14658 done
14659
14660   fi
14661
14662
14663
14664   ac_ext=C
14665 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14666 ac_cpp='$CXXCPP $CPPFLAGS'
14667 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14668 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14669 cross_compiling=$ac_cv_prog_cxx_cross
14670
14671   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
14672 echo "configure:14673: checking for _modfl declaration" >&5
14673   cat > conftest.$ac_ext <<EOF
14674 #line 14675 "configure"
14675 #include "confdefs.h"
14676 #include <math.h>
14677 int main() {
14678  _modfl(0, 0);
14679 ; return 0; }
14680 EOF
14681 if { (eval echo configure:14682: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14682   rm -rf conftest*
14683   use__modfl=yes
14684 else
14685   echo "configure: failed program was:" >&5
14686   cat conftest.$ac_ext >&5
14687   rm -rf conftest*
14688   use__modfl=no
14689 fi
14690 rm -f conftest*
14691   echo "$ac_t""$use__modfl" 1>&6
14692   ac_ext=c
14693 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14694 ac_cpp='$CPP $CPPFLAGS'
14695 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14696 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14697 cross_compiling=$ac_cv_prog_cc_cross
14698
14699   if test x$use__modfl = x"yes"; then
14700     for ac_func in _modfl
14701 do
14702 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14703 echo "configure:14704: checking for $ac_func" >&5
14704 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14705   echo $ac_n "(cached) $ac_c" 1>&6
14706 else
14707   cat > conftest.$ac_ext <<EOF
14708 #line 14709 "configure"
14709 #include "confdefs.h"
14710 /* System header to define __stub macros and hopefully few prototypes,
14711     which can conflict with char $ac_func(); below.  */
14712 #include <assert.h>
14713 /* Override any gcc2 internal prototype to avoid an error.  */
14714 /* We use char because int might match the return type of a gcc2
14715     builtin and then its argument prototype would still apply.  */
14716 char $ac_func();
14717
14718 int main() {
14719
14720 /* The GNU C library defines this for functions which it implements
14721     to always fail with ENOSYS.  Some functions are actually named
14722     something starting with __ and the normal name is an alias.  */
14723 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14724 choke me
14725 #else
14726 $ac_func();
14727 #endif
14728
14729 ; return 0; }
14730 EOF
14731 if { (eval echo configure:14732: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14732   rm -rf conftest*
14733   eval "ac_cv_func_$ac_func=yes"
14734 else
14735   echo "configure: failed program was:" >&5
14736   cat conftest.$ac_ext >&5
14737   rm -rf conftest*
14738   eval "ac_cv_func_$ac_func=no"
14739 fi
14740 rm -f conftest*
14741 fi
14742
14743 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14744   echo "$ac_t""yes" 1>&6
14745     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14746   cat >> confdefs.h <<EOF
14747 #define $ac_tr_func 1
14748 EOF
14749
14750 else
14751   echo "$ac_t""no" 1>&6
14752 fi
14753 done
14754
14755   fi
14756
14757
14758
14759   ac_ext=C
14760 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14761 ac_cpp='$CXXCPP $CPPFLAGS'
14762 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14763 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14764 cross_compiling=$ac_cv_prog_cxx_cross
14765
14766   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
14767 echo "configure:14768: checking for _powl declaration" >&5
14768   cat > conftest.$ac_ext <<EOF
14769 #line 14770 "configure"
14770 #include "confdefs.h"
14771 #include <math.h>
14772 int main() {
14773  _powl(0, 0);
14774 ; return 0; }
14775 EOF
14776 if { (eval echo configure:14777: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14777   rm -rf conftest*
14778   use__powl=yes
14779 else
14780   echo "configure: failed program was:" >&5
14781   cat conftest.$ac_ext >&5
14782   rm -rf conftest*
14783   use__powl=no
14784 fi
14785 rm -f conftest*
14786   echo "$ac_t""$use__powl" 1>&6
14787   ac_ext=c
14788 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14789 ac_cpp='$CPP $CPPFLAGS'
14790 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14791 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14792 cross_compiling=$ac_cv_prog_cc_cross
14793
14794   if test x$use__powl = x"yes"; then
14795     for ac_func in _powl
14796 do
14797 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14798 echo "configure:14799: checking for $ac_func" >&5
14799 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14800   echo $ac_n "(cached) $ac_c" 1>&6
14801 else
14802   cat > conftest.$ac_ext <<EOF
14803 #line 14804 "configure"
14804 #include "confdefs.h"
14805 /* System header to define __stub macros and hopefully few prototypes,
14806     which can conflict with char $ac_func(); below.  */
14807 #include <assert.h>
14808 /* Override any gcc2 internal prototype to avoid an error.  */
14809 /* We use char because int might match the return type of a gcc2
14810     builtin and then its argument prototype would still apply.  */
14811 char $ac_func();
14812
14813 int main() {
14814
14815 /* The GNU C library defines this for functions which it implements
14816     to always fail with ENOSYS.  Some functions are actually named
14817     something starting with __ and the normal name is an alias.  */
14818 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14819 choke me
14820 #else
14821 $ac_func();
14822 #endif
14823
14824 ; return 0; }
14825 EOF
14826 if { (eval echo configure:14827: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14827   rm -rf conftest*
14828   eval "ac_cv_func_$ac_func=yes"
14829 else
14830   echo "configure: failed program was:" >&5
14831   cat conftest.$ac_ext >&5
14832   rm -rf conftest*
14833   eval "ac_cv_func_$ac_func=no"
14834 fi
14835 rm -f conftest*
14836 fi
14837
14838 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14839   echo "$ac_t""yes" 1>&6
14840     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14841   cat >> confdefs.h <<EOF
14842 #define $ac_tr_func 1
14843 EOF
14844
14845 else
14846   echo "$ac_t""no" 1>&6
14847 fi
14848 done
14849
14850   fi
14851
14852
14853
14854   ac_ext=C
14855 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14856 ac_cpp='$CXXCPP $CPPFLAGS'
14857 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14858 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14859 cross_compiling=$ac_cv_prog_cxx_cross
14860
14861   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
14862 echo "configure:14863: checking for _sinl declaration" >&5
14863   cat > conftest.$ac_ext <<EOF
14864 #line 14865 "configure"
14865 #include "confdefs.h"
14866 #include <math.h>
14867 int main() {
14868  _sinl(0);
14869 ; return 0; }
14870 EOF
14871 if { (eval echo configure:14872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14872   rm -rf conftest*
14873   use__sinl=yes
14874 else
14875   echo "configure: failed program was:" >&5
14876   cat conftest.$ac_ext >&5
14877   rm -rf conftest*
14878   use__sinl=no
14879 fi
14880 rm -f conftest*
14881   echo "$ac_t""$use__sinl" 1>&6
14882   ac_ext=c
14883 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14884 ac_cpp='$CPP $CPPFLAGS'
14885 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14886 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14887 cross_compiling=$ac_cv_prog_cc_cross
14888
14889   if test x$use__sinl = x"yes"; then
14890     for ac_func in _sinl
14891 do
14892 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14893 echo "configure:14894: checking for $ac_func" >&5
14894 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14895   echo $ac_n "(cached) $ac_c" 1>&6
14896 else
14897   cat > conftest.$ac_ext <<EOF
14898 #line 14899 "configure"
14899 #include "confdefs.h"
14900 /* System header to define __stub macros and hopefully few prototypes,
14901     which can conflict with char $ac_func(); below.  */
14902 #include <assert.h>
14903 /* Override any gcc2 internal prototype to avoid an error.  */
14904 /* We use char because int might match the return type of a gcc2
14905     builtin and then its argument prototype would still apply.  */
14906 char $ac_func();
14907
14908 int main() {
14909
14910 /* The GNU C library defines this for functions which it implements
14911     to always fail with ENOSYS.  Some functions are actually named
14912     something starting with __ and the normal name is an alias.  */
14913 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14914 choke me
14915 #else
14916 $ac_func();
14917 #endif
14918
14919 ; return 0; }
14920 EOF
14921 if { (eval echo configure:14922: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14922   rm -rf conftest*
14923   eval "ac_cv_func_$ac_func=yes"
14924 else
14925   echo "configure: failed program was:" >&5
14926   cat conftest.$ac_ext >&5
14927   rm -rf conftest*
14928   eval "ac_cv_func_$ac_func=no"
14929 fi
14930 rm -f conftest*
14931 fi
14932
14933 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14934   echo "$ac_t""yes" 1>&6
14935     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14936   cat >> confdefs.h <<EOF
14937 #define $ac_tr_func 1
14938 EOF
14939
14940 else
14941   echo "$ac_t""no" 1>&6
14942 fi
14943 done
14944
14945   fi
14946
14947
14948
14949   ac_ext=C
14950 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14951 ac_cpp='$CXXCPP $CPPFLAGS'
14952 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14953 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14954 cross_compiling=$ac_cv_prog_cxx_cross
14955
14956   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
14957 echo "configure:14958: checking for _sinhl declaration" >&5
14958   cat > conftest.$ac_ext <<EOF
14959 #line 14960 "configure"
14960 #include "confdefs.h"
14961 #include <math.h>
14962 int main() {
14963  _sinhl(0);
14964 ; return 0; }
14965 EOF
14966 if { (eval echo configure:14967: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14967   rm -rf conftest*
14968   use__sinhl=yes
14969 else
14970   echo "configure: failed program was:" >&5
14971   cat conftest.$ac_ext >&5
14972   rm -rf conftest*
14973   use__sinhl=no
14974 fi
14975 rm -f conftest*
14976   echo "$ac_t""$use__sinhl" 1>&6
14977   ac_ext=c
14978 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14979 ac_cpp='$CPP $CPPFLAGS'
14980 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14981 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14982 cross_compiling=$ac_cv_prog_cc_cross
14983
14984   if test x$use__sinhl = x"yes"; then
14985     for ac_func in _sinhl
14986 do
14987 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14988 echo "configure:14989: checking for $ac_func" >&5
14989 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14990   echo $ac_n "(cached) $ac_c" 1>&6
14991 else
14992   cat > conftest.$ac_ext <<EOF
14993 #line 14994 "configure"
14994 #include "confdefs.h"
14995 /* System header to define __stub macros and hopefully few prototypes,
14996     which can conflict with char $ac_func(); below.  */
14997 #include <assert.h>
14998 /* Override any gcc2 internal prototype to avoid an error.  */
14999 /* We use char because int might match the return type of a gcc2
15000     builtin and then its argument prototype would still apply.  */
15001 char $ac_func();
15002
15003 int main() {
15004
15005 /* The GNU C library defines this for functions which it implements
15006     to always fail with ENOSYS.  Some functions are actually named
15007     something starting with __ and the normal name is an alias.  */
15008 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15009 choke me
15010 #else
15011 $ac_func();
15012 #endif
15013
15014 ; return 0; }
15015 EOF
15016 if { (eval echo configure:15017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15017   rm -rf conftest*
15018   eval "ac_cv_func_$ac_func=yes"
15019 else
15020   echo "configure: failed program was:" >&5
15021   cat conftest.$ac_ext >&5
15022   rm -rf conftest*
15023   eval "ac_cv_func_$ac_func=no"
15024 fi
15025 rm -f conftest*
15026 fi
15027
15028 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15029   echo "$ac_t""yes" 1>&6
15030     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15031   cat >> confdefs.h <<EOF
15032 #define $ac_tr_func 1
15033 EOF
15034
15035 else
15036   echo "$ac_t""no" 1>&6
15037 fi
15038 done
15039
15040   fi
15041
15042
15043
15044   ac_ext=C
15045 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15046 ac_cpp='$CXXCPP $CPPFLAGS'
15047 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15048 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15049 cross_compiling=$ac_cv_prog_cxx_cross
15050
15051   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
15052 echo "configure:15053: checking for _sqrtl declaration" >&5
15053   cat > conftest.$ac_ext <<EOF
15054 #line 15055 "configure"
15055 #include "confdefs.h"
15056 #include <math.h>
15057 int main() {
15058  _sqrtl(0);
15059 ; return 0; }
15060 EOF
15061 if { (eval echo configure:15062: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15062   rm -rf conftest*
15063   use__sqrtl=yes
15064 else
15065   echo "configure: failed program was:" >&5
15066   cat conftest.$ac_ext >&5
15067   rm -rf conftest*
15068   use__sqrtl=no
15069 fi
15070 rm -f conftest*
15071   echo "$ac_t""$use__sqrtl" 1>&6
15072   ac_ext=c
15073 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15074 ac_cpp='$CPP $CPPFLAGS'
15075 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15076 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15077 cross_compiling=$ac_cv_prog_cc_cross
15078
15079   if test x$use__sqrtl = x"yes"; then
15080     for ac_func in _sqrtl
15081 do
15082 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15083 echo "configure:15084: checking for $ac_func" >&5
15084 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15085   echo $ac_n "(cached) $ac_c" 1>&6
15086 else
15087   cat > conftest.$ac_ext <<EOF
15088 #line 15089 "configure"
15089 #include "confdefs.h"
15090 /* System header to define __stub macros and hopefully few prototypes,
15091     which can conflict with char $ac_func(); below.  */
15092 #include <assert.h>
15093 /* Override any gcc2 internal prototype to avoid an error.  */
15094 /* We use char because int might match the return type of a gcc2
15095     builtin and then its argument prototype would still apply.  */
15096 char $ac_func();
15097
15098 int main() {
15099
15100 /* The GNU C library defines this for functions which it implements
15101     to always fail with ENOSYS.  Some functions are actually named
15102     something starting with __ and the normal name is an alias.  */
15103 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15104 choke me
15105 #else
15106 $ac_func();
15107 #endif
15108
15109 ; return 0; }
15110 EOF
15111 if { (eval echo configure:15112: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15112   rm -rf conftest*
15113   eval "ac_cv_func_$ac_func=yes"
15114 else
15115   echo "configure: failed program was:" >&5
15116   cat conftest.$ac_ext >&5
15117   rm -rf conftest*
15118   eval "ac_cv_func_$ac_func=no"
15119 fi
15120 rm -f conftest*
15121 fi
15122
15123 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15124   echo "$ac_t""yes" 1>&6
15125     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15126   cat >> confdefs.h <<EOF
15127 #define $ac_tr_func 1
15128 EOF
15129
15130 else
15131   echo "$ac_t""no" 1>&6
15132 fi
15133 done
15134
15135   fi
15136
15137
15138
15139   ac_ext=C
15140 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15141 ac_cpp='$CXXCPP $CPPFLAGS'
15142 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15143 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15144 cross_compiling=$ac_cv_prog_cxx_cross
15145
15146   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
15147 echo "configure:15148: checking for _tanl declaration" >&5
15148   cat > conftest.$ac_ext <<EOF
15149 #line 15150 "configure"
15150 #include "confdefs.h"
15151 #include <math.h>
15152 int main() {
15153  _tanl(0);
15154 ; return 0; }
15155 EOF
15156 if { (eval echo configure:15157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15157   rm -rf conftest*
15158   use__tanl=yes
15159 else
15160   echo "configure: failed program was:" >&5
15161   cat conftest.$ac_ext >&5
15162   rm -rf conftest*
15163   use__tanl=no
15164 fi
15165 rm -f conftest*
15166   echo "$ac_t""$use__tanl" 1>&6
15167   ac_ext=c
15168 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15169 ac_cpp='$CPP $CPPFLAGS'
15170 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15171 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15172 cross_compiling=$ac_cv_prog_cc_cross
15173
15174   if test x$use__tanl = x"yes"; then
15175     for ac_func in _tanl
15176 do
15177 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15178 echo "configure:15179: checking for $ac_func" >&5
15179 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15180   echo $ac_n "(cached) $ac_c" 1>&6
15181 else
15182   cat > conftest.$ac_ext <<EOF
15183 #line 15184 "configure"
15184 #include "confdefs.h"
15185 /* System header to define __stub macros and hopefully few prototypes,
15186     which can conflict with char $ac_func(); below.  */
15187 #include <assert.h>
15188 /* Override any gcc2 internal prototype to avoid an error.  */
15189 /* We use char because int might match the return type of a gcc2
15190     builtin and then its argument prototype would still apply.  */
15191 char $ac_func();
15192
15193 int main() {
15194
15195 /* The GNU C library defines this for functions which it implements
15196     to always fail with ENOSYS.  Some functions are actually named
15197     something starting with __ and the normal name is an alias.  */
15198 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15199 choke me
15200 #else
15201 $ac_func();
15202 #endif
15203
15204 ; return 0; }
15205 EOF
15206 if { (eval echo configure:15207: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15207   rm -rf conftest*
15208   eval "ac_cv_func_$ac_func=yes"
15209 else
15210   echo "configure: failed program was:" >&5
15211   cat conftest.$ac_ext >&5
15212   rm -rf conftest*
15213   eval "ac_cv_func_$ac_func=no"
15214 fi
15215 rm -f conftest*
15216 fi
15217
15218 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15219   echo "$ac_t""yes" 1>&6
15220     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15221   cat >> confdefs.h <<EOF
15222 #define $ac_tr_func 1
15223 EOF
15224
15225 else
15226   echo "$ac_t""no" 1>&6
15227 fi
15228 done
15229
15230   fi
15231
15232
15233
15234   ac_ext=C
15235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15236 ac_cpp='$CXXCPP $CPPFLAGS'
15237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15239 cross_compiling=$ac_cv_prog_cxx_cross
15240
15241   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
15242 echo "configure:15243: checking for _tanhl declaration" >&5
15243   cat > conftest.$ac_ext <<EOF
15244 #line 15245 "configure"
15245 #include "confdefs.h"
15246 #include <math.h>
15247 int main() {
15248  _tanhl(0);
15249 ; return 0; }
15250 EOF
15251 if { (eval echo configure:15252: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15252   rm -rf conftest*
15253   use__tanhl=yes
15254 else
15255   echo "configure: failed program was:" >&5
15256   cat conftest.$ac_ext >&5
15257   rm -rf conftest*
15258   use__tanhl=no
15259 fi
15260 rm -f conftest*
15261   echo "$ac_t""$use__tanhl" 1>&6
15262   ac_ext=c
15263 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15264 ac_cpp='$CPP $CPPFLAGS'
15265 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15266 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15267 cross_compiling=$ac_cv_prog_cc_cross
15268
15269   if test x$use__tanhl = x"yes"; then
15270     for ac_func in _tanhl
15271 do
15272 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15273 echo "configure:15274: checking for $ac_func" >&5
15274 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15275   echo $ac_n "(cached) $ac_c" 1>&6
15276 else
15277   cat > conftest.$ac_ext <<EOF
15278 #line 15279 "configure"
15279 #include "confdefs.h"
15280 /* System header to define __stub macros and hopefully few prototypes,
15281     which can conflict with char $ac_func(); below.  */
15282 #include <assert.h>
15283 /* Override any gcc2 internal prototype to avoid an error.  */
15284 /* We use char because int might match the return type of a gcc2
15285     builtin and then its argument prototype would still apply.  */
15286 char $ac_func();
15287
15288 int main() {
15289
15290 /* The GNU C library defines this for functions which it implements
15291     to always fail with ENOSYS.  Some functions are actually named
15292     something starting with __ and the normal name is an alias.  */
15293 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15294 choke me
15295 #else
15296 $ac_func();
15297 #endif
15298
15299 ; return 0; }
15300 EOF
15301 if { (eval echo configure:15302: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15302   rm -rf conftest*
15303   eval "ac_cv_func_$ac_func=yes"
15304 else
15305   echo "configure: failed program was:" >&5
15306   cat conftest.$ac_ext >&5
15307   rm -rf conftest*
15308   eval "ac_cv_func_$ac_func=no"
15309 fi
15310 rm -f conftest*
15311 fi
15312
15313 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15314   echo "$ac_t""yes" 1>&6
15315     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15316   cat >> confdefs.h <<EOF
15317 #define $ac_tr_func 1
15318 EOF
15319
15320 else
15321   echo "$ac_t""no" 1>&6
15322 fi
15323 done
15324
15325   fi
15326
15327
15328
15329   ac_ext=C
15330 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15331 ac_cpp='$CXXCPP $CPPFLAGS'
15332 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15333 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15334 cross_compiling=$ac_cv_prog_cxx_cross
15335
15336   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
15337 echo "configure:15338: checking for _sincosl declaration" >&5
15338   cat > conftest.$ac_ext <<EOF
15339 #line 15340 "configure"
15340 #include "confdefs.h"
15341 #include <math.h>
15342 int main() {
15343  _sincosl(0, 0, 0);
15344 ; return 0; }
15345 EOF
15346 if { (eval echo configure:15347: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15347   rm -rf conftest*
15348   use__sincosl=yes
15349 else
15350   echo "configure: failed program was:" >&5
15351   cat conftest.$ac_ext >&5
15352   rm -rf conftest*
15353   use__sincosl=no
15354 fi
15355 rm -f conftest*
15356   echo "$ac_t""$use__sincosl" 1>&6
15357   ac_ext=c
15358 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15359 ac_cpp='$CPP $CPPFLAGS'
15360 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15361 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15362 cross_compiling=$ac_cv_prog_cc_cross
15363
15364   if test x$use__sincosl = x"yes"; then
15365     for ac_func in _sincosl
15366 do
15367 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15368 echo "configure:15369: checking for $ac_func" >&5
15369 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15370   echo $ac_n "(cached) $ac_c" 1>&6
15371 else
15372   cat > conftest.$ac_ext <<EOF
15373 #line 15374 "configure"
15374 #include "confdefs.h"
15375 /* System header to define __stub macros and hopefully few prototypes,
15376     which can conflict with char $ac_func(); below.  */
15377 #include <assert.h>
15378 /* Override any gcc2 internal prototype to avoid an error.  */
15379 /* We use char because int might match the return type of a gcc2
15380     builtin and then its argument prototype would still apply.  */
15381 char $ac_func();
15382
15383 int main() {
15384
15385 /* The GNU C library defines this for functions which it implements
15386     to always fail with ENOSYS.  Some functions are actually named
15387     something starting with __ and the normal name is an alias.  */
15388 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15389 choke me
15390 #else
15391 $ac_func();
15392 #endif
15393
15394 ; return 0; }
15395 EOF
15396 if { (eval echo configure:15397: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15397   rm -rf conftest*
15398   eval "ac_cv_func_$ac_func=yes"
15399 else
15400   echo "configure: failed program was:" >&5
15401   cat conftest.$ac_ext >&5
15402   rm -rf conftest*
15403   eval "ac_cv_func_$ac_func=no"
15404 fi
15405 rm -f conftest*
15406 fi
15407
15408 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15409   echo "$ac_t""yes" 1>&6
15410     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15411   cat >> confdefs.h <<EOF
15412 #define $ac_tr_func 1
15413 EOF
15414
15415 else
15416   echo "$ac_t""no" 1>&6
15417 fi
15418 done
15419
15420   fi
15421
15422
15423
15424   ac_ext=C
15425 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15426 ac_cpp='$CXXCPP $CPPFLAGS'
15427 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15428 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15429 cross_compiling=$ac_cv_prog_cxx_cross
15430
15431   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
15432 echo "configure:15433: checking for _finitel declaration" >&5
15433   cat > conftest.$ac_ext <<EOF
15434 #line 15435 "configure"
15435 #include "confdefs.h"
15436 #include <math.h>
15437 int main() {
15438  _finitel(0);
15439 ; return 0; }
15440 EOF
15441 if { (eval echo configure:15442: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15442   rm -rf conftest*
15443   use__finitel=yes
15444 else
15445   echo "configure: failed program was:" >&5
15446   cat conftest.$ac_ext >&5
15447   rm -rf conftest*
15448   use__finitel=no
15449 fi
15450 rm -f conftest*
15451   echo "$ac_t""$use__finitel" 1>&6
15452   ac_ext=c
15453 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15454 ac_cpp='$CPP $CPPFLAGS'
15455 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15456 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15457 cross_compiling=$ac_cv_prog_cc_cross
15458
15459   if test x$use__finitel = x"yes"; then
15460     for ac_func in _finitel
15461 do
15462 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15463 echo "configure:15464: checking for $ac_func" >&5
15464 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15465   echo $ac_n "(cached) $ac_c" 1>&6
15466 else
15467   cat > conftest.$ac_ext <<EOF
15468 #line 15469 "configure"
15469 #include "confdefs.h"
15470 /* System header to define __stub macros and hopefully few prototypes,
15471     which can conflict with char $ac_func(); below.  */
15472 #include <assert.h>
15473 /* Override any gcc2 internal prototype to avoid an error.  */
15474 /* We use char because int might match the return type of a gcc2
15475     builtin and then its argument prototype would still apply.  */
15476 char $ac_func();
15477
15478 int main() {
15479
15480 /* The GNU C library defines this for functions which it implements
15481     to always fail with ENOSYS.  Some functions are actually named
15482     something starting with __ and the normal name is an alias.  */
15483 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15484 choke me
15485 #else
15486 $ac_func();
15487 #endif
15488
15489 ; return 0; }
15490 EOF
15491 if { (eval echo configure:15492: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15492   rm -rf conftest*
15493   eval "ac_cv_func_$ac_func=yes"
15494 else
15495   echo "configure: failed program was:" >&5
15496   cat conftest.$ac_ext >&5
15497   rm -rf conftest*
15498   eval "ac_cv_func_$ac_func=no"
15499 fi
15500 rm -f conftest*
15501 fi
15502
15503 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15504   echo "$ac_t""yes" 1>&6
15505     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15506   cat >> confdefs.h <<EOF
15507 #define $ac_tr_func 1
15508 EOF
15509
15510 else
15511   echo "$ac_t""no" 1>&6
15512 fi
15513 done
15514
15515   fi
15516
15517
15518   LIBS="$ac_save_LIBS"
15519   CXXFLAGS="$ac_save_CXXFLAGS"
15520
15521
15522     for ac_hdr in complex.h
15523 do
15524 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
15525 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
15526 echo "configure:15527: checking for $ac_hdr" >&5
15527 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15528   echo $ac_n "(cached) $ac_c" 1>&6
15529 else
15530   cat > conftest.$ac_ext <<EOF
15531 #line 15532 "configure"
15532 #include "confdefs.h"
15533 #include <$ac_hdr>
15534 EOF
15535 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15536 { (eval echo configure:15537: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15537 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15538 if test -z "$ac_err"; then
15539   rm -rf conftest*
15540   eval "ac_cv_header_$ac_safe=yes"
15541 else
15542   echo "$ac_err" >&5
15543   echo "configure: failed program was:" >&5
15544   cat conftest.$ac_ext >&5
15545   rm -rf conftest*
15546   eval "ac_cv_header_$ac_safe=no"
15547 fi
15548 rm -f conftest*
15549 fi
15550 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15551   echo "$ac_t""yes" 1>&6
15552     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
15553   cat >> confdefs.h <<EOF
15554 #define $ac_tr_hdr 1
15555 EOF
15556
15557 else
15558   echo "$ac_t""no" 1>&6
15559 fi
15560 done
15561
15562   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
15563   clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
15564   ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf copysignf
15565 do
15566 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15567 echo "configure:15568: checking for $ac_func" >&5
15568 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15569   echo $ac_n "(cached) $ac_c" 1>&6
15570 else
15571   cat > conftest.$ac_ext <<EOF
15572 #line 15573 "configure"
15573 #include "confdefs.h"
15574 /* System header to define __stub macros and hopefully few prototypes,
15575     which can conflict with char $ac_func(); below.  */
15576 #include <assert.h>
15577 /* Override any gcc2 internal prototype to avoid an error.  */
15578 /* We use char because int might match the return type of a gcc2
15579     builtin and then its argument prototype would still apply.  */
15580 char $ac_func();
15581
15582 int main() {
15583
15584 /* The GNU C library defines this for functions which it implements
15585     to always fail with ENOSYS.  Some functions are actually named
15586     something starting with __ and the normal name is an alias.  */
15587 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15588 choke me
15589 #else
15590 $ac_func();
15591 #endif
15592
15593 ; return 0; }
15594 EOF
15595 if { (eval echo configure:15596: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15596   rm -rf conftest*
15597   eval "ac_cv_func_$ac_func=yes"
15598 else
15599   echo "configure: failed program was:" >&5
15600   cat conftest.$ac_ext >&5
15601   rm -rf conftest*
15602   eval "ac_cv_func_$ac_func=no"
15603 fi
15604 rm -f conftest*
15605 fi
15606
15607 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15608   echo "$ac_t""yes" 1>&6
15609     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15610   cat >> confdefs.h <<EOF
15611 #define $ac_tr_func 1
15612 EOF
15613
15614 else
15615   echo "$ac_t""no" 1>&6
15616 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15617 fi
15618 done
15619
15620
15621
15622           USE_COMPLEX_LONG_DOUBLE=no
15623   if test x$ac_cv_func_atan2l = x"yes" \
15624      && test x$ac_cv_func_copysignl = x"yes"; then
15625     USE_COMPLEX_LONG_DOUBLE=yes
15626     for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
15627     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
15628 do
15629 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15630 echo "configure:15631: checking for $ac_func" >&5
15631 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15632   echo $ac_n "(cached) $ac_c" 1>&6
15633 else
15634   cat > conftest.$ac_ext <<EOF
15635 #line 15636 "configure"
15636 #include "confdefs.h"
15637 /* System header to define __stub macros and hopefully few prototypes,
15638     which can conflict with char $ac_func(); below.  */
15639 #include <assert.h>
15640 /* Override any gcc2 internal prototype to avoid an error.  */
15641 /* We use char because int might match the return type of a gcc2
15642     builtin and then its argument prototype would still apply.  */
15643 char $ac_func();
15644
15645 int main() {
15646
15647 /* The GNU C library defines this for functions which it implements
15648     to always fail with ENOSYS.  Some functions are actually named
15649     something starting with __ and the normal name is an alias.  */
15650 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15651 choke me
15652 #else
15653 $ac_func();
15654 #endif
15655
15656 ; return 0; }
15657 EOF
15658 if { (eval echo configure:15659: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15659   rm -rf conftest*
15660   eval "ac_cv_func_$ac_func=yes"
15661 else
15662   echo "configure: failed program was:" >&5
15663   cat conftest.$ac_ext >&5
15664   rm -rf conftest*
15665   eval "ac_cv_func_$ac_func=no"
15666 fi
15667 rm -f conftest*
15668 fi
15669
15670 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15671   echo "$ac_t""yes" 1>&6
15672     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15673   cat >> confdefs.h <<EOF
15674 #define $ac_tr_func 1
15675 EOF
15676
15677 else
15678   echo "$ac_t""no" 1>&6
15679 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15680 fi
15681 done
15682
15683
15684   fi
15685
15686
15687
15688
15689
15690
15691   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
15692 echo "configure:15693: checking for GNU C++ __complex__ support" >&5
15693   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
15694   echo $ac_n "(cached) $ac_c" 1>&6
15695 else
15696
15697
15698     ac_ext=C
15699 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15700 ac_cpp='$CXXCPP $CPPFLAGS'
15701 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15702 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15703 cross_compiling=$ac_cv_prog_cxx_cross
15704
15705     cat > conftest.$ac_ext <<EOF
15706 #line 15707 "configure"
15707 #include "confdefs.h"
15708 struct dcomplex { __complex__ double x; }; \
15709                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
15710 int main() {
15711 \
15712                      dcomplex x; f(x);
15713 ; return 0; }
15714 EOF
15715 if { (eval echo configure:15716: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15716   rm -rf conftest*
15717   glibcpp_cv_complex=ok
15718 else
15719   echo "configure: failed program was:" >&5
15720   cat conftest.$ac_ext >&5
15721   rm -rf conftest*
15722   glibcpp_cv_complex=buggy
15723
15724 fi
15725 rm -f conftest*
15726     ac_ext=c
15727 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15728 ac_cpp='$CPP $CPPFLAGS'
15729 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15730 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15731 cross_compiling=$ac_cv_prog_cc_cross
15732
15733
15734 fi
15735
15736   echo "$ac_t""$glibcpp_cv_complex" 1>&6
15737   if test $glibcpp_cv_complex = buggy; then
15738     cat >> confdefs.h <<\EOF
15739 #define _GLIBCPP_BUGGY_COMPLEX 1
15740 EOF
15741
15742   fi
15743
15744   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
15745 echo "configure:15746: checking for GNU C++ __complex__ float support" >&5
15746   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
15747   echo $ac_n "(cached) $ac_c" 1>&6
15748 else
15749
15750
15751     ac_ext=C
15752 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15753 ac_cpp='$CXXCPP $CPPFLAGS'
15754 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15755 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15756 cross_compiling=$ac_cv_prog_cxx_cross
15757
15758     rm -f conftest.h
15759     cat > conftest.h <<EOB
15760       //
15761       // Check for buggy __complex__ that causes ICE in most versions of egcs
15762       // and gcc-2.95.x on certain platforms (eg., x86-win32).
15763       //
15764       // See http://egcs.cygnus.com/ml/gcc-bugs/1999-07/msg00845.html for
15765       // more info on the bug itself.
15766       //
15767       struct
15768       float_complex
15769       {
15770        __complex__ float m_value;
15771        float_complex (float = 0.0f, float = 0.0f);
15772        float_complex (__complex__ float val) : m_value (val) {}
15773        float_complex foo (const float_complex &val)
15774          { return float_complex (~val.m_value); }
15775       };
15776 EOB
15777     cat > conftest.$ac_ext <<EOF
15778 #line 15779 "configure"
15779 #include "confdefs.h"
15780 #include "conftest.h"
15781 int main() {
15782
15783 ; return 0; }
15784 EOF
15785 if { (eval echo configure:15786: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15786   rm -rf conftest*
15787   glibcpp_cv_float_complex=ok
15788 else
15789   echo "configure: failed program was:" >&5
15790   cat conftest.$ac_ext >&5
15791   rm -rf conftest*
15792   glibcpp_cv_float_complex=buggy
15793
15794 fi
15795 rm -f conftest*
15796     ac_ext=c
15797 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15798 ac_cpp='$CPP $CPPFLAGS'
15799 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15800 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15801 cross_compiling=$ac_cv_prog_cc_cross
15802
15803
15804 fi
15805
15806   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
15807   if test $glibcpp_cv_float_complex = buggy; then
15808     cat >> confdefs.h <<\EOF
15809 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
15810 EOF
15811
15812   fi
15813
15814
15815
15816     ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
15817 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
15818 echo "configure:15819: checking for wchar.h" >&5
15819 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15820   echo $ac_n "(cached) $ac_c" 1>&6
15821 else
15822   cat > conftest.$ac_ext <<EOF
15823 #line 15824 "configure"
15824 #include "confdefs.h"
15825 #include <wchar.h>
15826 EOF
15827 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15828 { (eval echo configure:15829: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15829 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15830 if test -z "$ac_err"; then
15831   rm -rf conftest*
15832   eval "ac_cv_header_$ac_safe=yes"
15833 else
15834   echo "$ac_err" >&5
15835   echo "configure: failed program was:" >&5
15836   cat conftest.$ac_ext >&5
15837   rm -rf conftest*
15838   eval "ac_cv_header_$ac_safe=no"
15839 fi
15840 rm -f conftest*
15841 fi
15842 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15843   echo "$ac_t""yes" 1>&6
15844   ac_has_wchar_h=yes
15845 else
15846   echo "$ac_t""no" 1>&6
15847 ac_has_wchar_h=no
15848 fi
15849
15850   ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
15851 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
15852 echo "configure:15853: checking for wctype.h" >&5
15853 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15854   echo $ac_n "(cached) $ac_c" 1>&6
15855 else
15856   cat > conftest.$ac_ext <<EOF
15857 #line 15858 "configure"
15858 #include "confdefs.h"
15859 #include <wctype.h>
15860 EOF
15861 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15862 { (eval echo configure:15863: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15863 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15864 if test -z "$ac_err"; then
15865   rm -rf conftest*
15866   eval "ac_cv_header_$ac_safe=yes"
15867 else
15868   echo "$ac_err" >&5
15869   echo "configure: failed program was:" >&5
15870   cat conftest.$ac_ext >&5
15871   rm -rf conftest*
15872   eval "ac_cv_header_$ac_safe=no"
15873 fi
15874 rm -f conftest*
15875 fi
15876 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15877   echo "$ac_t""yes" 1>&6
15878   ac_has_wctype_h=yes
15879 else
15880   echo "$ac_t""no" 1>&6
15881 ac_has_wctype_h=no
15882 fi
15883
15884
15885     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
15886
15887         echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
15888 echo "configure:15889: checking for mbstate_t" >&5
15889     cat > conftest.$ac_ext <<EOF
15890 #line 15891 "configure"
15891 #include "confdefs.h"
15892 #include <wchar.h>
15893 int main() {
15894 mbstate_t teststate;
15895 ; return 0; }
15896 EOF
15897 if { (eval echo configure:15898: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15898   rm -rf conftest*
15899   use_native_mbstatet=yes
15900 else
15901   echo "configure: failed program was:" >&5
15902   cat conftest.$ac_ext >&5
15903   rm -rf conftest*
15904   use_native_mbstatet=no
15905 fi
15906 rm -f conftest*
15907     echo "$ac_t""$use_native_mbstatet" 1>&6
15908     if test x"$use_native_mbstatet" = xno; then
15909       cat >> confdefs.h <<\EOF
15910 #define _GLIBCPP_NEED_MBSTATE_T 1
15911 EOF
15912
15913     fi
15914
15915             echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
15916 echo "configure:15917: checking for WCHAR_MIN and WCHAR_MAX" >&5
15917     cat > conftest.$ac_ext <<EOF
15918 #line 15919 "configure"
15919 #include "confdefs.h"
15920 #include <wchar.h>
15921 int main() {
15922 int i = WCHAR_MIN; int j = WCHAR_MAX;
15923 ; return 0; }
15924 EOF
15925 if { (eval echo configure:15926: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15926   rm -rf conftest*
15927   has_wchar_minmax=yes
15928 else
15929   echo "configure: failed program was:" >&5
15930   cat conftest.$ac_ext >&5
15931   rm -rf conftest*
15932   has_wchar_minmax=no
15933 fi
15934 rm -f conftest*
15935     echo "$ac_t""$has_wchar_minmax" 1>&6
15936
15937             echo $ac_n "checking for WEOF""... $ac_c" 1>&6
15938 echo "configure:15939: checking for WEOF" >&5
15939     cat > conftest.$ac_ext <<EOF
15940 #line 15941 "configure"
15941 #include "confdefs.h"
15942
15943       #include <wchar.h>
15944       #include <stddef.h>
15945 int main() {
15946 wint_t i = WEOF;
15947 ; return 0; }
15948 EOF
15949 if { (eval echo configure:15950: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15950   rm -rf conftest*
15951   has_weof=yes
15952 else
15953   echo "configure: failed program was:" >&5
15954   cat conftest.$ac_ext >&5
15955   rm -rf conftest*
15956   has_weof=no
15957 fi
15958 rm -f conftest*
15959     echo "$ac_t""$has_weof" 1>&6
15960
15961         for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset
15962 do
15963 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15964 echo "configure:15965: checking for $ac_func" >&5
15965 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15966   echo $ac_n "(cached) $ac_c" 1>&6
15967 else
15968   cat > conftest.$ac_ext <<EOF
15969 #line 15970 "configure"
15970 #include "confdefs.h"
15971 /* System header to define __stub macros and hopefully few prototypes,
15972     which can conflict with char $ac_func(); below.  */
15973 #include <assert.h>
15974 /* Override any gcc2 internal prototype to avoid an error.  */
15975 /* We use char because int might match the return type of a gcc2
15976     builtin and then its argument prototype would still apply.  */
15977 char $ac_func();
15978
15979 int main() {
15980
15981 /* The GNU C library defines this for functions which it implements
15982     to always fail with ENOSYS.  Some functions are actually named
15983     something starting with __ and the normal name is an alias.  */
15984 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15985 choke me
15986 #else
15987 $ac_func();
15988 #endif
15989
15990 ; return 0; }
15991 EOF
15992 if { (eval echo configure:15993: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15993   rm -rf conftest*
15994   eval "ac_cv_func_$ac_func=yes"
15995 else
15996   echo "configure: failed program was:" >&5
15997   cat conftest.$ac_ext >&5
15998   rm -rf conftest*
15999   eval "ac_cv_func_$ac_func=no"
16000 fi
16001 rm -f conftest*
16002 fi
16003
16004 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16005   echo "$ac_t""yes" 1>&6
16006     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16007   cat >> confdefs.h <<EOF
16008 #define $ac_tr_func 1
16009 EOF
16010  ac_wfuncs=yes
16011 else
16012   echo "$ac_t""no" 1>&6
16013 ac_wfuncs=no
16014 fi
16015 done
16016
16017
16018     echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
16019 echo "configure:16020: checking for ISO C9X wchar_t support" >&5
16020     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes && test x"$ac_wfuncs" = xyes; then
16021       ac_isoC9X_wchar_t=yes
16022     else
16023       ac_isoC9X_wchar_t=no
16024     fi
16025     echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
16026
16027             ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
16028 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
16029 echo "configure:16030: checking for iconv.h" >&5
16030 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16031   echo $ac_n "(cached) $ac_c" 1>&6
16032 else
16033   cat > conftest.$ac_ext <<EOF
16034 #line 16035 "configure"
16035 #include "confdefs.h"
16036 #include <iconv.h>
16037 EOF
16038 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16039 { (eval echo configure:16040: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16040 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16041 if test -z "$ac_err"; then
16042   rm -rf conftest*
16043   eval "ac_cv_header_$ac_safe=yes"
16044 else
16045   echo "$ac_err" >&5
16046   echo "configure: failed program was:" >&5
16047   cat conftest.$ac_ext >&5
16048   rm -rf conftest*
16049   eval "ac_cv_header_$ac_safe=no"
16050 fi
16051 rm -f conftest*
16052 fi
16053 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16054   echo "$ac_t""yes" 1>&6
16055   ac_has_iconv_h=yes
16056 else
16057   echo "$ac_t""no" 1>&6
16058 ac_has_iconv_h=no
16059 fi
16060
16061     for ac_func in iconv_open iconv_close iconv
16062 do
16063 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16064 echo "configure:16065: checking for $ac_func" >&5
16065 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16066   echo $ac_n "(cached) $ac_c" 1>&6
16067 else
16068   cat > conftest.$ac_ext <<EOF
16069 #line 16070 "configure"
16070 #include "confdefs.h"
16071 /* System header to define __stub macros and hopefully few prototypes,
16072     which can conflict with char $ac_func(); below.  */
16073 #include <assert.h>
16074 /* Override any gcc2 internal prototype to avoid an error.  */
16075 /* We use char because int might match the return type of a gcc2
16076     builtin and then its argument prototype would still apply.  */
16077 char $ac_func();
16078
16079 int main() {
16080
16081 /* The GNU C library defines this for functions which it implements
16082     to always fail with ENOSYS.  Some functions are actually named
16083     something starting with __ and the normal name is an alias.  */
16084 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16085 choke me
16086 #else
16087 $ac_func();
16088 #endif
16089
16090 ; return 0; }
16091 EOF
16092 if { (eval echo configure:16093: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16093   rm -rf conftest*
16094   eval "ac_cv_func_$ac_func=yes"
16095 else
16096   echo "configure: failed program was:" >&5
16097   cat conftest.$ac_ext >&5
16098   rm -rf conftest*
16099   eval "ac_cv_func_$ac_func=no"
16100 fi
16101 rm -f conftest*
16102 fi
16103
16104 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16105   echo "$ac_t""yes" 1>&6
16106     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16107   cat >> confdefs.h <<EOF
16108 #define $ac_tr_func 1
16109 EOF
16110  ac_XPG2funcs=yes
16111 else
16112   echo "$ac_t""no" 1>&6
16113 ac_XPG2funcs=no
16114 fi
16115 done
16116
16117
16118     echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
16119 echo "configure:16120: checking for XPG2 wchar_t support" >&5
16120     if test x"$ac_has_iconv_h" = xyes && test x"$ac_XPG2funcs" = xyes; then
16121       ac_XPG2_wchar_t=yes
16122     else
16123       ac_XPG2_wchar_t=no
16124     fi
16125     echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
16126
16127             #    ac_isoC9X_wchar_t=no
16128
16129     echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
16130 echo "configure:16131: checking for enabled wchar_t specializations" >&5
16131     if test x"$ac_isoC9X_wchar_t" = xyes && test x"$ac_XPG2_wchar_t" = xyes; then
16132       libinst_wstring_la="libinst-wstring.la"
16133       cat >> confdefs.h <<\EOF
16134 #define _GLIBCPP_USE_WCHAR_T 1
16135 EOF
16136
16137       echo "$ac_t"""yes"" 1>&6
16138     else
16139       libinst_wstring_la=""
16140       echo "$ac_t"""no"" 1>&6
16141     fi
16142
16143
16144   else
16145     echo "configure: warning: <wchar.h> not found" 1>&2
16146     cat >> confdefs.h <<\EOF
16147 #define _GLIBCPP_NEED_MBSTATE_T 1
16148 EOF
16149
16150   fi
16151
16152
16153   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
16154 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
16155 echo "configure:16156: checking for ctype.h" >&5
16156 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16157   echo $ac_n "(cached) $ac_c" 1>&6
16158 else
16159   cat > conftest.$ac_ext <<EOF
16160 #line 16161 "configure"
16161 #include "confdefs.h"
16162 #include <ctype.h>
16163 EOF
16164 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16165 { (eval echo configure:16166: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16166 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16167 if test -z "$ac_err"; then
16168   rm -rf conftest*
16169   eval "ac_cv_header_$ac_safe=yes"
16170 else
16171   echo "$ac_err" >&5
16172   echo "configure: failed program was:" >&5
16173   cat conftest.$ac_ext >&5
16174   rm -rf conftest*
16175   eval "ac_cv_header_$ac_safe=no"
16176 fi
16177 rm -f conftest*
16178 fi
16179 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16180   echo "$ac_t""yes" 1>&6
16181
16182
16183         ctype_default=yes
16184
16185         echo $ac_n "checking <ctype> for gnu-linux ""... $ac_c" 1>&6
16186 echo "configure:16187: checking <ctype> for gnu-linux " >&5
16187     cat > conftest.$ac_ext <<EOF
16188 #line 16189 "configure"
16189 #include "confdefs.h"
16190 #include <ctype.h>
16191 int main() {
16192 int
16193     foo (int a)
16194     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
16195         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
16196         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
16197 ; return 0; }
16198 EOF
16199 if { (eval echo configure:16200: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16200   rm -rf conftest*
16201   \
16202     ctype_linux=yes
16203 else
16204   echo "configure: failed program was:" >&5
16205   cat conftest.$ac_ext >&5
16206   rm -rf conftest*
16207   ctype_linux=no
16208 fi
16209 rm -f conftest*
16210     echo "$ac_t""$ctype_linux" 1>&6
16211     if test $ctype_linux = "yes"; then
16212       ctype_include_dir="config/gnu-linux"
16213       ctype_default=no
16214     fi
16215
16216         if test $ctype_default = "yes"; then
16217     echo $ac_n "checking <ctype> for freebsd 4.0 ""... $ac_c" 1>&6
16218 echo "configure:16219: checking <ctype> for freebsd 4.0 " >&5
16219     cat > conftest.$ac_ext <<EOF
16220 #line 16221 "configure"
16221 #include "confdefs.h"
16222 #include <ctype.h>
16223 int main() {
16224 int
16225     foo (int a)
16226     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
16227         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
16228 ; return 0; }
16229 EOF
16230 if { (eval echo configure:16231: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16231   rm -rf conftest*
16232   \
16233     ctype_bsd=yes
16234 else
16235   echo "configure: failed program was:" >&5
16236   cat conftest.$ac_ext >&5
16237   rm -rf conftest*
16238   ctype_bsd=no
16239 fi
16240 rm -f conftest*
16241     echo "$ac_t""$ctype_bsd" 1>&6
16242     if test $ctype_bsd = "yes"; then
16243       ctype_include_dir="config/bsd"
16244       ctype_default=no
16245     fi
16246     fi
16247
16248         if test $ctype_default = "yes"; then
16249     echo $ac_n "checking <ctype> for freebsd 3.4 ""... $ac_c" 1>&6
16250 echo "configure:16251: checking <ctype> for freebsd 3.4 " >&5
16251     cat > conftest.$ac_ext <<EOF
16252 #line 16253 "configure"
16253 #include "confdefs.h"
16254 #include <ctype.h>
16255 int main() {
16256 int
16257     foo (int a)
16258     { return _S + _R + _C + _U + _L + _A \
16259       + _D + _P + _X + _G + __istype (a, 0);}
16260 ; return 0; }
16261 EOF
16262 if { (eval echo configure:16263: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16263   rm -rf conftest*
16264   \
16265     ctype_freebsd34=yes
16266 else
16267   echo "configure: failed program was:" >&5
16268   cat conftest.$ac_ext >&5
16269   rm -rf conftest*
16270   ctype_freebsd34=no
16271 fi
16272 rm -f conftest*
16273     echo "$ac_t""$ctype_freebsd34" 1>&6
16274     if test $ctype_freebsd34 = "yes"; then
16275       ctype_include_dir="config/bsd"
16276       ctype_default=no
16277     fi
16278     fi
16279
16280         if test $ctype_default = "yes"; then
16281     echo $ac_n "checking <ctype> for solaris 2.6,7,8 ""... $ac_c" 1>&6
16282 echo "configure:16283: checking <ctype> for solaris 2.6,7,8 " >&5
16283     cat > conftest.$ac_ext <<EOF
16284 #line 16285 "configure"
16285 #include "confdefs.h"
16286 #include <ctype.h>
16287 int main() {
16288 int
16289     foo (int a)
16290     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16291         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16292         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
16293 ; return 0; }
16294 EOF
16295 if { (eval echo configure:16296: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16296   rm -rf conftest*
16297   \
16298     ctype_solaris=yes
16299 else
16300   echo "configure: failed program was:" >&5
16301   cat conftest.$ac_ext >&5
16302   rm -rf conftest*
16303   ctype_solaris=no
16304 fi
16305 rm -f conftest*
16306     echo "$ac_t""$ctype_solaris" 1>&6
16307
16308     if test $ctype_solaris = "yes"; then
16309       echo $ac_n "checking   for version""... $ac_c" 1>&6
16310 echo "configure:16311: checking   for version" >&5
16311       ac_ext=C
16312 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16313 ac_cpp='$CXXCPP $CPPFLAGS'
16314 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16315 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16316 cross_compiling=$ac_cv_prog_cxx_cross
16317
16318       cat > conftest.$ac_ext <<EOF
16319 #line 16320 "configure"
16320 #include "confdefs.h"
16321 #include <ctype.h>
16322 int main() {
16323 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
16324 ; return 0; }
16325 EOF
16326 if { (eval echo configure:16327: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16327   rm -rf conftest*
16328   \
16329       ctype_solaris26=yes
16330 else
16331   echo "configure: failed program was:" >&5
16332   cat conftest.$ac_ext >&5
16333   rm -rf conftest*
16334   ctype_solaris26=no
16335 fi
16336 rm -f conftest*
16337       ac_ext=c
16338 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16339 ac_cpp='$CPP $CPPFLAGS'
16340 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16341 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16342 cross_compiling=$ac_cv_prog_cc_cross
16343
16344       if test $ctype_solaris26 = "yes"; then
16345         ctype_include_dir="config/solaris/solaris2.6"
16346         echo "$ac_t"""solaris2.6"" 1>&6
16347         ctype_default=no
16348       else
16349         ctype_include_dir="config/solaris/solaris2.7"
16350         echo "$ac_t"""solaris2.7,8"" 1>&6
16351         ctype_default=no
16352       fi
16353     fi
16354     fi
16355
16356         if test $ctype_default = "yes"; then
16357     echo $ac_n "checking <ctype> for solaris 2.5.1 ""... $ac_c" 1>&6
16358 echo "configure:16359: checking <ctype> for solaris 2.5.1 " >&5
16359     cat > conftest.$ac_ext <<EOF
16360 #line 16361 "configure"
16361 #include "confdefs.h"
16362 #include <ctype.h>
16363 int main() {
16364 int
16365     foo (int a)
16366     { return _U + _L + _N + _S + _P + _C + _X + _B \
16367         + __ctype[a];}
16368 ; return 0; }
16369 EOF
16370 if { (eval echo configure:16371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16371   rm -rf conftest*
16372   \
16373     ctype_solaris25=yes
16374 else
16375   echo "configure: failed program was:" >&5
16376   cat conftest.$ac_ext >&5
16377   rm -rf conftest*
16378   ctype_solaris25=no
16379 fi
16380 rm -f conftest*
16381     echo "$ac_t""$ctype_solaris25" 1>&6
16382     if test $ctype_solaris25 = "yes"; then
16383       ctype_include_dir="config/solaris/solaris2.5"
16384       ctype_default=no
16385     fi
16386     fi
16387
16388         if test $ctype_default = "yes"; then
16389     echo $ac_n "checking <ctype> for aix ""... $ac_c" 1>&6
16390 echo "configure:16391: checking <ctype> for aix " >&5
16391     cat > conftest.$ac_ext <<EOF
16392 #line 16393 "configure"
16393 #include "confdefs.h"
16394 #include <ctype.h>
16395 int main() {
16396 int
16397     foo (int a)
16398     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16399         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16400         + _VALC('a') + _IS('c', 0);}
16401 ; return 0; }
16402 EOF
16403 if { (eval echo configure:16404: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16404   rm -rf conftest*
16405   \
16406     ctype_aix=yes
16407 else
16408   echo "configure: failed program was:" >&5
16409   cat conftest.$ac_ext >&5
16410   rm -rf conftest*
16411   ctype_aix=no
16412 fi
16413 rm -f conftest*
16414     echo "$ac_t""$ctype_aix" 1>&6
16415     if test $ctype_aix = "yes"; then
16416       ctype_include_dir="config/aix"
16417       ctype_default=no
16418     fi
16419     fi
16420
16421         if test $ctype_default = "yes"; then
16422     echo $ac_n "checking <ctype> for newlib ""... $ac_c" 1>&6
16423 echo "configure:16424: checking <ctype> for newlib " >&5
16424     cat > conftest.$ac_ext <<EOF
16425 #line 16426 "configure"
16426 #include "confdefs.h"
16427 #include <ctype.h>
16428 int main() {
16429 int
16430     foo (int a)
16431     { return _U + _L + _N + _S + _P + _C + _X + _B \
16432         + _ctype_[a];}
16433 ; return 0; }
16434 EOF
16435 if { (eval echo configure:16436: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16436   rm -rf conftest*
16437   \
16438     ctype_newlib=yes
16439 else
16440   echo "configure: failed program was:" >&5
16441   cat conftest.$ac_ext >&5
16442   rm -rf conftest*
16443   ctype_newlib=no
16444 fi
16445 rm -f conftest*
16446     echo "$ac_t""$ctype_newlib" 1>&6
16447     if test $ctype_newlib = "yes"; then
16448       ctype_include_dir="config/newlib"
16449       ctype_default=no
16450     fi
16451     fi
16452
16453     if test $ctype_default = "yes"; then
16454       ctype_include_dir="config/generic"
16455       echo "configure: warning: "Using default ctype headers."" 1>&2
16456     fi
16457
16458
16459 else
16460   echo "$ac_t""no" 1>&6
16461 fi
16462
16463
16464
16465   for ac_hdr in unistd.h
16466 do
16467 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16468 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16469 echo "configure:16470: checking for $ac_hdr" >&5
16470 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16471   echo $ac_n "(cached) $ac_c" 1>&6
16472 else
16473   cat > conftest.$ac_ext <<EOF
16474 #line 16475 "configure"
16475 #include "confdefs.h"
16476 #include <$ac_hdr>
16477 EOF
16478 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16479 { (eval echo configure:16480: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16480 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16481 if test -z "$ac_err"; then
16482   rm -rf conftest*
16483   eval "ac_cv_header_$ac_safe=yes"
16484 else
16485   echo "$ac_err" >&5
16486   echo "configure: failed program was:" >&5
16487   cat conftest.$ac_ext >&5
16488   rm -rf conftest*
16489   eval "ac_cv_header_$ac_safe=no"
16490 fi
16491 rm -f conftest*
16492 fi
16493 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16494   echo "$ac_t""yes" 1>&6
16495     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
16496   cat >> confdefs.h <<EOF
16497 #define $ac_tr_hdr 1
16498 EOF
16499
16500 else
16501   echo "$ac_t""no" 1>&6
16502 fi
16503 done
16504
16505 for ac_func in getpagesize
16506 do
16507 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16508 echo "configure:16509: checking for $ac_func" >&5
16509 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16510   echo $ac_n "(cached) $ac_c" 1>&6
16511 else
16512   cat > conftest.$ac_ext <<EOF
16513 #line 16514 "configure"
16514 #include "confdefs.h"
16515 /* System header to define __stub macros and hopefully few prototypes,
16516     which can conflict with char $ac_func(); below.  */
16517 #include <assert.h>
16518 /* Override any gcc2 internal prototype to avoid an error.  */
16519 /* We use char because int might match the return type of a gcc2
16520     builtin and then its argument prototype would still apply.  */
16521 char $ac_func();
16522
16523 int main() {
16524
16525 /* The GNU C library defines this for functions which it implements
16526     to always fail with ENOSYS.  Some functions are actually named
16527     something starting with __ and the normal name is an alias.  */
16528 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16529 choke me
16530 #else
16531 $ac_func();
16532 #endif
16533
16534 ; return 0; }
16535 EOF
16536 if { (eval echo configure:16537: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16537   rm -rf conftest*
16538   eval "ac_cv_func_$ac_func=yes"
16539 else
16540   echo "configure: failed program was:" >&5
16541   cat conftest.$ac_ext >&5
16542   rm -rf conftest*
16543   eval "ac_cv_func_$ac_func=no"
16544 fi
16545 rm -f conftest*
16546 fi
16547
16548 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16549   echo "$ac_t""yes" 1>&6
16550     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16551   cat >> confdefs.h <<EOF
16552 #define $ac_tr_func 1
16553 EOF
16554
16555 else
16556   echo "$ac_t""no" 1>&6
16557 fi
16558 done
16559
16560 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
16561 echo "configure:16562: checking for working mmap" >&5
16562 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
16563   echo $ac_n "(cached) $ac_c" 1>&6
16564 else
16565   if test "$cross_compiling" = yes; then
16566   ac_cv_func_mmap_fixed_mapped=no
16567 else
16568   cat > conftest.$ac_ext <<EOF
16569 #line 16570 "configure"
16570 #include "confdefs.h"
16571
16572 /* Thanks to Mike Haertel and Jim Avera for this test.
16573    Here is a matrix of mmap possibilities:
16574         mmap private not fixed
16575         mmap private fixed at somewhere currently unmapped
16576         mmap private fixed at somewhere already mapped
16577         mmap shared not fixed
16578         mmap shared fixed at somewhere currently unmapped
16579         mmap shared fixed at somewhere already mapped
16580    For private mappings, we should verify that changes cannot be read()
16581    back from the file, nor mmap's back from the file at a different
16582    address.  (There have been systems where private was not correctly
16583    implemented like the infamous i386 svr4.0, and systems where the
16584    VM page cache was not coherent with the filesystem buffer cache
16585    like early versions of FreeBSD and possibly contemporary NetBSD.)
16586    For shared mappings, we should conversely verify that changes get
16587    propogated back to all the places they're supposed to be.
16588
16589    Grep wants private fixed already mapped.
16590    The main things grep needs to know about mmap are:
16591    * does it exist and is it safe to write into the mmap'd area
16592    * how to use it (BSD variants)  */
16593 #include <sys/types.h>
16594 #include <fcntl.h>
16595 #include <sys/mman.h>
16596
16597 /* This mess was copied from the GNU getpagesize.h.  */
16598 #ifndef HAVE_GETPAGESIZE
16599 # ifdef HAVE_UNISTD_H
16600 #  include <unistd.h>
16601 # endif
16602
16603 /* Assume that all systems that can run configure have sys/param.h.  */
16604 # ifndef HAVE_SYS_PARAM_H
16605 #  define HAVE_SYS_PARAM_H 1
16606 # endif
16607
16608 # ifdef _SC_PAGESIZE
16609 #  define getpagesize() sysconf(_SC_PAGESIZE)
16610 # else /* no _SC_PAGESIZE */
16611 #  ifdef HAVE_SYS_PARAM_H
16612 #   include <sys/param.h>
16613 #   ifdef EXEC_PAGESIZE
16614 #    define getpagesize() EXEC_PAGESIZE
16615 #   else /* no EXEC_PAGESIZE */
16616 #    ifdef NBPG
16617 #     define getpagesize() NBPG * CLSIZE
16618 #     ifndef CLSIZE
16619 #      define CLSIZE 1
16620 #     endif /* no CLSIZE */
16621 #    else /* no NBPG */
16622 #     ifdef NBPC
16623 #      define getpagesize() NBPC
16624 #     else /* no NBPC */
16625 #      ifdef PAGESIZE
16626 #       define getpagesize() PAGESIZE
16627 #      endif /* PAGESIZE */
16628 #     endif /* no NBPC */
16629 #    endif /* no NBPG */
16630 #   endif /* no EXEC_PAGESIZE */
16631 #  else /* no HAVE_SYS_PARAM_H */
16632 #   define getpagesize() 8192   /* punt totally */
16633 #  endif /* no HAVE_SYS_PARAM_H */
16634 # endif /* no _SC_PAGESIZE */
16635
16636 #endif /* no HAVE_GETPAGESIZE */
16637
16638 #ifdef __cplusplus
16639 extern "C" { void *malloc(unsigned); }
16640 #else
16641 char *malloc();
16642 #endif
16643
16644 int
16645 main()
16646 {
16647         char *data, *data2, *data3;
16648         int i, pagesize;
16649         int fd;
16650
16651         pagesize = getpagesize();
16652
16653         /*
16654          * First, make a file with some known garbage in it.
16655          */
16656         data = malloc(pagesize);
16657         if (!data)
16658                 exit(1);
16659         for (i = 0; i < pagesize; ++i)
16660                 *(data + i) = rand();
16661         umask(0);
16662         fd = creat("conftestmmap", 0600);
16663         if (fd < 0)
16664                 exit(1);
16665         if (write(fd, data, pagesize) != pagesize)
16666                 exit(1);
16667         close(fd);
16668
16669         /*
16670          * Next, try to mmap the file at a fixed address which
16671          * already has something else allocated at it.  If we can,
16672          * also make sure that we see the same garbage.
16673          */
16674         fd = open("conftestmmap", O_RDWR);
16675         if (fd < 0)
16676                 exit(1);
16677         data2 = malloc(2 * pagesize);
16678         if (!data2)
16679                 exit(1);
16680         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
16681         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
16682             MAP_PRIVATE | MAP_FIXED, fd, 0L))
16683                 exit(1);
16684         for (i = 0; i < pagesize; ++i)
16685                 if (*(data + i) != *(data2 + i))
16686                         exit(1);
16687
16688         /*
16689          * Finally, make sure that changes to the mapped area
16690          * do not percolate back to the file as seen by read().
16691          * (This is a bug on some variants of i386 svr4.0.)
16692          */
16693         for (i = 0; i < pagesize; ++i)
16694                 *(data2 + i) = *(data2 + i) + 1;
16695         data3 = malloc(pagesize);
16696         if (!data3)
16697                 exit(1);
16698         if (read(fd, data3, pagesize) != pagesize)
16699                 exit(1);
16700         for (i = 0; i < pagesize; ++i)
16701                 if (*(data + i) != *(data3 + i))
16702                         exit(1);
16703         close(fd);
16704         unlink("conftestmmap");
16705         exit(0);
16706 }
16707
16708 EOF
16709 if { (eval echo configure:16710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
16710 then
16711   ac_cv_func_mmap_fixed_mapped=yes
16712 else
16713   echo "configure: failed program was:" >&5
16714   cat conftest.$ac_ext >&5
16715   rm -fr conftest*
16716   ac_cv_func_mmap_fixed_mapped=no
16717 fi
16718 rm -fr conftest*
16719 fi
16720
16721 fi
16722
16723 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
16724 if test $ac_cv_func_mmap_fixed_mapped = yes; then
16725   cat >> confdefs.h <<\EOF
16726 #define HAVE_MMAP 1
16727 EOF
16728
16729 fi
16730
16731 fi
16732
16733
16734
16735 if test "$CANADIAN" = yes; then
16736   CANADIAN_TRUE=
16737   CANADIAN_FALSE='#'
16738 else
16739   CANADIAN_TRUE='#'
16740   CANADIAN_FALSE=
16741 fi
16742
16743
16744 if test "$NULL_TARGET" = yes; then
16745   NULL_TARGET_TRUE=
16746   NULL_TARGET_FALSE='#'
16747 else
16748   NULL_TARGET_TRUE='#'
16749   NULL_TARGET_FALSE=
16750 fi
16751
16752
16753 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
16754   NATIVE_TRUE=
16755   NATIVE_FALSE='#'
16756 else
16757   NATIVE_TRUE='#'
16758   NATIVE_FALSE=
16759 fi
16760
16761
16762 if test -z "$with_cross_host"; then
16763   USE_LIBDIR_TRUE=
16764   USE_LIBDIR_FALSE='#'
16765 else
16766   USE_LIBDIR_TRUE='#'
16767   USE_LIBDIR_FALSE=
16768 fi
16769
16770 if test $ac_cv_header_locale_h = yes; then
16771     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
16772 echo "configure:16773: checking for LC_MESSAGES" >&5
16773 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
16774   echo $ac_n "(cached) $ac_c" 1>&6
16775 else
16776   cat > conftest.$ac_ext <<EOF
16777 #line 16778 "configure"
16778 #include "confdefs.h"
16779 #include <locale.h>
16780 int main() {
16781 return LC_MESSAGES
16782 ; return 0; }
16783 EOF
16784 if { (eval echo configure:16785: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16785   rm -rf conftest*
16786   ac_cv_val_LC_MESSAGES=yes
16787 else
16788   echo "configure: failed program was:" >&5
16789   cat conftest.$ac_ext >&5
16790   rm -rf conftest*
16791   ac_cv_val_LC_MESSAGES=no
16792 fi
16793 rm -f conftest*
16794 fi
16795
16796 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
16797     if test $ac_cv_val_LC_MESSAGES = yes; then
16798       cat >> confdefs.h <<\EOF
16799 #define HAVE_LC_MESSAGES 1
16800 EOF
16801
16802     fi
16803   fi
16804
16805
16806 if test "${multilib}" = "yes"; then
16807   multilib_arg="--enable-multilib"
16808 else
16809   multilib_arg=
16810 fi
16811
16812
16813 # Generate the various Makefiles, include files, and scripts.
16814
16815 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
16816 # so that multilib installs will end up installed in the correct
16817 # place. To work around this not being passed down from config-ml.in
16818 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
16819 # append it here.
16820
16821 trap '' 1 2 15
16822 cat > confcache <<\EOF
16823 # This file is a shell script that caches the results of configure
16824 # tests run on this system so they can be shared between configure
16825 # scripts and configure runs.  It is not useful on other systems.
16826 # If it contains results you don't want to keep, you may remove or edit it.
16827 #
16828 # By default, configure uses ./config.cache as the cache file,
16829 # creating it if it does not exist already.  You can give configure
16830 # the --cache-file=FILE option to use a different cache file; that is
16831 # what configure does when it calls configure scripts in
16832 # subdirectories, so they share the cache.
16833 # Giving --cache-file=/dev/null disables caching, for debugging configure.
16834 # config.status only pays attention to the cache file if you give it the
16835 # --recheck option to rerun configure.
16836 #
16837 EOF
16838 # The following way of writing the cache mishandles newlines in values,
16839 # but we know of no workaround that is simple, portable, and efficient.
16840 # So, don't put newlines in cache variables' values.
16841 # Ultrix sh set writes to stderr and can't be redirected directly,
16842 # and sets the high bit in the cache file unless we assign to the vars.
16843 (set) 2>&1 |
16844   case `(ac_space=' '; set | grep ac_space) 2>&1` in
16845   *ac_space=\ *)
16846     # `set' does not quote correctly, so add quotes (double-quote substitution
16847     # turns \\\\ into \\, and sed turns \\ into \).
16848     sed -n \
16849       -e "s/'/'\\\\''/g" \
16850       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
16851     ;;
16852   *)
16853     # `set' quotes correctly as required by POSIX, so do not add quotes.
16854     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
16855     ;;
16856   esac >> confcache
16857 if cmp -s $cache_file confcache; then
16858   :
16859 else
16860   if test -w $cache_file; then
16861     echo "updating cache $cache_file"
16862     cat confcache > $cache_file
16863   else
16864     echo "not updating unwritable cache $cache_file"
16865   fi
16866 fi
16867 rm -f confcache
16868
16869 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
16870
16871 test "x$prefix" = xNONE && prefix=$ac_default_prefix
16872 # Let make expand exec_prefix.
16873 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
16874
16875 # Any assignment to VPATH causes Sun make to only execute
16876 # the first set of double-colon rules, so remove it if not needed.
16877 # If there is a colon in the path, we need to keep it.
16878 if test "x$srcdir" = x.; then
16879   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
16880 fi
16881
16882 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
16883
16884 DEFS=-DHAVE_CONFIG_H
16885
16886 # Without the "./", some shells look in PATH for config.status.
16887 : ${CONFIG_STATUS=./config.status}
16888
16889 echo creating $CONFIG_STATUS
16890 rm -f $CONFIG_STATUS
16891 cat > $CONFIG_STATUS <<EOF
16892 #! /bin/sh
16893 # Generated automatically by configure.
16894 # Run this file to recreate the current configuration.
16895 # This directory was configured as follows,
16896 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
16897 #
16898 # $0 $ac_configure_args
16899 #
16900 # Compiler output produced by configure, useful for debugging
16901 # configure, is in ./config.log if it exists.
16902
16903 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
16904 for ac_option
16905 do
16906   case "\$ac_option" in
16907   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
16908     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
16909     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
16910   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
16911     echo "$CONFIG_STATUS generated by autoconf version 2.13"
16912     exit 0 ;;
16913   -help | --help | --hel | --he | --h)
16914     echo "\$ac_cs_usage"; exit 0 ;;
16915   *) echo "\$ac_cs_usage"; exit 1 ;;
16916   esac
16917 done
16918
16919 ac_given_srcdir=$srcdir
16920 ac_given_INSTALL="$INSTALL"
16921
16922 trap 'rm -fr `echo "mkcheck Makefile src/Makefile math/Makefile libio/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
16923 EOF
16924 cat >> $CONFIG_STATUS <<EOF
16925
16926 # Protect against being on the right side of a sed subst in config.status.
16927 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
16928  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
16929 $ac_vpsub
16930 $extrasub
16931 s%@SHELL@%$SHELL%g
16932 s%@CFLAGS@%$CFLAGS%g
16933 s%@CPPFLAGS@%$CPPFLAGS%g
16934 s%@CXXFLAGS@%$CXXFLAGS%g
16935 s%@FFLAGS@%$FFLAGS%g
16936 s%@DEFS@%$DEFS%g
16937 s%@LDFLAGS@%$LDFLAGS%g
16938 s%@LIBS@%$LIBS%g
16939 s%@exec_prefix@%$exec_prefix%g
16940 s%@prefix@%$prefix%g
16941 s%@program_transform_name@%$program_transform_name%g
16942 s%@bindir@%$bindir%g
16943 s%@sbindir@%$sbindir%g
16944 s%@libexecdir@%$libexecdir%g
16945 s%@datadir@%$datadir%g
16946 s%@sysconfdir@%$sysconfdir%g
16947 s%@sharedstatedir@%$sharedstatedir%g
16948 s%@localstatedir@%$localstatedir%g
16949 s%@libdir@%$libdir%g
16950 s%@includedir@%$includedir%g
16951 s%@oldincludedir@%$oldincludedir%g
16952 s%@infodir@%$infodir%g
16953 s%@mandir@%$mandir%g
16954 s%@host@%$host%g
16955 s%@host_alias@%$host_alias%g
16956 s%@host_cpu@%$host_cpu%g
16957 s%@host_vendor@%$host_vendor%g
16958 s%@host_os@%$host_os%g
16959 s%@target@%$target%g
16960 s%@target_alias@%$target_alias%g
16961 s%@target_cpu@%$target_cpu%g
16962 s%@target_vendor@%$target_vendor%g
16963 s%@target_os@%$target_os%g
16964 s%@build@%$build%g
16965 s%@build_alias@%$build_alias%g
16966 s%@build_cpu@%$build_cpu%g
16967 s%@build_vendor@%$build_vendor%g
16968 s%@build_os@%$build_os%g
16969 s%@glibcpp_basedir@%$glibcpp_basedir%g
16970 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
16971 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
16972 s%@INSTALL_DATA@%$INSTALL_DATA%g
16973 s%@PACKAGE@%$PACKAGE%g
16974 s%@VERSION@%$VERSION%g
16975 s%@ACLOCAL@%$ACLOCAL%g
16976 s%@AUTOCONF@%$AUTOCONF%g
16977 s%@AUTOMAKE@%$AUTOMAKE%g
16978 s%@AUTOHEADER@%$AUTOHEADER%g
16979 s%@MAKEINFO@%$MAKEINFO%g
16980 s%@SET_MAKE@%$SET_MAKE%g
16981 s%@CC@%$CC%g
16982 s%@CXX@%$CXX%g
16983 s%@AS@%$AS%g
16984 s%@AR@%$AR%g
16985 s%@RANLIB@%$RANLIB%g
16986 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
16987 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
16988 s%@MAINT@%$MAINT%g
16989 s%@EXEEXT@%$EXEEXT%g
16990 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
16991 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
16992 s%@ifGNUmake@%$ifGNUmake%g
16993 s%@LN_S@%$LN_S%g
16994 s%@LIBTOOL@%$LIBTOOL%g
16995 s%@CPP@%$CPP%g
16996 s%@cpu_include_dir@%$cpu_include_dir%g
16997 s%@CPU_FLAGS@%$CPU_FLAGS%g
16998 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
16999 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
17000 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
17001 s%@GLIBCPP_NEED_XTRA_LIBIO_TRUE@%$GLIBCPP_NEED_XTRA_LIBIO_TRUE%g
17002 s%@GLIBCPP_NEED_XTRA_LIBIO_FALSE@%$GLIBCPP_NEED_XTRA_LIBIO_FALSE%g
17003 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
17004 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
17005 s%@CSHADOWFLAGS@%$CSHADOWFLAGS%g
17006 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
17007 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
17008 s%@THREADLIBS@%$THREADLIBS%g
17009 s%@THREADINCS@%$THREADINCS%g
17010 s%@THREADDEPS@%$THREADDEPS%g
17011 s%@THREADOBJS@%$THREADOBJS%g
17012 s%@THREADSPEC@%$THREADSPEC%g
17013 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
17014 s%@ctype_include_dir@%$ctype_include_dir%g
17015 s%@WERROR@%$WERROR%g
17016 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
17017 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
17018 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
17019 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
17020 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
17021 s%@libinst_wstring_la@%$libinst_wstring_la%g
17022 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
17023 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
17024 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
17025 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
17026 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
17027 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
17028 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
17029 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
17030
17031 CEOF
17032 EOF
17033
17034 cat >> $CONFIG_STATUS <<\EOF
17035
17036 # Split the substitutions into bite-sized pieces for seds with
17037 # small command number limits, like on Digital OSF/1 and HP-UX.
17038 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
17039 ac_file=1 # Number of current file.
17040 ac_beg=1 # First line for current file.
17041 ac_end=$ac_max_sed_cmds # Line after last line for current file.
17042 ac_more_lines=:
17043 ac_sed_cmds=""
17044 while $ac_more_lines; do
17045   if test $ac_beg -gt 1; then
17046     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
17047   else
17048     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
17049   fi
17050   if test ! -s conftest.s$ac_file; then
17051     ac_more_lines=false
17052     rm -f conftest.s$ac_file
17053   else
17054     if test -z "$ac_sed_cmds"; then
17055       ac_sed_cmds="sed -f conftest.s$ac_file"
17056     else
17057       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
17058     fi
17059     ac_file=`expr $ac_file + 1`
17060     ac_beg=$ac_end
17061     ac_end=`expr $ac_end + $ac_max_sed_cmds`
17062   fi
17063 done
17064 if test -z "$ac_sed_cmds"; then
17065   ac_sed_cmds=cat
17066 fi
17067 EOF
17068
17069 cat >> $CONFIG_STATUS <<EOF
17070
17071 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile math/Makefile libio/Makefile"}
17072 EOF
17073 cat >> $CONFIG_STATUS <<\EOF
17074 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
17075   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17076   case "$ac_file" in
17077   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17078        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17079   *) ac_file_in="${ac_file}.in" ;;
17080   esac
17081
17082   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
17083
17084   # Remove last slash and all that follows it.  Not all systems have dirname.
17085   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17086   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17087     # The file is in a subdirectory.
17088     test ! -d "$ac_dir" && mkdir "$ac_dir"
17089     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
17090     # A "../" for each directory in $ac_dir_suffix.
17091     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
17092   else
17093     ac_dir_suffix= ac_dots=
17094   fi
17095
17096   case "$ac_given_srcdir" in
17097   .)  srcdir=.
17098       if test -z "$ac_dots"; then top_srcdir=.
17099       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
17100   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
17101   *) # Relative path.
17102     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
17103     top_srcdir="$ac_dots$ac_given_srcdir" ;;
17104   esac
17105
17106   case "$ac_given_INSTALL" in
17107   [/$]*) INSTALL="$ac_given_INSTALL" ;;
17108   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
17109   esac
17110
17111   echo creating "$ac_file"
17112   rm -f "$ac_file"
17113   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
17114   case "$ac_file" in
17115   *Makefile*) ac_comsub="1i\\
17116 # $configure_input" ;;
17117   *) ac_comsub= ;;
17118   esac
17119
17120   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17121   sed -e "$ac_comsub
17122 s%@configure_input@%$configure_input%g
17123 s%@srcdir@%$srcdir%g
17124 s%@top_srcdir@%$top_srcdir%g
17125 s%@INSTALL@%$INSTALL%g
17126 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
17127 fi; done
17128 rm -f conftest.s*
17129
17130 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
17131 # NAME is the cpp macro being defined and VALUE is the value it is being given.
17132 #
17133 # ac_d sets the value in "#define NAME VALUE" lines.
17134 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
17135 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
17136 ac_dC='\3'
17137 ac_dD='%g'
17138 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
17139 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17140 ac_uB='\([      ]\)%\1#\2define\3'
17141 ac_uC=' '
17142 ac_uD='\4%g'
17143 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
17144 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17145 ac_eB='$%\1#\2define\3'
17146 ac_eC=' '
17147 ac_eD='%g'
17148
17149 if test "${CONFIG_HEADERS+set}" != set; then
17150 EOF
17151 cat >> $CONFIG_STATUS <<EOF
17152   CONFIG_HEADERS="config.h"
17153 EOF
17154 cat >> $CONFIG_STATUS <<\EOF
17155 fi
17156 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
17157   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17158   case "$ac_file" in
17159   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17160        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17161   *) ac_file_in="${ac_file}.in" ;;
17162   esac
17163
17164   echo creating $ac_file
17165
17166   rm -f conftest.frag conftest.in conftest.out
17167   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17168   cat $ac_file_inputs > conftest.in
17169
17170 EOF
17171
17172 # Transform confdefs.h into a sed script conftest.vals that substitutes
17173 # the proper values into config.h.in to produce config.h.  And first:
17174 # Protect against being on the right side of a sed subst in config.status.
17175 # Protect against being in an unquoted here document in config.status.
17176 rm -f conftest.vals
17177 cat > conftest.hdr <<\EOF
17178 s/[\\&%]/\\&/g
17179 s%[\\$`]%\\&%g
17180 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
17181 s%ac_d%ac_u%gp
17182 s%ac_u%ac_e%gp
17183 EOF
17184 sed -n -f conftest.hdr confdefs.h > conftest.vals
17185 rm -f conftest.hdr
17186
17187 # This sed command replaces #undef with comments.  This is necessary, for
17188 # example, in the case of _POSIX_SOURCE, which is predefined and required
17189 # on some systems where configure will not decide to define it.
17190 cat >> conftest.vals <<\EOF
17191 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
17192 EOF
17193
17194 # Break up conftest.vals because some shells have a limit on
17195 # the size of here documents, and old seds have small limits too.
17196
17197 rm -f conftest.tail
17198 while :
17199 do
17200   ac_lines=`grep -c . conftest.vals`
17201   # grep -c gives empty output for an empty file on some AIX systems.
17202   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
17203   # Write a limited-size here document to conftest.frag.
17204   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
17205   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
17206   echo 'CEOF
17207   sed -f conftest.frag conftest.in > conftest.out
17208   rm -f conftest.in
17209   mv conftest.out conftest.in
17210 ' >> $CONFIG_STATUS
17211   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
17212   rm -f conftest.vals
17213   mv conftest.tail conftest.vals
17214 done
17215 rm -f conftest.vals
17216
17217 cat >> $CONFIG_STATUS <<\EOF
17218   rm -f conftest.frag conftest.h
17219   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
17220   cat conftest.in >> conftest.h
17221   rm -f conftest.in
17222   if cmp -s $ac_file conftest.h 2>/dev/null; then
17223     echo "$ac_file is unchanged"
17224     rm -f conftest.h
17225   else
17226     # Remove last slash and all that follows it.  Not all systems have dirname.
17227       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17228       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17229       # The file is in a subdirectory.
17230       test ! -d "$ac_dir" && mkdir "$ac_dir"
17231     fi
17232     rm -f $ac_file
17233     mv conftest.h $ac_file
17234   fi
17235 fi; done
17236
17237 EOF
17238
17239 cat >> $CONFIG_STATUS <<EOF
17240 ac_sources="$CSTDIO_H $CSTDIO_CC config/$THREADH"
17241 ac_dests="bits/c++io.h src/c++io.cc bits/c++threads.h"
17242 EOF
17243
17244 cat >> $CONFIG_STATUS <<\EOF
17245 srcdir=$ac_given_srcdir
17246 while test -n "$ac_sources"; do
17247   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
17248   set $ac_sources; ac_source=$1; shift; ac_sources=$*
17249
17250   echo "linking $srcdir/$ac_source to $ac_dest"
17251
17252   if test ! -r $srcdir/$ac_source; then
17253     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
17254   fi
17255   rm -f $ac_dest
17256
17257   # Make relative symlinks.
17258   # Remove last slash and all that follows it.  Not all systems have dirname.
17259   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
17260   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
17261     # The dest file is in a subdirectory.
17262     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
17263     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
17264     # A "../" for each directory in $ac_dest_dir_suffix.
17265     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
17266   else
17267     ac_dest_dir_suffix= ac_dots=
17268   fi
17269
17270   case "$srcdir" in
17271   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
17272   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
17273   esac
17274
17275   # Make a symlink if possible; otherwise try a hard link.
17276   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
17277     ln $srcdir/$ac_source $ac_dest; then :
17278   else
17279     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
17280   fi
17281 done
17282 EOF
17283 cat >> $CONFIG_STATUS <<EOF
17284
17285 srcdir=${srcdir}
17286 host=${host}
17287 target=${target}
17288 with_multisubdir=${with_multisubdir}
17289 ac_configure_args="${multilib_arg} ${ac_configure_args}"
17290 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
17291 glibcpp_basedir=${glibcpp_basedir}
17292 CC="${CC}"
17293 CXX="${CXX}"
17294
17295 EOF
17296 cat >> $CONFIG_STATUS <<\EOF
17297 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
17298 if test -n "$CONFIG_FILES"; then
17299   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
17300   grep '^MULTISUBDIR =' Makefile >> src/Makefile
17301 fi
17302 exit 0
17303 EOF
17304 chmod +x $CONFIG_STATUS
17305 rm -fr confdefs* $ac_clean_files
17306 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
17307
17308
17309
17310 blddir=`pwd`
17311 # Generate bits/c++config.h
17312 # NB: This must be the first generated file as others include it. . .
17313
17314
17315 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
17316
17317
17318
17319 # Sanity checking & User-visible messages.
17320 # Checks down here, otherwise they get scrolled off before
17321 # the user will notice.
17322 if test "$enable_namespaces" = "yes" && test "$enable_libgcc_rebuild" = "no"
17323 then
17324   echo "configure: warning: libgcc.a will not match mangled symbols unless it is rebuilt" 1>&2
17325 fi
17326 if test "$enable_namespaces" = "no" && test "$enable_libgcc_rebuild" != "no"
17327 then
17328   # Other things besides namespaces can make this true as well, but none
17329   # of them are done automatically... yet
17330   echo "configure: warning: no point in rebuilding libgcc.a if namespaces aren't used" 1>&2
17331 fi
17332
17333 # Trying to get more people to read documentation.  Possibly remove check
17334 # and warn all the time.
17335 if test ! -f stamp-sanity-warned; then
17336   touch stamp-sanity-warned
17337   # There is no "informational" AC_MSG_ macro, so these are going to be
17338   # printed even when --quiet/--silent is given.
17339   echo ''
17340   echo 'Please make certain that you read the installation information here:'
17341   echo "  faster => ${srcdir}/docs/install.html"
17342   echo '  slower => <URL:http://sources.redhat.com/libstdc++/install.html>'
17343   echo ''
17344   echo 'and the configuration information here:'
17345   echo "  faster => ${srcdir}/docs/configopts.html"
17346   echo '  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>'
17347   echo ''
17348   echo 'before proceeding with "make".'
17349   echo ''
17350 fi
17351
17352
17353 $srcdir/mkc++config $blddir $srcdir
17354 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
17355
17356