libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --enable-debug          extra debugging, turn off optimization [default=no]"
  36 ac_help="$ac_help
  37   --enable-cstdio         enable GNU libio for target io package. (default)
  38   --enable-cstdio=LIB     use LIB target-speific io package."
  39 ac_help="$ac_help
  40   --enable-long-long      turns on 'long long' [default=yes]"
  41 ac_help="$ac_help
  42   --enable-cshadow-headers construct "shadowed" C header files for
  43                            g++ [default=no]"
  44 ac_help="$ac_help
  45   --enable-threads        enable thread usage for target GCC.
  46   --enable-threads=LIB    use LIB thread package for target GCC."
  47 ac_help="$ac_help
  48   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  49                                 [default=none]"
  50
  51 # Initialize some variables set by options.
  52 # The variables have the same names as the options, with
  53 # dashes changed to underlines.
  54 build=NONE
  55 cache_file=./config.cache
  56 exec_prefix=NONE
  57 host=NONE
  58 no_create=
  59 nonopt=NONE
  60 no_recursion=
  61 prefix=NONE
  62 program_prefix=NONE
  63 program_suffix=NONE
  64 program_transform_name=s,x,x,
  65 silent=
  66 site=
  67 sitefile=
  68 srcdir=
  69 target=NONE
  70 verbose=
  71 x_includes=NONE
  72 x_libraries=NONE
  73 bindir='${exec_prefix}/bin'
  74 sbindir='${exec_prefix}/sbin'
  75 libexecdir='${exec_prefix}/libexec'
  76 datadir='${prefix}/share'
  77 sysconfdir='${prefix}/etc'
  78 sharedstatedir='${prefix}/com'
  79 localstatedir='${prefix}/var'
  80 libdir='${exec_prefix}/lib'
  81 includedir='${prefix}/include'
  82 oldincludedir='/usr/include'
  83 infodir='${prefix}/info'
  84 mandir='${prefix}/man'
  85
  86 # Initialize some other variables.
  87 subdirs=
  88 MFLAGS= MAKEFLAGS=
  89 SHELL=${CONFIG_SHELL-/bin/sh}
  90 # Maximum number of lines to put in a shell here document.
  91 ac_max_here_lines=12
  92
  93 ac_prev=
  94 for ac_option
  95 do
  96
  97   # If the previous option needs an argument, assign it.
  98   if test -n "$ac_prev"; then
  99     eval "$ac_prev=\$ac_option"
 100     ac_prev=
 101     continue
 102   fi
 103
 104   case "$ac_option" in
 105   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 106   *) ac_optarg= ;;
 107   esac
 108
 109   # Accept the important Cygnus configure options, so we can diagnose typos.
 110
 111   case "$ac_option" in
 112
 113   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 114     ac_prev=bindir ;;
 115   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 116     bindir="$ac_optarg" ;;
 117
 118   -build | --build | --buil | --bui | --bu)
 119     ac_prev=build ;;
 120   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 121     build="$ac_optarg" ;;
 122
 123   -cache-file | --cache-file | --cache-fil | --cache-fi \
 124   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 125     ac_prev=cache_file ;;
 126   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 127   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 128     cache_file="$ac_optarg" ;;
 129
 130   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 131     ac_prev=datadir ;;
 132   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 133   | --da=*)
 134     datadir="$ac_optarg" ;;
 135
 136   -disable-* | --disable-*)
 137     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 138     # Reject names that are not valid shell variable names.
 139     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 140       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 141     fi
 142     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 143     eval "enable_${ac_feature}=no" ;;
 144
 145   -enable-* | --enable-*)
 146     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 147     # Reject names that are not valid shell variable names.
 148     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 149       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 150     fi
 151     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 152     case "$ac_option" in
 153       *=*) ;;
 154       *) ac_optarg=yes ;;
 155     esac
 156     eval "enable_${ac_feature}='$ac_optarg'" ;;
 157
 158   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 159   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 160   | --exec | --exe | --ex)
 161     ac_prev=exec_prefix ;;
 162   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 163   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 164   | --exec=* | --exe=* | --ex=*)
 165     exec_prefix="$ac_optarg" ;;
 166
 167   -gas | --gas | --ga | --g)
 168     # Obsolete; use --with-gas.
 169     with_gas=yes ;;
 170
 171   -help | --help | --hel | --he)
 172     # Omit some internal or obsolete options to make the list less imposing.
 173     # This message is too long to be a string in the A/UX 3.1 sh.
 174     cat << EOF
 175 Usage: configure [options] [host]
 176 Options: [defaults in brackets after descriptions]
 177 Configuration:
 178   --cache-file=FILE       cache test results in FILE
 179   --help                  print this message
 180   --no-create             do not create output files
 181   --quiet, --silent       do not print \`checking...' messages
 182   --site-file=FILE        use FILE as the site file
 183   --version               print the version of autoconf that created configure
 184 Directory and file names:
 185   --prefix=PREFIX         install architecture-independent files in PREFIX
 186                           [$ac_default_prefix]
 187   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 188                           [same as prefix]
 189   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 190   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 191   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 192   --datadir=DIR           read-only architecture-independent data in DIR
 193                           [PREFIX/share]
 194   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 195   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 196                           [PREFIX/com]
 197   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 198   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 199   --includedir=DIR        C header files in DIR [PREFIX/include]
 200   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 201   --infodir=DIR           info documentation in DIR [PREFIX/info]
 202   --mandir=DIR            man documentation in DIR [PREFIX/man]
 203   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 204   --program-prefix=PREFIX prepend PREFIX to installed program names
 205   --program-suffix=SUFFIX append SUFFIX to installed program names
 206   --program-transform-name=PROGRAM
 207                           run sed PROGRAM on installed program names
 208 EOF
 209     cat << EOF
 210 Host type:
 211   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 212   --host=HOST             configure for HOST [guessed]
 213   --target=TARGET         configure for TARGET [TARGET=HOST]
 214 Features and packages:
 215   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 216   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 217   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 218   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 219   --x-includes=DIR        X include files are in DIR
 220   --x-libraries=DIR       X library files are in DIR
 221 EOF
 222     if test -n "$ac_help"; then
 223       echo "--enable and --with options recognized:$ac_help"
 224     fi
 225     exit 0 ;;
 226
 227   -host | --host | --hos | --ho)
 228     ac_prev=host ;;
 229   -host=* | --host=* | --hos=* | --ho=*)
 230     host="$ac_optarg" ;;
 231
 232   -includedir | --includedir | --includedi | --included | --include \
 233   | --includ | --inclu | --incl | --inc)
 234     ac_prev=includedir ;;
 235   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 236   | --includ=* | --inclu=* | --incl=* | --inc=*)
 237     includedir="$ac_optarg" ;;
 238
 239   -infodir | --infodir | --infodi | --infod | --info | --inf)
 240     ac_prev=infodir ;;
 241   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 242     infodir="$ac_optarg" ;;
 243
 244   -libdir | --libdir | --libdi | --libd)
 245     ac_prev=libdir ;;
 246   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 247     libdir="$ac_optarg" ;;
 248
 249   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 250   | --libexe | --libex | --libe)
 251     ac_prev=libexecdir ;;
 252   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 253   | --libexe=* | --libex=* | --libe=*)
 254     libexecdir="$ac_optarg" ;;
 255
 256   -localstatedir | --localstatedir | --localstatedi | --localstated \
 257   | --localstate | --localstat | --localsta | --localst \
 258   | --locals | --local | --loca | --loc | --lo)
 259     ac_prev=localstatedir ;;
 260   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 261   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 262   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 263     localstatedir="$ac_optarg" ;;
 264
 265   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 266     ac_prev=mandir ;;
 267   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 268     mandir="$ac_optarg" ;;
 269
 270   -nfp | --nfp | --nf)
 271     # Obsolete; use --without-fp.
 272     with_fp=no ;;
 273
 274   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 275   | --no-cr | --no-c)
 276     no_create=yes ;;
 277
 278   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 279   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 280     no_recursion=yes ;;
 281
 282   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 283   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 284   | --oldin | --oldi | --old | --ol | --o)
 285     ac_prev=oldincludedir ;;
 286   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 287   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 288   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 289     oldincludedir="$ac_optarg" ;;
 290
 291   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 292     ac_prev=prefix ;;
 293   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 294     prefix="$ac_optarg" ;;
 295
 296   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 297   | --program-pre | --program-pr | --program-p)
 298     ac_prev=program_prefix ;;
 299   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 300   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 301     program_prefix="$ac_optarg" ;;
 302
 303   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 304   | --program-suf | --program-su | --program-s)
 305     ac_prev=program_suffix ;;
 306   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 307   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 308     program_suffix="$ac_optarg" ;;
 309
 310   -program-transform-name | --program-transform-name \
 311   | --program-transform-nam | --program-transform-na \
 312   | --program-transform-n | --program-transform- \
 313   | --program-transform | --program-transfor \
 314   | --program-transfo | --program-transf \
 315   | --program-trans | --program-tran \
 316   | --progr-tra | --program-tr | --program-t)
 317     ac_prev=program_transform_name ;;
 318   -program-transform-name=* | --program-transform-name=* \
 319   | --program-transform-nam=* | --program-transform-na=* \
 320   | --program-transform-n=* | --program-transform-=* \
 321   | --program-transform=* | --program-transfor=* \
 322   | --program-transfo=* | --program-transf=* \
 323   | --program-trans=* | --program-tran=* \
 324   | --progr-tra=* | --program-tr=* | --program-t=*)
 325     program_transform_name="$ac_optarg" ;;
 326
 327   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 328   | -silent | --silent | --silen | --sile | --sil)
 329     silent=yes ;;
 330
 331   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 332     ac_prev=sbindir ;;
 333   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 334   | --sbi=* | --sb=*)
 335     sbindir="$ac_optarg" ;;
 336
 337   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 338   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 339   | --sharedst | --shareds | --shared | --share | --shar \
 340   | --sha | --sh)
 341     ac_prev=sharedstatedir ;;
 342   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 343   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 344   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 345   | --sha=* | --sh=*)
 346     sharedstatedir="$ac_optarg" ;;
 347
 348   -site | --site | --sit)
 349     ac_prev=site ;;
 350   -site=* | --site=* | --sit=*)
 351     site="$ac_optarg" ;;
 352
 353   -site-file | --site-file | --site-fil | --site-fi | --site-f)
 354     ac_prev=sitefile ;;
 355   -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
 356     sitefile="$ac_optarg" ;;
 357
 358   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 359     ac_prev=srcdir ;;
 360   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 361     srcdir="$ac_optarg" ;;
 362
 363   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 364   | --syscon | --sysco | --sysc | --sys | --sy)
 365     ac_prev=sysconfdir ;;
 366   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 367   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 368     sysconfdir="$ac_optarg" ;;
 369
 370   -target | --target | --targe | --targ | --tar | --ta | --t)
 371     ac_prev=target ;;
 372   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 373     target="$ac_optarg" ;;
 374
 375   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 376     verbose=yes ;;
 377
 378   -version | --version | --versio | --versi | --vers)
 379     echo "configure generated by autoconf version 2.13"
 380     exit 0 ;;
 381
 382   -with-* | --with-*)
 383     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 384     # Reject names that are not valid shell variable names.
 385     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 386       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 387     fi
 388     ac_package=`echo $ac_package| sed 's/-/_/g'`
 389     case "$ac_option" in
 390       *=*) ;;
 391       *) ac_optarg=yes ;;
 392     esac
 393     eval "with_${ac_package}='$ac_optarg'" ;;
 394
 395   -without-* | --without-*)
 396     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 397     # Reject names that are not valid shell variable names.
 398     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 399       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 400     fi
 401     ac_package=`echo $ac_package| sed 's/-/_/g'`
 402     eval "with_${ac_package}=no" ;;
 403
 404   --x)
 405     # Obsolete; use --with-x.
 406     with_x=yes ;;
 407
 408   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 409   | --x-incl | --x-inc | --x-in | --x-i)
 410     ac_prev=x_includes ;;
 411   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 412   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 413     x_includes="$ac_optarg" ;;
 414
 415   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 416   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 417     ac_prev=x_libraries ;;
 418   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 419   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 420     x_libraries="$ac_optarg" ;;
 421
 422   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 423     ;;
 424
 425   *)
 426     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 427       echo "configure: warning: $ac_option: invalid host type" 1>&2
 428     fi
 429     if test "x$nonopt" != xNONE; then
 430       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 431     fi
 432     nonopt="$ac_option"
 433     ;;
 434
 435   esac
 436 done
 437
 438 if test -n "$ac_prev"; then
 439   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 440 fi
 441
 442 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 443
 444 # File descriptor usage:
 445 # 0 standard input
 446 # 1 file creation
 447 # 2 errors and warnings
 448 # 3 some systems may open it to /dev/tty
 449 # 4 used on the Kubota Titan
 450 # 6 checking for... messages and results
 451 # 5 compiler messages saved in config.log
 452 if test "$silent" = yes; then
 453   exec 6>/dev/null
 454 else
 455   exec 6>&1
 456 fi
 457 exec 5>./config.log
 458
 459 echo "\
 460 This file contains any messages produced by compilers while
 461 running configure, to aid debugging if configure makes a mistake.
 462 " 1>&5
 463
 464 # Strip out --no-create and --no-recursion so they do not pile up.
 465 # Also quote any args containing shell metacharacters.
 466 ac_configure_args=
 467 for ac_arg
 468 do
 469   case "$ac_arg" in
 470   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 471   | --no-cr | --no-c) ;;
 472   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 473   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 474   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 475   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 476   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 477   esac
 478 done
 479
 480 # NLS nuisances.
 481 # Only set these to C if already set.  These must not be set unconditionally
 482 # because not all systems understand e.g. LANG=C (notably SCO).
 483 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 484 # Non-C LC_CTYPE values break the ctype check.
 485 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 486 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 487 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 488 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 489
 490 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 491 rm -rf conftest* confdefs.h
 492 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 493 echo > confdefs.h
 494
 495 # A filename unique to this package, relative to the directory that
 496 # configure is in, which we can look for to find out if srcdir is correct.
 497 ac_unique_file=src/complex.cc
 498
 499 # Find the source files, if location was not specified.
 500 if test -z "$srcdir"; then
 501   ac_srcdir_defaulted=yes
 502   # Try the directory containing this script, then its parent.
 503   ac_prog=$0
 504   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 505   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 506   srcdir=$ac_confdir
 507   if test ! -r $srcdir/$ac_unique_file; then
 508     srcdir=..
 509   fi
 510 else
 511   ac_srcdir_defaulted=no
 512 fi
 513 if test ! -r $srcdir/$ac_unique_file; then
 514   if test "$ac_srcdir_defaulted" = yes; then
 515     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 516   else
 517     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 518   fi
 519 fi
 520 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 521
 522 # Prefer explicitly selected file to automatically selected ones.
 523 if test -z "$sitefile"; then
 524   if test -z "$CONFIG_SITE"; then
 525     if test "x$prefix" != xNONE; then
 526       CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527     else
 528       CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529     fi
 530   fi
 531 else
 532   CONFIG_SITE="$sitefile"
 533 fi
 534 for ac_site_file in $CONFIG_SITE; do
 535   if test -r "$ac_site_file"; then
 536     echo "loading site script $ac_site_file"
 537     . "$ac_site_file"
 538   fi
 539 done
 540
 541 if test -r "$cache_file"; then
 542   echo "loading cache $cache_file"
 543   . $cache_file
 544 else
 545   echo "creating cache $cache_file"
 546   > $cache_file
 547 fi
 548
 549 ac_ext=c
 550 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 551 ac_cpp='$CPP $CPPFLAGS'
 552 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 553 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 554 cross_compiling=$ac_cv_prog_cc_cross
 555
 556 ac_exeext=
 557 ac_objext=o
 558 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 559   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 560   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 561     ac_n= ac_c='
 562 ' ac_t='        '
 563   else
 564     ac_n=-n ac_c= ac_t=
 565   fi
 566 else
 567   ac_n= ac_c='\c' ac_t=
 568 fi
 569
 570
 571 ac_aux_dir=
 572 for ac_dir in .. $srcdir/..; do
 573   if test -f $ac_dir/install-sh; then
 574     ac_aux_dir=$ac_dir
 575     ac_install_sh="$ac_aux_dir/install-sh -c"
 576     break
 577   elif test -f $ac_dir/install.sh; then
 578     ac_aux_dir=$ac_dir
 579     ac_install_sh="$ac_aux_dir/install.sh -c"
 580     break
 581   fi
 582 done
 583 if test -z "$ac_aux_dir"; then
 584   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 585 fi
 586 ac_config_guess=$ac_aux_dir/config.guess
 587 ac_config_sub=$ac_aux_dir/config.sub
 588 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 589
 590
 591 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 592
 593 # Do some error checking and defaulting for the host and target type.
 594 # The inputs are:
 595 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 596 #
 597 # The rules are:
 598 # 1. You are not allowed to specify --host, --target, and nonopt at the
 599 #    same time.
 600 # 2. Host defaults to nonopt.
 601 # 3. If nonopt is not specified, then host defaults to the current host,
 602 #    as determined by config.guess.
 603 # 4. Target and build default to nonopt.
 604 # 5. If nonopt is not specified, then target and build default to host.
 605
 606 # The aliases save the names the user supplied, while $host etc.
 607 # will get canonicalized.
 608 case $host---$target---$nonopt in
 609 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 610 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 611 esac
 612
 613
 614 # Make sure we can run config.sub.
 615 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 616 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 617 fi
 618
 619 echo $ac_n "checking host system type""... $ac_c" 1>&6
 620 echo "configure:621: checking host system type" >&5
 621
 622 host_alias=$host
 623 case "$host_alias" in
 624 NONE)
 625   case $nonopt in
 626   NONE)
 627     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 628     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 629     fi ;;
 630   *) host_alias=$nonopt ;;
 631   esac ;;
 632 esac
 633
 634 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 635 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 636 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 637 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 638 echo "$ac_t""$host" 1>&6
 639
 640 echo $ac_n "checking target system type""... $ac_c" 1>&6
 641 echo "configure:642: checking target system type" >&5
 642
 643 target_alias=$target
 644 case "$target_alias" in
 645 NONE)
 646   case $nonopt in
 647   NONE) target_alias=$host_alias ;;
 648   *) target_alias=$nonopt ;;
 649   esac ;;
 650 esac
 651
 652 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 653 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 654 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 655 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 656 echo "$ac_t""$target" 1>&6
 657
 658 echo $ac_n "checking build system type""... $ac_c" 1>&6
 659 echo "configure:660: checking build system type" >&5
 660
 661 build_alias=$build
 662 case "$build_alias" in
 663 NONE)
 664   case $nonopt in
 665   NONE) build_alias=$host_alias ;;
 666   *) build_alias=$nonopt ;;
 667   esac ;;
 668 esac
 669
 670 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 671 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 672 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 673 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 674 echo "$ac_t""$build" 1>&6
 675
 676 test "$host_alias" != "$target_alias" &&
 677   test "$program_prefix$program_suffix$program_transform_name" = \
 678     NONENONEs,x,x, &&
 679   program_prefix=${target_alias}-
 680
 681
 682 # We use these options to decide which functions to include.
 683 # Check whether --with-target-subdir or --without-target-subdir was given.
 684 if test "${with_target_subdir+set}" = set; then
 685   withval="$with_target_subdir"
 686   :
 687 fi
 688
 689 # Check whether --with-cross-host or --without-cross-host was given.
 690 if test "${with_cross_host+set}" = set; then
 691   withval="$with_cross_host"
 692   :
 693 fi
 694
 695
 696 # Find a good install program.  We prefer a C program (faster),
 697 # so one script is as good as another.  But avoid the broken or
 698 # incompatible versions:
 699 # SysV /etc/install, /usr/sbin/install
 700 # SunOS /usr/etc/install
 701 # IRIX /sbin/install
 702 # AIX /bin/install
 703 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 704 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 705 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 706 # ./install, which can be erroneously created by make from ./install.sh.
 707 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 708 echo "configure:709: checking for a BSD compatible install" >&5
 709 if test -z "$INSTALL"; then
 710 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 711   echo $ac_n "(cached) $ac_c" 1>&6
 712 else
 713     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 714   for ac_dir in $PATH; do
 715     # Account for people who put trailing slashes in PATH elements.
 716     case "$ac_dir/" in
 717     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 718     *)
 719       # OSF1 and SCO ODT 3.0 have their own names for install.
 720       # Don't use installbsd from OSF since it installs stuff as root
 721       # by default.
 722       for ac_prog in ginstall scoinst install; do
 723         if test -f $ac_dir/$ac_prog; then
 724           if test $ac_prog = install &&
 725             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 726             # AIX install.  It has an incompatible calling convention.
 727             :
 728           else
 729             ac_cv_path_install="$ac_dir/$ac_prog -c"
 730             break 2
 731           fi
 732         fi
 733       done
 734       ;;
 735     esac
 736   done
 737   IFS="$ac_save_IFS"
 738
 739 fi
 740   if test "${ac_cv_path_install+set}" = set; then
 741     INSTALL="$ac_cv_path_install"
 742   else
 743     # As a last resort, use the slow shell script.  We don't cache a
 744     # path for INSTALL within a source directory, because that will
 745     # break other packages using the cache if that directory is
 746     # removed, or if the path is relative.
 747     INSTALL="$ac_install_sh"
 748   fi
 749 fi
 750 echo "$ac_t""$INSTALL" 1>&6
 751
 752 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 753 # It thinks the first close brace ends the variable substitution.
 754 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 755
 756 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 757
 758 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 759
 760 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 761 echo "configure:762: checking whether build environment is sane" >&5
 762 # Just in case
 763 sleep 1
 764 echo timestamp > conftestfile
 765 # Do `set' in a subshell so we don't clobber the current shell's
 766 # arguments.  Must try -L first in case configure is actually a
 767 # symlink; some systems play weird games with the mod time of symlinks
 768 # (eg FreeBSD returns the mod time of the symlink's containing
 769 # directory).
 770 if (
 771    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 772    if test "$*" = "X"; then
 773       # -L didn't work.
 774       set X `ls -t $srcdir/configure conftestfile`
 775    fi
 776    if test "$*" != "X $srcdir/configure conftestfile" \
 777       && test "$*" != "X conftestfile $srcdir/configure"; then
 778
 779       # If neither matched, then we have a broken ls.  This can happen
 780       # if, for instance, CONFIG_SHELL is bash and it inherits a
 781       # broken ls alias from the environment.  This has actually
 782       # happened.  Such a system could not be considered "sane".
 783       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 784 alias in your environment" 1>&2; exit 1; }
 785    fi
 786
 787    test "$2" = conftestfile
 788    )
 789 then
 790    # Ok.
 791    :
 792 else
 793    { echo "configure: error: newly created file is older than distributed files!
 794 Check your system clock" 1>&2; exit 1; }
 795 fi
 796 rm -f conftest*
 797 echo "$ac_t""yes" 1>&6
 798 if test "$program_transform_name" = s,x,x,; then
 799   program_transform_name=
 800 else
 801   # Double any \ or $.  echo might interpret backslashes.
 802   cat <<\EOF_SED > conftestsed
 803 s,\\,\\\\,g; s,\$,$$,g
 804 EOF_SED
 805   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 806   rm -f conftestsed
 807 fi
 808 test "$program_prefix" != NONE &&
 809   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 810 # Use a double $ so make ignores it.
 811 test "$program_suffix" != NONE &&
 812   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 813
 814 # sed with no file args requires a program.
 815 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 816
 817 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 818 echo "configure:819: checking whether ${MAKE-make} sets \${MAKE}" >&5
 819 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 820 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 821   echo $ac_n "(cached) $ac_c" 1>&6
 822 else
 823   cat > conftestmake <<\EOF
 824 all:
 825         @echo 'ac_maketemp="${MAKE}"'
 826 EOF
 827 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 828 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 829 if test -n "$ac_maketemp"; then
 830   eval ac_cv_prog_make_${ac_make}_set=yes
 831 else
 832   eval ac_cv_prog_make_${ac_make}_set=no
 833 fi
 834 rm -f conftestmake
 835 fi
 836 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 837   echo "$ac_t""yes" 1>&6
 838   SET_MAKE=
 839 else
 840   echo "$ac_t""no" 1>&6
 841   SET_MAKE="MAKE=${MAKE-make}"
 842 fi
 843
 844 if test $host != $build; then
 845   ac_tool_prefix=${host_alias}-
 846 else
 847   ac_tool_prefix=
 848 fi
 849
 850 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 851 echo "configure:852: checking for Cygwin environment" >&5
 852 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 853   echo $ac_n "(cached) $ac_c" 1>&6
 854 else
 855   cat > conftest.$ac_ext <<EOF
 856 #line 857 "configure"
 857 #include "confdefs.h"
 858
 859 int main() {
 860
 861 #ifndef __CYGWIN__
 862 #define __CYGWIN__ __CYGWIN32__
 863 #endif
 864 return __CYGWIN__;
 865 ; return 0; }
 866 EOF
 867 if { (eval echo configure:868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 868   rm -rf conftest*
 869   ac_cv_cygwin=yes
 870 else
 871   echo "configure: failed program was:" >&5
 872   cat conftest.$ac_ext >&5
 873   rm -rf conftest*
 874   ac_cv_cygwin=no
 875 fi
 876 rm -f conftest*
 877 rm -f conftest*
 878 fi
 879
 880 echo "$ac_t""$ac_cv_cygwin" 1>&6
 881 CYGWIN=
 882 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 883 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 884 echo "configure:885: checking for mingw32 environment" >&5
 885 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 886   echo $ac_n "(cached) $ac_c" 1>&6
 887 else
 888   cat > conftest.$ac_ext <<EOF
 889 #line 890 "configure"
 890 #include "confdefs.h"
 891
 892 int main() {
 893 return __MINGW32__;
 894 ; return 0; }
 895 EOF
 896 if { (eval echo configure:897: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 897   rm -rf conftest*
 898   ac_cv_mingw32=yes
 899 else
 900   echo "configure: failed program was:" >&5
 901   cat conftest.$ac_ext >&5
 902   rm -rf conftest*
 903   ac_cv_mingw32=no
 904 fi
 905 rm -f conftest*
 906 rm -f conftest*
 907 fi
 908
 909 echo "$ac_t""$ac_cv_mingw32" 1>&6
 910 MINGW32=
 911 test "$ac_cv_mingw32" = yes && MINGW32=yes
 912
 913     # Check whether --enable-multilib or --disable-multilib was given.
 914 if test "${enable_multilib+set}" = set; then
 915   enableval="$enable_multilib"
 916   case "${enableval}" in
 917     yes) multilib=yes ;;
 918     no)  multilib=no ;;
 919     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 920    esac
 921 else
 922   multilib=yes
 923 fi
 924
 925       if test "${srcdir}" = "."; then
 926     if test "${with_target_subdir}" != "."; then
 927       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 928     else
 929       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 930     fi
 931   else
 932     glibcpp_basedir="${srcdir}/."
 933   fi
 934
 935
 936
 937 # Make sure we can run config.sub.
 938 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 939 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 940 fi
 941
 942 echo $ac_n "checking host system type""... $ac_c" 1>&6
 943 echo "configure:944: checking host system type" >&5
 944
 945 host_alias=$host
 946 case "$host_alias" in
 947 NONE)
 948   case $nonopt in
 949   NONE)
 950     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 951     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 952     fi ;;
 953   *) host_alias=$nonopt ;;
 954   esac ;;
 955 esac
 956
 957 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 958 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 959 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 960 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 961 echo "$ac_t""$host" 1>&6
 962
 963
 964
 965 PACKAGE=libstdc++
 966
 967 VERSION=2.90.8
 968
 969 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 970   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 971 fi
 972 cat >> confdefs.h <<EOF
 973 #define PACKAGE "$PACKAGE"
 974 EOF
 975
 976 cat >> confdefs.h <<EOF
 977 #define VERSION "$VERSION"
 978 EOF
 979
 980
 981
 982 missing_dir=`cd $ac_aux_dir && pwd`
 983 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 984 echo "configure:985: checking for working aclocal" >&5
 985 # Run test in a subshell; some versions of sh will print an error if
 986 # an executable is not found, even if stderr is redirected.
 987 # Redirect stdin to placate older versions of autoconf.  Sigh.
 988 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 989    ACLOCAL=aclocal
 990    echo "$ac_t""found" 1>&6
 991 else
 992    ACLOCAL="$missing_dir/missing aclocal"
 993    echo "$ac_t""missing" 1>&6
 994 fi
 995
 996 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 997 echo "configure:998: checking for working autoconf" >&5
 998 # Run test in a subshell; some versions of sh will print an error if
 999 # an executable is not found, even if stderr is redirected.
1000 # Redirect stdin to placate older versions of autoconf.  Sigh.
1001 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
1002    AUTOCONF=autoconf
1003    echo "$ac_t""found" 1>&6
1004 else
1005    AUTOCONF="$missing_dir/missing autoconf"
1006    echo "$ac_t""missing" 1>&6
1007 fi
1008
1009 echo $ac_n "checking for working automake""... $ac_c" 1>&6
1010 echo "configure:1011: checking for working automake" >&5
1011 # Run test in a subshell; some versions of sh will print an error if
1012 # an executable is not found, even if stderr is redirected.
1013 # Redirect stdin to placate older versions of autoconf.  Sigh.
1014 if (automake --version) < /dev/null > /dev/null 2>&1; then
1015    AUTOMAKE=automake
1016    echo "$ac_t""found" 1>&6
1017 else
1018    AUTOMAKE="$missing_dir/missing automake"
1019    echo "$ac_t""missing" 1>&6
1020 fi
1021
1022 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
1023 echo "configure:1024: checking for working autoheader" >&5
1024 # Run test in a subshell; some versions of sh will print an error if
1025 # an executable is not found, even if stderr is redirected.
1026 # Redirect stdin to placate older versions of autoconf.  Sigh.
1027 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
1028    AUTOHEADER=autoheader
1029    echo "$ac_t""found" 1>&6
1030 else
1031    AUTOHEADER="$missing_dir/missing autoheader"
1032    echo "$ac_t""missing" 1>&6
1033 fi
1034
1035 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1036 echo "configure:1037: checking for working makeinfo" >&5
1037 # Run test in a subshell; some versions of sh will print an error if
1038 # an executable is not found, even if stderr is redirected.
1039 # Redirect stdin to placate older versions of autoconf.  Sigh.
1040 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1041    MAKEINFO=makeinfo
1042    echo "$ac_t""found" 1>&6
1043 else
1044    MAKEINFO="$missing_dir/missing makeinfo"
1045    echo "$ac_t""missing" 1>&6
1046 fi
1047
1048
1049
1050 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1051 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1052 # are probably using a cross compiler, which will not be able to fully
1053 # link an executable.  This should really be fixed in autoconf
1054 # itself.
1055
1056
1057
1058
1059 # Extract the first word of "gcc", so it can be a program name with args.
1060 set dummy gcc; ac_word=$2
1061 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1062 echo "configure:1063: checking for $ac_word" >&5
1063 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1064   echo $ac_n "(cached) $ac_c" 1>&6
1065 else
1066   if test -n "$CC"; then
1067   ac_cv_prog_CC="$CC" # Let the user override the test.
1068 else
1069   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1070   ac_dummy="$PATH"
1071   for ac_dir in $ac_dummy; do
1072     test -z "$ac_dir" && ac_dir=.
1073     if test -f $ac_dir/$ac_word; then
1074       ac_cv_prog_CC="gcc"
1075       break
1076     fi
1077   done
1078   IFS="$ac_save_ifs"
1079 fi
1080 fi
1081 CC="$ac_cv_prog_CC"
1082 if test -n "$CC"; then
1083   echo "$ac_t""$CC" 1>&6
1084 else
1085   echo "$ac_t""no" 1>&6
1086 fi
1087
1088 if test -z "$CC"; then
1089   # Extract the first word of "cc", so it can be a program name with args.
1090 set dummy cc; ac_word=$2
1091 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1092 echo "configure:1093: checking for $ac_word" >&5
1093 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1094   echo $ac_n "(cached) $ac_c" 1>&6
1095 else
1096   if test -n "$CC"; then
1097   ac_cv_prog_CC="$CC" # Let the user override the test.
1098 else
1099   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1100   ac_prog_rejected=no
1101   ac_dummy="$PATH"
1102   for ac_dir in $ac_dummy; do
1103     test -z "$ac_dir" && ac_dir=.
1104     if test -f $ac_dir/$ac_word; then
1105       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1106         ac_prog_rejected=yes
1107         continue
1108       fi
1109       ac_cv_prog_CC="cc"
1110       break
1111     fi
1112   done
1113   IFS="$ac_save_ifs"
1114 if test $ac_prog_rejected = yes; then
1115   # We found a bogon in the path, so make sure we never use it.
1116   set dummy $ac_cv_prog_CC
1117   shift
1118   if test $# -gt 0; then
1119     # We chose a different compiler from the bogus one.
1120     # However, it has the same basename, so the bogon will be chosen
1121     # first if we set CC to just the basename; use the full file name.
1122     shift
1123     set dummy "$ac_dir/$ac_word" "$@"
1124     shift
1125     ac_cv_prog_CC="$@"
1126   fi
1127 fi
1128 fi
1129 fi
1130 CC="$ac_cv_prog_CC"
1131 if test -n "$CC"; then
1132   echo "$ac_t""$CC" 1>&6
1133 else
1134   echo "$ac_t""no" 1>&6
1135 fi
1136
1137   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1138 fi
1139
1140 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1141 echo "configure:1142: checking whether we are using GNU C" >&5
1142 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1143   echo $ac_n "(cached) $ac_c" 1>&6
1144 else
1145   cat > conftest.c <<EOF
1146 #ifdef __GNUC__
1147   yes;
1148 #endif
1149 EOF
1150 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1151: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1151   ac_cv_prog_gcc=yes
1152 else
1153   ac_cv_prog_gcc=no
1154 fi
1155 fi
1156
1157 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1158
1159 if test $ac_cv_prog_gcc = yes; then
1160   GCC=yes
1161   ac_test_CFLAGS="${CFLAGS+set}"
1162   ac_save_CFLAGS="$CFLAGS"
1163   CFLAGS=
1164   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1165 echo "configure:1166: checking whether ${CC-cc} accepts -g" >&5
1166 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1167   echo $ac_n "(cached) $ac_c" 1>&6
1168 else
1169   echo 'void f(){}' > conftest.c
1170 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1171   ac_cv_prog_cc_g=yes
1172 else
1173   ac_cv_prog_cc_g=no
1174 fi
1175 rm -f conftest*
1176
1177 fi
1178
1179 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1180   if test "$ac_test_CFLAGS" = set; then
1181     CFLAGS="$ac_save_CFLAGS"
1182   elif test $ac_cv_prog_cc_g = yes; then
1183     CFLAGS="-g -O2"
1184   else
1185     CFLAGS="-O2"
1186   fi
1187 else
1188   GCC=
1189   test "${CFLAGS+set}" = set || CFLAGS="-g"
1190 fi
1191
1192
1193 # Likewise for AC_PROG_CXX.
1194
1195
1196
1197 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1198 do
1199 # Extract the first word of "$ac_prog", so it can be a program name with args.
1200 set dummy $ac_prog; ac_word=$2
1201 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1202 echo "configure:1203: checking for $ac_word" >&5
1203 if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
1204   echo $ac_n "(cached) $ac_c" 1>&6
1205 else
1206   if test -n "$CXX"; then
1207   ac_cv_prog_CXX="$CXX" # Let the user override the test.
1208 else
1209   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1210   ac_dummy="$PATH"
1211   for ac_dir in $ac_dummy; do
1212     test -z "$ac_dir" && ac_dir=.
1213     if test -f $ac_dir/$ac_word; then
1214       ac_cv_prog_CXX="$ac_prog"
1215       break
1216     fi
1217   done
1218   IFS="$ac_save_ifs"
1219 fi
1220 fi
1221 CXX="$ac_cv_prog_CXX"
1222 if test -n "$CXX"; then
1223   echo "$ac_t""$CXX" 1>&6
1224 else
1225   echo "$ac_t""no" 1>&6
1226 fi
1227
1228 test -n "$CXX" && break
1229 done
1230 test -n "$CXX" || CXX="gcc"
1231
1232 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1233
1234 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1235 echo "configure:1236: checking whether we are using GNU C++" >&5
1236 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1237   echo $ac_n "(cached) $ac_c" 1>&6
1238 else
1239   cat > conftest.C <<EOF
1240 #ifdef __GNUC__
1241   yes;
1242 #endif
1243 EOF
1244 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1245: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1245   ac_cv_prog_gxx=yes
1246 else
1247   ac_cv_prog_gxx=no
1248 fi
1249 fi
1250
1251 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1252
1253 if test $ac_cv_prog_gxx = yes; then
1254   GXX=yes
1255   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1256   ac_save_CXXFLAGS="$CXXFLAGS"
1257   CXXFLAGS=
1258   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1259 echo "configure:1260: checking whether ${CXX-g++} accepts -g" >&5
1260 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1261   echo $ac_n "(cached) $ac_c" 1>&6
1262 else
1263   echo 'void f(){}' > conftest.cc
1264 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1265   ac_cv_prog_cxx_g=yes
1266 else
1267   ac_cv_prog_cxx_g=no
1268 fi
1269 rm -f conftest*
1270
1271 fi
1272
1273 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1274   if test "$ac_test_CXXFLAGS" = set; then
1275     CXXFLAGS="$ac_save_CXXFLAGS"
1276   elif test $ac_cv_prog_cxx_g = yes; then
1277     CXXFLAGS="-g -O2"
1278   else
1279     CXXFLAGS="-O2"
1280   fi
1281 else
1282   GXX=
1283   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1284 fi
1285
1286
1287 # AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD).  If we dont
1288 # run it explicitly here, it will be run implicitly before
1289 # LIBGCJ_CONFIGURE, which doesn't work because that means that it will
1290 # be run before AC_CANONICAL_HOST.
1291 echo $ac_n "checking build system type""... $ac_c" 1>&6
1292 echo "configure:1293: checking build system type" >&5
1293
1294 build_alias=$build
1295 case "$build_alias" in
1296 NONE)
1297   case $nonopt in
1298   NONE) build_alias=$host_alias ;;
1299   *) build_alias=$nonopt ;;
1300   esac ;;
1301 esac
1302
1303 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
1304 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1305 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1306 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1307 echo "$ac_t""$build" 1>&6
1308
1309
1310 # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1311 set dummy ${ac_tool_prefix}as; ac_word=$2
1312 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1313 echo "configure:1314: checking for $ac_word" >&5
1314 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1315   echo $ac_n "(cached) $ac_c" 1>&6
1316 else
1317   if test -n "$AS"; then
1318   ac_cv_prog_AS="$AS" # Let the user override the test.
1319 else
1320   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1321   ac_dummy="$PATH"
1322   for ac_dir in $ac_dummy; do
1323     test -z "$ac_dir" && ac_dir=.
1324     if test -f $ac_dir/$ac_word; then
1325       ac_cv_prog_AS="${ac_tool_prefix}as"
1326       break
1327     fi
1328   done
1329   IFS="$ac_save_ifs"
1330   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1331 fi
1332 fi
1333 AS="$ac_cv_prog_AS"
1334 if test -n "$AS"; then
1335   echo "$ac_t""$AS" 1>&6
1336 else
1337   echo "$ac_t""no" 1>&6
1338 fi
1339
1340
1341
1342 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1343 set dummy ${ac_tool_prefix}ar; ac_word=$2
1344 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1345 echo "configure:1346: checking for $ac_word" >&5
1346 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1347   echo $ac_n "(cached) $ac_c" 1>&6
1348 else
1349   if test -n "$AR"; then
1350   ac_cv_prog_AR="$AR" # Let the user override the test.
1351 else
1352   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1353   ac_dummy="$PATH"
1354   for ac_dir in $ac_dummy; do
1355     test -z "$ac_dir" && ac_dir=.
1356     if test -f $ac_dir/$ac_word; then
1357       ac_cv_prog_AR="${ac_tool_prefix}ar"
1358       break
1359     fi
1360   done
1361   IFS="$ac_save_ifs"
1362   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1363 fi
1364 fi
1365 AR="$ac_cv_prog_AR"
1366 if test -n "$AR"; then
1367   echo "$ac_t""$AR" 1>&6
1368 else
1369   echo "$ac_t""no" 1>&6
1370 fi
1371
1372
1373
1374 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1375 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1376 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1377 echo "configure:1378: checking for $ac_word" >&5
1378 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1379   echo $ac_n "(cached) $ac_c" 1>&6
1380 else
1381   if test -n "$RANLIB"; then
1382   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1383 else
1384   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1385   ac_dummy="$PATH"
1386   for ac_dir in $ac_dummy; do
1387     test -z "$ac_dir" && ac_dir=.
1388     if test -f $ac_dir/$ac_word; then
1389       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1390       break
1391     fi
1392   done
1393   IFS="$ac_save_ifs"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403
1404 if test -z "$ac_cv_prog_RANLIB"; then
1405 if test -n "$ac_tool_prefix"; then
1406   # Extract the first word of "ranlib", so it can be a program name with args.
1407 set dummy ranlib; ac_word=$2
1408 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1409 echo "configure:1410: checking for $ac_word" >&5
1410 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1411   echo $ac_n "(cached) $ac_c" 1>&6
1412 else
1413   if test -n "$RANLIB"; then
1414   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1415 else
1416   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1417   ac_dummy="$PATH"
1418   for ac_dir in $ac_dummy; do
1419     test -z "$ac_dir" && ac_dir=.
1420     if test -f $ac_dir/$ac_word; then
1421       ac_cv_prog_RANLIB="ranlib"
1422       break
1423     fi
1424   done
1425   IFS="$ac_save_ifs"
1426   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1427 fi
1428 fi
1429 RANLIB="$ac_cv_prog_RANLIB"
1430 if test -n "$RANLIB"; then
1431   echo "$ac_t""$RANLIB" 1>&6
1432 else
1433   echo "$ac_t""no" 1>&6
1434 fi
1435
1436 else
1437   RANLIB=":"
1438 fi
1439 fi
1440
1441
1442 # Find a good install program.  We prefer a C program (faster),
1443 # so one script is as good as another.  But avoid the broken or
1444 # incompatible versions:
1445 # SysV /etc/install, /usr/sbin/install
1446 # SunOS /usr/etc/install
1447 # IRIX /sbin/install
1448 # AIX /bin/install
1449 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1450 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1451 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1452 # ./install, which can be erroneously created by make from ./install.sh.
1453 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1454 echo "configure:1455: checking for a BSD compatible install" >&5
1455 if test -z "$INSTALL"; then
1456 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1457   echo $ac_n "(cached) $ac_c" 1>&6
1458 else
1459     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1460   for ac_dir in $PATH; do
1461     # Account for people who put trailing slashes in PATH elements.
1462     case "$ac_dir/" in
1463     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1464     *)
1465       # OSF1 and SCO ODT 3.0 have their own names for install.
1466       # Don't use installbsd from OSF since it installs stuff as root
1467       # by default.
1468       for ac_prog in ginstall scoinst install; do
1469         if test -f $ac_dir/$ac_prog; then
1470           if test $ac_prog = install &&
1471             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1472             # AIX install.  It has an incompatible calling convention.
1473             :
1474           else
1475             ac_cv_path_install="$ac_dir/$ac_prog -c"
1476             break 2
1477           fi
1478         fi
1479       done
1480       ;;
1481     esac
1482   done
1483   IFS="$ac_save_IFS"
1484
1485 fi
1486   if test "${ac_cv_path_install+set}" = set; then
1487     INSTALL="$ac_cv_path_install"
1488   else
1489     # As a last resort, use the slow shell script.  We don't cache a
1490     # path for INSTALL within a source directory, because that will
1491     # break other packages using the cache if that directory is
1492     # removed, or if the path is relative.
1493     INSTALL="$ac_install_sh"
1494   fi
1495 fi
1496 echo "$ac_t""$INSTALL" 1>&6
1497
1498 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1499 # It thinks the first close brace ends the variable substitution.
1500 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1501
1502 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1503
1504 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1505
1506
1507 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1508 echo "configure:1509: checking whether to enable maintainer-specific portions of Makefiles" >&5
1509     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1510 if test "${enable_maintainer_mode+set}" = set; then
1511   enableval="$enable_maintainer_mode"
1512   USE_MAINTAINER_MODE=$enableval
1513 else
1514   USE_MAINTAINER_MODE=no
1515 fi
1516
1517   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1518
1519
1520 if test $USE_MAINTAINER_MODE = yes; then
1521   MAINTAINER_MODE_TRUE=
1522   MAINTAINER_MODE_FALSE='#'
1523 else
1524   MAINTAINER_MODE_TRUE='#'
1525   MAINTAINER_MODE_FALSE=
1526 fi
1527   MAINT=$MAINTAINER_MODE_TRUE
1528
1529
1530
1531 # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1532 # at least currently, we never actually build a program, so we never
1533 # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1534 # fails, because we are probably configuring with a cross compiler
1535 # which cant create executables.  So we include AC_EXEEXT to keep
1536 # automake happy, but we dont execute it, since we dont care about
1537 # the result.
1538 if false; then
1539
1540
1541 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1542 echo "configure:1543: checking for executable suffix" >&5
1543 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1544   echo $ac_n "(cached) $ac_c" 1>&6
1545 else
1546   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1547   ac_cv_exeext=.exe
1548 else
1549   rm -f conftest*
1550   echo 'int main () { return 0; }' > conftest.$ac_ext
1551   ac_cv_exeext=
1552   if { (eval echo configure:1553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1553     for file in conftest.*; do
1554       case $file in
1555       *.c | *.o | *.obj | *.ilk | *.pdb) ;;
1556       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1557       esac
1558     done
1559   else
1560     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1561   fi
1562   rm -f conftest*
1563   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1564 fi
1565 fi
1566
1567 EXEEXT=""
1568 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1569 echo "$ac_t""${ac_cv_exeext}" 1>&6
1570 ac_exeext=$EXEEXT
1571
1572 fi
1573
1574 # configure.host sets the following important variables
1575 #       glibcpp_cflags    - host specific C compiler flags
1576 #       glibcpp_cxxflags  - host specific C++ compiler flags
1577
1578 glibcpp_cflags=
1579 glibcpp_cxxflags=
1580
1581 . ${glibcpp_basedir}/configure.host
1582
1583 case ${glibcpp_basedir} in
1584 /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1585 *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1586 esac
1587
1588 GLIBCPP_CFLAGS="${glibcpp_cflags}"
1589 GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1590
1591
1592
1593
1594 # Check whether --enable-shared or --disable-shared was given.
1595 if test "${enable_shared+set}" = set; then
1596   enableval="$enable_shared"
1597   p=${PACKAGE-default}
1598 case "$enableval" in
1599 yes) enable_shared=yes ;;
1600 no) enable_shared=no ;;
1601 *)
1602   enable_shared=no
1603   # Look at the argument we got.  We use all the common list separators.
1604   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1605   for pkg in $enableval; do
1606     if test "X$pkg" = "X$p"; then
1607       enable_shared=yes
1608     fi
1609   done
1610   IFS="$ac_save_ifs"
1611   ;;
1612 esac
1613 else
1614   enable_shared=yes
1615 fi
1616
1617 # Check whether --enable-static or --disable-static was given.
1618 if test "${enable_static+set}" = set; then
1619   enableval="$enable_static"
1620   p=${PACKAGE-default}
1621 case "$enableval" in
1622 yes) enable_static=yes ;;
1623 no) enable_static=no ;;
1624 *)
1625   enable_static=no
1626   # Look at the argument we got.  We use all the common list separators.
1627   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1628   for pkg in $enableval; do
1629     if test "X$pkg" = "X$p"; then
1630       enable_static=yes
1631     fi
1632   done
1633   IFS="$ac_save_ifs"
1634   ;;
1635 esac
1636 else
1637   enable_static=yes
1638 fi
1639
1640 # Check whether --enable-fast-install or --disable-fast-install was given.
1641 if test "${enable_fast_install+set}" = set; then
1642   enableval="$enable_fast_install"
1643   p=${PACKAGE-default}
1644 case "$enableval" in
1645 yes) enable_fast_install=yes ;;
1646 no) enable_fast_install=no ;;
1647 *)
1648   enable_fast_install=no
1649   # Look at the argument we got.  We use all the common list separators.
1650   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1651   for pkg in $enableval; do
1652     if test "X$pkg" = "X$p"; then
1653       enable_fast_install=yes
1654     fi
1655   done
1656   IFS="$ac_save_ifs"
1657   ;;
1658 esac
1659 else
1660   enable_fast_install=yes
1661 fi
1662
1663 # Extract the first word of "ranlib", so it can be a program name with args.
1664 set dummy ranlib; ac_word=$2
1665 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1666 echo "configure:1667: checking for $ac_word" >&5
1667 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1668   echo $ac_n "(cached) $ac_c" 1>&6
1669 else
1670   if test -n "$RANLIB"; then
1671   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1672 else
1673   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1674   ac_dummy="$PATH"
1675   for ac_dir in $ac_dummy; do
1676     test -z "$ac_dir" && ac_dir=.
1677     if test -f $ac_dir/$ac_word; then
1678       ac_cv_prog_RANLIB="ranlib"
1679       break
1680     fi
1681   done
1682   IFS="$ac_save_ifs"
1683   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1684 fi
1685 fi
1686 RANLIB="$ac_cv_prog_RANLIB"
1687 if test -n "$RANLIB"; then
1688   echo "$ac_t""$RANLIB" 1>&6
1689 else
1690   echo "$ac_t""no" 1>&6
1691 fi
1692
1693 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1694 if test "${with_gnu_ld+set}" = set; then
1695   withval="$with_gnu_ld"
1696   test "$withval" = no || with_gnu_ld=yes
1697 else
1698   with_gnu_ld=no
1699 fi
1700
1701 ac_prog=ld
1702 if test "$ac_cv_prog_gcc" = yes; then
1703   # Check if gcc -print-prog-name=ld gives a path.
1704   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1705 echo "configure:1706: checking for ld used by GCC" >&5
1706   ac_prog=`($CC -print-prog-name=ld) 2>&5`
1707   case "$ac_prog" in
1708     # Accept absolute paths.
1709     [\\/]* | [A-Za-z]:[\\/]*)
1710       re_direlt='/[^/][^/]*/\.\./'
1711       # Canonicalize the path of ld
1712       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1713       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1714         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1715       done
1716       test -z "$LD" && LD="$ac_prog"
1717       ;;
1718   "")
1719     # If it fails, then pretend we aren't using GCC.
1720     ac_prog=ld
1721     ;;
1722   *)
1723     # If it is relative, then search for the first ld in PATH.
1724     with_gnu_ld=unknown
1725     ;;
1726   esac
1727 elif test "$with_gnu_ld" = yes; then
1728   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1729 echo "configure:1730: checking for GNU ld" >&5
1730 else
1731   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1732 echo "configure:1733: checking for non-GNU ld" >&5
1733 fi
1734 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1735   echo $ac_n "(cached) $ac_c" 1>&6
1736 else
1737   if test -z "$LD"; then
1738   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1739   for ac_dir in $PATH; do
1740     test -z "$ac_dir" && ac_dir=.
1741     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1742       ac_cv_path_LD="$ac_dir/$ac_prog"
1743       # Check to see if the program is GNU ld.  I'd rather use --version,
1744       # but apparently some GNU ld's only accept -v.
1745       # Break only if it was the GNU/non-GNU ld that we prefer.
1746       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1747         test "$with_gnu_ld" != no && break
1748       else
1749         test "$with_gnu_ld" != yes && break
1750       fi
1751     fi
1752   done
1753   IFS="$ac_save_ifs"
1754 else
1755   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1756 fi
1757 fi
1758
1759 LD="$ac_cv_path_LD"
1760 if test -n "$LD"; then
1761   echo "$ac_t""$LD" 1>&6
1762 else
1763   echo "$ac_t""no" 1>&6
1764 fi
1765 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1766 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1767 echo "configure:1768: checking if the linker ($LD) is GNU ld" >&5
1768 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1769   echo $ac_n "(cached) $ac_c" 1>&6
1770 else
1771   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1772 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1773   ac_cv_prog_gnu_ld=yes
1774 else
1775   ac_cv_prog_gnu_ld=no
1776 fi
1777 fi
1778
1779 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1780
1781
1782 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1783 echo "configure:1784: checking for BSD-compatible nm" >&5
1784 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1785   echo $ac_n "(cached) $ac_c" 1>&6
1786 else
1787   if test -n "$NM"; then
1788   # Let the user override the test.
1789   ac_cv_path_NM="$NM"
1790 else
1791   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1792   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1793     test -z "$ac_dir" && ac_dir=.
1794     if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
1795       # Check to see if the nm accepts a BSD-compat flag.
1796       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1797       #   nm: unknown option "B" ignored
1798       if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1799         ac_cv_path_NM="$ac_dir/nm -B"
1800         break
1801       elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1802         ac_cv_path_NM="$ac_dir/nm -p"
1803         break
1804       else
1805         ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
1806         continue # so that we can try to find one that supports BSD flags
1807       fi
1808     fi
1809   done
1810   IFS="$ac_save_ifs"
1811   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1812 fi
1813 fi
1814
1815 NM="$ac_cv_path_NM"
1816 echo "$ac_t""$NM" 1>&6
1817
1818 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1819 echo "configure:1820: checking whether ln -s works" >&5
1820 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1821   echo $ac_n "(cached) $ac_c" 1>&6
1822 else
1823   rm -f conftestdata
1824 if ln -s X conftestdata 2>/dev/null
1825 then
1826   rm -f conftestdata
1827   ac_cv_prog_LN_S="ln -s"
1828 else
1829   ac_cv_prog_LN_S=ln
1830 fi
1831 fi
1832 LN_S="$ac_cv_prog_LN_S"
1833 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1834   echo "$ac_t""yes" 1>&6
1835 else
1836   echo "$ac_t""no" 1>&6
1837 fi
1838
1839
1840 # Check for any special flags to pass to ltconfig.
1841 libtool_flags="--cache-file=$cache_file"
1842 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
1843 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
1844 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
1845 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
1846 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
1847 libtool_flags="$libtool_flags --enable-dlopen"
1848
1849 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
1850 if test "${enable_libtool_lock+set}" = set; then
1851   enableval="$enable_libtool_lock"
1852   :
1853 fi
1854
1855 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
1856 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
1857
1858 # Some flags need to be propagated to the compiler or linker for good
1859 # libtool support.
1860 case "$host" in
1861 *-*-irix6*)
1862   # Find out which ABI we are using.
1863   echo '#line 1864 "configure"' > conftest.$ac_ext
1864   if { (eval echo configure:1865: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1865     case "`/usr/bin/file conftest.o`" in
1866     *32-bit*)
1867       LD="${LD-ld} -32"
1868       ;;
1869     *N32*)
1870       LD="${LD-ld} -n32"
1871       ;;
1872     *64-bit*)
1873       LD="${LD-ld} -64"
1874       ;;
1875     esac
1876   fi
1877   rm -rf conftest*
1878   ;;
1879
1880 *-*-sco3.2v5*)
1881   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
1882   SAVE_CFLAGS="$CFLAGS"
1883   CFLAGS="$CFLAGS -belf"
1884   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
1885 echo "configure:1886: checking whether the C compiler needs -belf" >&5
1886 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
1887   echo $ac_n "(cached) $ac_c" 1>&6
1888 else
1889   cat > conftest.$ac_ext <<EOF
1890 #line 1891 "configure"
1891 #include "confdefs.h"
1892
1893 int main() {
1894
1895 ; return 0; }
1896 EOF
1897 if { (eval echo configure:1898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1898   rm -rf conftest*
1899   lt_cv_cc_needs_belf=yes
1900 else
1901   echo "configure: failed program was:" >&5
1902   cat conftest.$ac_ext >&5
1903   rm -rf conftest*
1904   lt_cv_cc_needs_belf=no
1905 fi
1906 rm -f conftest*
1907 fi
1908
1909 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
1910   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
1911     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
1912     CFLAGS="$SAVE_CFLAGS"
1913   fi
1914   ;;
1915
1916
1917 esac
1918
1919
1920 # Save cache, so that ltconfig can load it
1921 cat > confcache <<\EOF
1922 # This file is a shell script that caches the results of configure
1923 # tests run on this system so they can be shared between configure
1924 # scripts and configure runs.  It is not useful on other systems.
1925 # If it contains results you don't want to keep, you may remove or edit it.
1926 #
1927 # By default, configure uses ./config.cache as the cache file,
1928 # creating it if it does not exist already.  You can give configure
1929 # the --cache-file=FILE option to use a different cache file; that is
1930 # what configure does when it calls configure scripts in
1931 # subdirectories, so they share the cache.
1932 # Giving --cache-file=/dev/null disables caching, for debugging configure.
1933 # config.status only pays attention to the cache file if you give it the
1934 # --recheck option to rerun configure.
1935 #
1936 EOF
1937 # The following way of writing the cache mishandles newlines in values,
1938 # but we know of no workaround that is simple, portable, and efficient.
1939 # So, don't put newlines in cache variables' values.
1940 # Ultrix sh set writes to stderr and can't be redirected directly,
1941 # and sets the high bit in the cache file unless we assign to the vars.
1942 (set) 2>&1 |
1943   case `(ac_space=' '; set | grep ac_space) 2>&1` in
1944   *ac_space=\ *)
1945     # `set' does not quote correctly, so add quotes (double-quote substitution
1946     # turns \\\\ into \\, and sed turns \\ into \).
1947     sed -n \
1948       -e "s/'/'\\\\''/g" \
1949       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
1950     ;;
1951   *)
1952     # `set' quotes correctly as required by POSIX, so do not add quotes.
1953     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
1954     ;;
1955   esac >> confcache
1956 if cmp -s $cache_file confcache; then
1957   :
1958 else
1959   if test -w $cache_file; then
1960     echo "updating cache $cache_file"
1961     cat confcache > $cache_file
1962   else
1963     echo "not updating unwritable cache $cache_file"
1964   fi
1965 fi
1966 rm -f confcache
1967
1968
1969 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
1970 CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
1971 LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
1972 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
1973 DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
1974 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
1975 $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
1976 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
1977
1978 # Reload cache, that may have been modified by ltconfig
1979 if test -r "$cache_file"; then
1980   echo "loading cache $cache_file"
1981   . $cache_file
1982 else
1983   echo "creating cache $cache_file"
1984   > $cache_file
1985 fi
1986
1987
1988 # This can be used to rebuild libtool when needed
1989 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
1990
1991 # Always use our own libtool.
1992 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
1993
1994 # Redirect the config.log output again, so that the ltconfig log is not
1995 # clobbered by the next message.
1996 exec 5>>./config.log
1997
1998
1999
2000
2001
2002 # Check for c++ or library specific bits that don't require linking.
2003 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2004 echo "configure:2005: checking how to run the C preprocessor" >&5
2005 # On Suns, sometimes $CPP names a directory.
2006 if test -n "$CPP" && test -d "$CPP"; then
2007   CPP=
2008 fi
2009 if test -z "$CPP"; then
2010 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2011   echo $ac_n "(cached) $ac_c" 1>&6
2012 else
2013     # This must be in double quotes, not single quotes, because CPP may get
2014   # substituted into the Makefile and "${CC-cc}" will confuse make.
2015   CPP="${CC-cc} -E"
2016   # On the NeXT, cc -E runs the code through the compiler's parser,
2017   # not just through cpp.
2018   cat > conftest.$ac_ext <<EOF
2019 #line 2020 "configure"
2020 #include "confdefs.h"
2021 #include <assert.h>
2022 Syntax Error
2023 EOF
2024 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2025 { (eval echo configure:2026: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2026 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2027 if test -z "$ac_err"; then
2028   :
2029 else
2030   echo "$ac_err" >&5
2031   echo "configure: failed program was:" >&5
2032   cat conftest.$ac_ext >&5
2033   rm -rf conftest*
2034   CPP="${CC-cc} -E -traditional-cpp"
2035   cat > conftest.$ac_ext <<EOF
2036 #line 2037 "configure"
2037 #include "confdefs.h"
2038 #include <assert.h>
2039 Syntax Error
2040 EOF
2041 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2042 { (eval echo configure:2043: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2043 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2044 if test -z "$ac_err"; then
2045   :
2046 else
2047   echo "$ac_err" >&5
2048   echo "configure: failed program was:" >&5
2049   cat conftest.$ac_ext >&5
2050   rm -rf conftest*
2051   CPP="${CC-cc} -nologo -E"
2052   cat > conftest.$ac_ext <<EOF
2053 #line 2054 "configure"
2054 #include "confdefs.h"
2055 #include <assert.h>
2056 Syntax Error
2057 EOF
2058 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2059 { (eval echo configure:2060: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2060 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2061 if test -z "$ac_err"; then
2062   :
2063 else
2064   echo "$ac_err" >&5
2065   echo "configure: failed program was:" >&5
2066   cat conftest.$ac_ext >&5
2067   rm -rf conftest*
2068   CPP=/lib/cpp
2069 fi
2070 rm -f conftest*
2071 fi
2072 rm -f conftest*
2073 fi
2074 rm -f conftest*
2075   ac_cv_prog_CPP="$CPP"
2076 fi
2077   CPP="$ac_cv_prog_CPP"
2078 else
2079   ac_cv_prog_CPP="$CPP"
2080 fi
2081 echo "$ac_t""$CPP" 1>&6
2082
2083
2084   # Sanity check that g++ is capable of dealing with v-3.
2085   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2086 echo "configure:2087: checking for g++ that will successfully compile this code" >&5
2087   cat > conftest.$ac_ext <<EOF
2088 #line 2089 "configure"
2089 #include "confdefs.h"
2090
2091   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2092     ok
2093   #endif
2094
2095 EOF
2096 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2097   egrep "ok" >/dev/null 2>&1; then
2098   rm -rf conftest*
2099   gpp_satisfactory=yes
2100 else
2101   rm -rf conftest*
2102   { echo "configure: error: "please upgrade to gcc-2.95 or above"" 1>&2; exit 1; }
2103 fi
2104 rm -f conftest*
2105
2106   echo "$ac_t""$gpp_satisfactory" 1>&6
2107
2108
2109     echo $ac_n "checking for cpu primitives directory""... $ac_c" 1>&6
2110 echo "configure:2111: checking for cpu primitives directory" >&5
2111     CPU_FLAGS=
2112     case "$target_cpu" in
2113       alpha*)
2114         cpu_include_dir="config/cpu/alpha"
2115         ;;
2116       arm*)
2117         cpu_include_dir="config/cpu/arm"
2118         ;;
2119       i386)
2120         cpu_include_dir="config/cpu/i386"
2121         ;;
2122       i486 | i586 | i686 | i786)
2123         cpu_include_dir="config/cpu/i486"
2124         ;;
2125       powerpc | rs6000)
2126         cpu_include_dir="config/cpu/powerpc"
2127         CPU_FLAGS='-mcpu=powerpc'
2128         ;;
2129       sparc64 | ultrasparc)
2130         cpu_include_dir="config/cpu/sparc/sparc64"
2131         ;;
2132       sparc*)
2133         cpu_include_dir="config/cpu/sparc/sparc32"
2134         ;;
2135       *)
2136         cpu_include_dir="config/cpu/generic"
2137         ;;
2138     esac
2139     echo "$ac_t""$cpu_include_dir" 1>&6
2140
2141
2142
2143
2144 # Enable all the crazy c++ stuff.
2145 # Check whether --enable-debug or --disable-debug was given.
2146 if test "${enable_debug+set}" = set; then
2147   enableval="$enable_debug"
2148   case "$enableval" in
2149  yes) enable_debug=yes ;;
2150  no)  enable_debug=no ;;
2151  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2152  esac
2153 else
2154   enable_debug=no
2155 fi
2156 case "$enable_debug" in
2157     yes)
2158         DEBUG_FLAGS='-O0 -ggdb'
2159         ;;
2160     no)
2161         DEBUG_FLAGS='-g'
2162         ;;
2163 esac
2164
2165
2166
2167   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2168 echo "configure:2169: checking for cstdio to use" >&5
2169   # Check whether --enable-cstdio or --disable-cstdio was given.
2170 if test "${enable_cstdio+set}" = set; then
2171   enableval="$enable_cstdio"
2172   if test x$enable_cstdio = xno; then
2173     enable_cstdio=libio
2174   fi
2175 else
2176   enable_cstdio=libio
2177 fi
2178
2179
2180   enable_cstdio_flag=$enable_cstdio
2181
2182     case x${enable_cstdio_flag} in
2183         xlibio | x | xno | xnone | xyes)
2184                 # default
2185                 CSTDIO_H=c_io_libio.h
2186                 CSTDIO_CC=c_io_libio.cc
2187                 echo "$ac_t""libio" 1>&6
2188
2189                 # see if we are on a system with libio native (ie, linux)
2190                 ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2191 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2192 echo "configure:2193: checking for libio.h" >&5
2193 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2194   echo $ac_n "(cached) $ac_c" 1>&6
2195 else
2196   cat > conftest.$ac_ext <<EOF
2197 #line 2198 "configure"
2198 #include "confdefs.h"
2199 #include <libio.h>
2200 EOF
2201 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2202 { (eval echo configure:2203: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2203 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2204 if test -z "$ac_err"; then
2205   rm -rf conftest*
2206   eval "ac_cv_header_$ac_safe=yes"
2207 else
2208   echo "$ac_err" >&5
2209   echo "configure: failed program was:" >&5
2210   cat conftest.$ac_ext >&5
2211   rm -rf conftest*
2212   eval "ac_cv_header_$ac_safe=no"
2213 fi
2214 rm -f conftest*
2215 fi
2216 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2217   echo "$ac_t""yes" 1>&6
2218   has_libio=yes
2219 else
2220   echo "$ac_t""no" 1>&6
2221 has_libio=no
2222 fi
2223
2224                 if test $has_libio = "yes"; then
2225                   BUILD_LIBIO_INCLUDE=
2226                   need_libio=no
2227                 else
2228                   BUILD_LIBIO_INCLUDE='-I../libio'
2229                   need_libio=yes
2230                 fi
2231
2232
2233                 # see if the _G_config.h header needs to be built.
2234                 # NB: This replaces the _G_CONFIG_H machinery in libio-v2
2235                 ac_safe=`echo "_G_config.h" | sed 'y%./+-%__p_%'`
2236 echo $ac_n "checking for _G_config.h""... $ac_c" 1>&6
2237 echo "configure:2238: checking for _G_config.h" >&5
2238 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2239   echo $ac_n "(cached) $ac_c" 1>&6
2240 else
2241   cat > conftest.$ac_ext <<EOF
2242 #line 2243 "configure"
2243 #include "confdefs.h"
2244 #include <_G_config.h>
2245 EOF
2246 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2247 { (eval echo configure:2248: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2248 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2249 if test -z "$ac_err"; then
2250   rm -rf conftest*
2251   eval "ac_cv_header_$ac_safe=yes"
2252 else
2253   echo "$ac_err" >&5
2254   echo "configure: failed program was:" >&5
2255   cat conftest.$ac_ext >&5
2256   rm -rf conftest*
2257   eval "ac_cv_header_$ac_safe=no"
2258 fi
2259 rm -f conftest*
2260 fi
2261 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2262   echo "$ac_t""yes" 1>&6
2263   has_gconf_h=yes
2264 else
2265   echo "$ac_t""no" 1>&6
2266 has_gconf_h=no
2267 fi
2268
2269
2270
2271 if test "$has_gconf_h" = no; then
2272   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE=
2273   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE='#'
2274 else
2275   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE='#'
2276   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE=
2277 fi
2278                 ;;
2279         xwince)
2280                 CSTDIO_H=c_io_wince.h
2281                 CSTDIO_CC=c_io_wince.cc
2282                 echo "$ac_t""wince" 1>&6
2283
2284                 need_libio=no
2285                 BUILD_LIBIO_INCLUDE=
2286
2287                 ;;
2288         *)
2289                 echo "$enable_cstdio is an unknown io package" 1>&2
2290                 exit 1
2291                 ;;
2292   esac
2293
2294
2295
2296
2297 if test "$need_libio" = yes; then
2298   GLIBCPP_NEED_LIBIO_TRUE=
2299   GLIBCPP_NEED_LIBIO_FALSE='#'
2300 else
2301   GLIBCPP_NEED_LIBIO_TRUE='#'
2302   GLIBCPP_NEED_LIBIO_FALSE=
2303 fi
2304
2305
2306   # Check whether --enable-long-long or --disable-long-long was given.
2307 if test "${enable_long_long+set}" = set; then
2308   enableval="$enable_long_long"
2309     case "$enableval" in
2310    yes) enable_long_long=yes ;;
2311    no)  enable_long_long=no ;;
2312    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2313    esac
2314 else
2315   enable_long_long=yes
2316 fi
2317
2318   # Check for the existance of functions used if long long is enabled.
2319   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2320 echo "configure:2321: checking for strtoll" >&5
2321 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2322   echo $ac_n "(cached) $ac_c" 1>&6
2323 else
2324   cat > conftest.$ac_ext <<EOF
2325 #line 2326 "configure"
2326 #include "confdefs.h"
2327 /* System header to define __stub macros and hopefully few prototypes,
2328     which can conflict with char strtoll(); below.  */
2329 #include <assert.h>
2330 /* Override any gcc2 internal prototype to avoid an error.  */
2331 /* We use char because int might match the return type of a gcc2
2332     builtin and then its argument prototype would still apply.  */
2333 char strtoll();
2334
2335 int main() {
2336
2337 /* The GNU C library defines this for functions which it implements
2338     to always fail with ENOSYS.  Some functions are actually named
2339     something starting with __ and the normal name is an alias.  */
2340 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2341 choke me
2342 #else
2343 strtoll();
2344 #endif
2345
2346 ; return 0; }
2347 EOF
2348 if { (eval echo configure:2349: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2349   rm -rf conftest*
2350   eval "ac_cv_func_strtoll=yes"
2351 else
2352   echo "configure: failed program was:" >&5
2353   cat conftest.$ac_ext >&5
2354   rm -rf conftest*
2355   eval "ac_cv_func_strtoll=no"
2356 fi
2357 rm -f conftest*
2358 fi
2359
2360 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2361   echo "$ac_t""yes" 1>&6
2362   :
2363 else
2364   echo "$ac_t""no" 1>&6
2365 ac_strtoll=no
2366 fi
2367
2368   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2369 echo "configure:2370: checking for strtoull" >&5
2370 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2371   echo $ac_n "(cached) $ac_c" 1>&6
2372 else
2373   cat > conftest.$ac_ext <<EOF
2374 #line 2375 "configure"
2375 #include "confdefs.h"
2376 /* System header to define __stub macros and hopefully few prototypes,
2377     which can conflict with char strtoull(); below.  */
2378 #include <assert.h>
2379 /* Override any gcc2 internal prototype to avoid an error.  */
2380 /* We use char because int might match the return type of a gcc2
2381     builtin and then its argument prototype would still apply.  */
2382 char strtoull();
2383
2384 int main() {
2385
2386 /* The GNU C library defines this for functions which it implements
2387     to always fail with ENOSYS.  Some functions are actually named
2388     something starting with __ and the normal name is an alias.  */
2389 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2390 choke me
2391 #else
2392 strtoull();
2393 #endif
2394
2395 ; return 0; }
2396 EOF
2397 if { (eval echo configure:2398: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2398   rm -rf conftest*
2399   eval "ac_cv_func_strtoull=yes"
2400 else
2401   echo "configure: failed program was:" >&5
2402   cat conftest.$ac_ext >&5
2403   rm -rf conftest*
2404   eval "ac_cv_func_strtoull=no"
2405 fi
2406 rm -f conftest*
2407 fi
2408
2409 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2410   echo "$ac_t""yes" 1>&6
2411   :
2412 else
2413   echo "$ac_t""no" 1>&6
2414 ac_strtoull=no
2415 fi
2416
2417
2418   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2419 echo "configure:2420: checking for enabled long long" >&5
2420   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2421     enable_long_long=no;
2422   fi;
2423   echo "$ac_t""$enable_long_long" 1>&6
2424
2425     case "$enable_long_long" in
2426     yes)  cat >> confdefs.h <<\EOF
2427 #define _GLIBCPP_USE_LONG_LONG 1
2428 EOF
2429
2430           ;;
2431   esac
2432
2433 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2434 echo "configure:2435: checking for enabled cshadow headers" >&5
2435 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2436 if test "${enable_cshadow_headers+set}" = set; then
2437   enableval="$enable_cshadow_headers"
2438   case "$enableval" in
2439  yes) enable_cshadow_headers=yes
2440         ;;
2441  no)  enable_cshadow_headers=no
2442         ;;
2443  *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
2444         ;;
2445  esac
2446 else
2447   enable_cshadow_headers=no
2448 fi
2449 echo "$ac_t""$enable_cshadow_headers" 1>&6
2450 case "$enable_cshadow_headers" in
2451     yes)
2452         CSHADOWFLAGS="-D_GNU_SOURCE"
2453         CSHADOW_INCLUDES=" -I$srcdir/shadow -I$blddir/cshadow"
2454         ;;
2455     no)
2456         CSHADOWFLAGS=""
2457         CSHADOW_INCLUDES=""
2458         ;;
2459 esac
2460
2461
2462
2463
2464
2465 if test "$enable_cshadow_headers" = yes; then
2466   GLIBCPP_USE_CSHADOW_TRUE=
2467   GLIBCPP_USE_CSHADOW_FALSE='#'
2468 else
2469   GLIBCPP_USE_CSHADOW_TRUE='#'
2470   GLIBCPP_USE_CSHADOW_FALSE=
2471 fi
2472
2473
2474       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
2475 echo "configure:2476: checking for threads package to use" >&5
2476   # Check whether --enable-threads or --disable-threads was given.
2477 if test "${enable_threads+set}" = set; then
2478   enableval="$enable_threads"
2479   if test x$enable_threads = xno; then
2480     enable_threads=''
2481   fi
2482 else
2483   enable_threads=''
2484 fi
2485
2486
2487   enable_threads_flag=$enable_threads
2488
2489     case x${enable_threads_flag} in
2490         x | xno | xnone)
2491                 # No threads
2492                 target_thread_file='single'
2493                 ;;
2494         xyes)
2495                 # default
2496                 target_thread_file=''
2497                 ;;
2498         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
2499         xsolaris | xwin32 | xdce | xvxworks)
2500                 target_thread_file=$enable_threads_flag
2501                 ;;
2502         *)
2503                 echo "$enable_threads is an unknown thread package" 1>&2
2504                 exit 1
2505                 ;;
2506   esac
2507
2508     case "$target_thread_file" in
2509     no | none | single)
2510       THREADS=none
2511       ;;
2512     posix | pthreads)
2513       THREADS=posix
2514       case "$host" in
2515         *-*-linux*)
2516         ;;
2517       esac
2518       ;;
2519     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
2520       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
2521       ;;
2522     *)
2523       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
2524       ;;
2525   esac
2526   echo "$ac_t""$THREADS" 1>&6
2527
2528   THREADLIBS=
2529   THREADINCS=
2530   THREADDEPS=
2531   THREADOBJS=
2532   THREADH=
2533   THREADSPEC=
2534   case "$THREADS" in
2535     posix)
2536       ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
2537 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
2538 echo "configure:2539: checking for pthread.h" >&5
2539 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2540   echo $ac_n "(cached) $ac_c" 1>&6
2541 else
2542   cat > conftest.$ac_ext <<EOF
2543 #line 2544 "configure"
2544 #include "confdefs.h"
2545 #include <pthread.h>
2546 EOF
2547 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2548 { (eval echo configure:2549: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2549 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2550 if test -z "$ac_err"; then
2551   rm -rf conftest*
2552   eval "ac_cv_header_$ac_safe=yes"
2553 else
2554   echo "$ac_err" >&5
2555   echo "configure: failed program was:" >&5
2556   cat conftest.$ac_ext >&5
2557   rm -rf conftest*
2558   eval "ac_cv_header_$ac_safe=no"
2559 fi
2560 rm -f conftest*
2561 fi
2562 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2563   echo "$ac_t""yes" 1>&6
2564   have_pthread_h=yes
2565 else
2566   echo "$ac_t""no" 1>&6
2567 have_pthread_h=
2568 fi
2569
2570       THREADLIBS=-lpthread
2571       THREADSPEC=-lpthread
2572                   THREADH=threads-posix.h
2573       ;;
2574     none)
2575                   THREADH=threads-no.h
2576       ;;
2577   esac
2578
2579
2580
2581
2582
2583
2584 #GLIBCPP_ENABLE_RELIBGCC([../..])
2585 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
2586 if test "${enable_cxx_flags+set}" = set; then
2587   enableval="$enable_cxx_flags"
2588   case "x$enableval" in
2589  xyes)   { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
2590  xno|x)  enable_cxx_flags='' ;;
2591  *)      enable_cxx_flags="$enableval" ;;
2592  esac
2593 else
2594   enable_cxx_flags='none'
2595 fi
2596 if test "$enable_cxx_flags" = "none"; then enable_cxx_flags=''; fi
2597 if test -n "$enable_cxx_flags"; then
2598     for f in $enable_cxx_flags; do
2599         case "$f" in
2600             -fhonor-std)  ;;
2601             -*)  ;;
2602             *)   # and we're trying to pass /what/ exactly?
2603                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
2604         esac
2605     done
2606 fi
2607 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2608
2609
2610
2611
2612 if test -n "$with_cross_host"; then
2613
2614   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
2615   # may not work correctly, because the compiler may not be able to
2616   # link executables.
2617
2618   xcompiling=1
2619   NATIVE=no
2620   # If Canadian cross, then don't pick up tools from the build
2621   # directory.
2622   if test "$build" != "$with_cross_host"; then
2623     CANADIAN=yes
2624     NULL_TARGET=yes
2625   else
2626     CANADIAN=no
2627     NULL_TARGET=no
2628   fi
2629
2630   case "$target_alias" in
2631     *-wince-*)
2632         # Configure for Microsoft Windows CE, or whatever they are
2633         # currently calling it.
2634         cat >> confdefs.h <<\EOF
2635 #define HAVE_FLOAT_H 1
2636 EOF
2637
2638
2639         cat >> confdefs.h <<\EOF
2640 #define HAVE__FINITE 1
2641 EOF
2642
2643         cat >> confdefs.h <<\EOF
2644 #define HAVE__ISNAN 1
2645 EOF
2646
2647         cat >> confdefs.h <<\EOF
2648 #define HAVE__COPYSIGN 1
2649 EOF
2650
2651         cat >> confdefs.h <<\EOF
2652 #define HAVE__FPCLASS 1
2653 EOF
2654
2655         cat >> confdefs.h <<\EOF
2656 #define HAVE_MODF 1
2657 EOF
2658
2659
2660         ctype_include_dir="config/wince"
2661
2662
2663         cat >> confdefs.h <<\EOF
2664 #define _GLIBCPP_NEED_MBSTATE_T 1
2665 EOF
2666
2667
2668         cat >> confdefs.h <<\EOF
2669 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2670 EOF
2671
2672         cat >> confdefs.h <<\EOF
2673 #define _GLIBCPP_BUGGY_COMPLEX 1
2674 EOF
2675
2676         ;;
2677     *)
2678         # We assume newlib.  This lets us hard-code the functions we know
2679         # we'll have.
2680         cat >> confdefs.h <<\EOF
2681 #define HAVE_FINITE 1
2682 EOF
2683
2684         cat >> confdefs.h <<\EOF
2685 #define HAVE_ISNAN 1
2686 EOF
2687
2688         cat >> confdefs.h <<\EOF
2689 #define HAVE_ISNANF 1
2690 EOF
2691
2692         cat >> confdefs.h <<\EOF
2693 #define HAVE_ISINF 1
2694 EOF
2695
2696         cat >> confdefs.h <<\EOF
2697 #define HAVE_ISINFF 1
2698 EOF
2699
2700
2701         ctype_include_dir="config/newlib"
2702
2703
2704         cat >> confdefs.h <<\EOF
2705 #define _GLIBCPP_NEED_MBSTATE_T 1
2706 EOF
2707
2708
2709         cat >> confdefs.h <<\EOF
2710 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2711 EOF
2712
2713         cat >> confdefs.h <<\EOF
2714 #define _GLIBCPP_BUGGY_COMPLEX 1
2715 EOF
2716
2717         # need to ceck for faster f versions of math functions, ie sinf?
2718         ;;
2719   esac
2720 else
2721
2722   # We are being configured natively. We can do more elaborate tests
2723   # that include AC_TRY_COMPILE now, as the linker is assumed to be
2724   # working.
2725
2726   xcompiling=0
2727   NATIVE=yes
2728   CANADIAN=no
2729   NULL_TARGET=no
2730
2731   # Check for available headers.
2732   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
2733   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h
2734 do
2735 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
2736 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
2737 echo "configure:2738: checking for $ac_hdr" >&5
2738 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2739   echo $ac_n "(cached) $ac_c" 1>&6
2740 else
2741   cat > conftest.$ac_ext <<EOF
2742 #line 2743 "configure"
2743 #include "confdefs.h"
2744 #include <$ac_hdr>
2745 EOF
2746 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2747 { (eval echo configure:2748: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2748 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2749 if test -z "$ac_err"; then
2750   rm -rf conftest*
2751   eval "ac_cv_header_$ac_safe=yes"
2752 else
2753   echo "$ac_err" >&5
2754   echo "configure: failed program was:" >&5
2755   cat conftest.$ac_ext >&5
2756   rm -rf conftest*
2757   eval "ac_cv_header_$ac_safe=no"
2758 fi
2759 rm -f conftest*
2760 fi
2761 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2762   echo "$ac_t""yes" 1>&6
2763     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
2764   cat >> confdefs.h <<EOF
2765 #define $ac_tr_hdr 1
2766 EOF
2767
2768 else
2769   echo "$ac_t""no" 1>&6
2770 fi
2771 done
2772
2773
2774
2775   # All these tests are for C++; save the language and the compiler flags.
2776   # The CXXFLAGS thing is suspicious, but based on similar bits
2777   # found in GLIBCPP_CONFIGURE.
2778
2779   ac_ext=C
2780 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2781 ac_cpp='$CXXCPP $CPPFLAGS'
2782 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2783 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2784 cross_compiling=$ac_cv_prog_cxx_cross
2785
2786   ac_test_CXXFLAGS="${CXXFLAGS+set}"
2787   ac_save_CXXFLAGS="$CXXFLAGS"
2788   WERROR='-Werror'
2789
2790   # Check for pragma system_header.
2791   echo $ac_n "checking for g++ that supports pragma system_header""... $ac_c" 1>&6
2792 echo "configure:2793: checking for g++ that supports pragma system_header" >&5
2793   CXXFLAGS='-Wunknown-pragmas -Werror'
2794   cat > conftest.$ac_ext <<EOF
2795 #line 2796 "configure"
2796 #include "confdefs.h"
2797 #pragma system_header
2798 int main() {
2799 int foo;
2800
2801 ; return 0; }
2802 EOF
2803 if { (eval echo configure:2804: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2804   rm -rf conftest*
2805   ac_newpragma=yes
2806 else
2807   echo "configure: failed program was:" >&5
2808   cat conftest.$ac_ext >&5
2809   rm -rf conftest*
2810   ac_newpragma=no
2811 fi
2812 rm -f conftest*
2813   if test "$ac_test_CXXFLAGS" = set; then
2814     CXXFLAGS="$ac_save_CXXFLAGS"
2815   else
2816     # this is the suspicious part
2817     CXXFLAGS=''
2818   fi
2819   if test "$ac_newpragma" = "no"; then
2820     WERROR="$WERROR -Wno-unknown-pragmas"
2821   fi
2822   echo "$ac_t""$ac_newpragma" 1>&6
2823
2824   # Check for more sophisticated diagnostic control.
2825   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
2826 echo "configure:2827: checking for g++ that supports -fdiagnostics-show-location=once" >&5
2827   CXXFLAGS='-fdiagnostics-show-location=once'
2828   cat > conftest.$ac_ext <<EOF
2829 #line 2830 "configure"
2830 #include "confdefs.h"
2831
2832 int main() {
2833 int foo;
2834
2835 ; return 0; }
2836 EOF
2837 if { (eval echo configure:2838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2838   rm -rf conftest*
2839   ac_gabydiags=yes
2840 else
2841   echo "configure: failed program was:" >&5
2842   cat conftest.$ac_ext >&5
2843   rm -rf conftest*
2844   ac_gabydiags=no
2845 fi
2846 rm -f conftest*
2847   if test "$ac_test_CXXFLAGS" = set; then
2848     CXXFLAGS="$ac_save_CXXFLAGS"
2849   else
2850     # this is the suspicious part
2851     CXXFLAGS=''
2852   fi
2853   if test "$ac_gabydiags" = "yes"; then
2854     WFMT_FLAGS='-fdiagnostics-show-location=once'
2855   fi
2856   echo "$ac_t""$ac_gabydiags" 1>&6
2857
2858   # Check for -ffunction-sections -fdata-sections
2859   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
2860 echo "configure:2861: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
2861   CXXFLAGS='-ffunction-sections -fdata-sections'
2862   cat > conftest.$ac_ext <<EOF
2863 #line 2864 "configure"
2864 #include "confdefs.h"
2865
2866 int main() {
2867 int foo;
2868
2869 ; return 0; }
2870 EOF
2871 if { (eval echo configure:2872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2872   rm -rf conftest*
2873   ac_fdsections=yes
2874 else
2875   echo "configure: failed program was:" >&5
2876   cat conftest.$ac_ext >&5
2877   rm -rf conftest*
2878   ac_fdsections=no
2879 fi
2880 rm -f conftest*
2881   if test "$ac_test_CXXFLAGS" = set; then
2882     CXXFLAGS="$ac_save_CXXFLAGS"
2883   else
2884     # this is the suspicious part
2885     CXXFLAGS=''
2886   fi
2887   if test "$ac_fdsections" = "yes"; then
2888     SECTION_FLAGS='-ffunction-sections -fdata-sections'
2889   fi
2890   echo "$ac_t""$ac_fdsections" 1>&6
2891
2892   ac_ext=c
2893 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2894 ac_cpp='$CPP $CPPFLAGS'
2895 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2896 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2897 cross_compiling=$ac_cv_prog_cc_cross
2898
2899
2900
2901
2902
2903
2904   # All these tests are for C++; save the language and the compiler flags.
2905   # The CXXFLAGS thing is suspicious, but based on similar bits
2906   # found in GLIBCPP_CONFIGURE.
2907
2908   ac_ext=C
2909 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2910 ac_cpp='$CXXCPP $CPPFLAGS'
2911 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2912 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2913 cross_compiling=$ac_cv_prog_cxx_cross
2914
2915
2916   # Check for -Wl,--gc-sections
2917   echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
2918 echo "configure:2919: checking for ld that supports -Wl,--gc-sections" >&5
2919   CXXFLAGS='-Wl,--gc-sections'
2920   if test "$cross_compiling" = yes; then
2921   ac_sectionLDflags=yes
2922 else
2923   cat > conftest.$ac_ext <<EOF
2924 #line 2925 "configure"
2925 #include "confdefs.h"
2926 #ifdef __cplusplus
2927 extern "C" void exit(int);
2928 #endif
2929
2930    int main()
2931    {
2932      try { throw 1; }
2933      catch (...) { };
2934      return 0;
2935    }
2936
2937 EOF
2938 if { (eval echo configure:2939: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
2939 then
2940   ac_sectionLDflags=yes
2941 else
2942   echo "configure: failed program was:" >&5
2943   cat conftest.$ac_ext >&5
2944   rm -fr conftest*
2945   ac_sectionLFflags=no
2946 fi
2947 rm -fr conftest*
2948 fi
2949
2950   if test "$ac_test_CXXFLAGS" = set; then
2951     CXXFLAGS="$ac_save_CXXFLAGS"
2952   else
2953     # this is the suspicious part
2954     CXXFLAGS=''
2955   fi
2956   if test "$ac_sectionLDflags" = "yes"; then
2957     SECTION_LDFLAGS='-Wl,--gc-sections'
2958   fi
2959   echo "$ac_t""$ac_sectionLDflags" 1>&6
2960
2961   ac_ext=c
2962 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2963 ac_cpp='$CPP $CPPFLAGS'
2964 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2965 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2966 cross_compiling=$ac_cv_prog_cc_cross
2967
2968
2969
2970
2971
2972   ac_ext=C
2973 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2974 ac_cpp='$CXXCPP $CPPFLAGS'
2975 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2976 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2977 cross_compiling=$ac_cv_prog_cxx_cross
2978
2979   echo $ac_n "checking for __builtin_acos""... $ac_c" 1>&6
2980 echo "configure:2981: checking for __builtin_acos" >&5
2981   cat > conftest.$ac_ext <<EOF
2982 #line 2983 "configure"
2983 #include "confdefs.h"
2984 #include <math.h>
2985 int main() {
2986  __builtin_acos(0.0);
2987 ; return 0; }
2988 EOF
2989 if { (eval echo configure:2990: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2990   rm -rf conftest*
2991   use_builtin_acos=yes
2992 else
2993   echo "configure: failed program was:" >&5
2994   cat conftest.$ac_ext >&5
2995   rm -rf conftest*
2996   use_builtin_acos=no
2997 fi
2998 rm -f conftest*
2999   echo "$ac_t""$use_builtin_acos" 1>&6
3000   if test $use_builtin_acos = "yes"; then
3001     cat >> confdefs.h <<\EOF
3002 #define HAVE_BUILTIN_ACOS 1
3003 EOF
3004
3005   fi
3006   echo $ac_n "checking for __builtin_acosf""... $ac_c" 1>&6
3007 echo "configure:3008: checking for __builtin_acosf" >&5
3008   cat > conftest.$ac_ext <<EOF
3009 #line 3010 "configure"
3010 #include "confdefs.h"
3011 #include <math.h>
3012 int main() {
3013  __builtin_acosf(0.0);
3014 ; return 0; }
3015 EOF
3016 if { (eval echo configure:3017: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3017   rm -rf conftest*
3018   use_builtin_acosf=yes
3019 else
3020   echo "configure: failed program was:" >&5
3021   cat conftest.$ac_ext >&5
3022   rm -rf conftest*
3023   use_builtin_acosf=no
3024 fi
3025 rm -f conftest*
3026   echo "$ac_t""$use_builtin_acosf" 1>&6
3027   if test $use_builtin_acosf = "yes"; then
3028     cat >> confdefs.h <<\EOF
3029 #define HAVE_BUILTIN_ACOSF 1
3030 EOF
3031
3032   fi
3033   echo $ac_n "checking for __builtin_acosl""... $ac_c" 1>&6
3034 echo "configure:3035: checking for __builtin_acosl" >&5
3035   cat > conftest.$ac_ext <<EOF
3036 #line 3037 "configure"
3037 #include "confdefs.h"
3038 #include <math.h>
3039 int main() {
3040  __builtin_acosl(0.0);
3041 ; return 0; }
3042 EOF
3043 if { (eval echo configure:3044: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3044   rm -rf conftest*
3045   use_builtin_acosl=yes
3046 else
3047   echo "configure: failed program was:" >&5
3048   cat conftest.$ac_ext >&5
3049   rm -rf conftest*
3050   use_builtin_acosl=no
3051 fi
3052 rm -f conftest*
3053   echo "$ac_t""$use_builtin_acosl" 1>&6
3054   if test $use_builtin_acosl = "yes"; then
3055     cat >> confdefs.h <<\EOF
3056 #define HAVE_BUILTIN_ACOSL 1
3057 EOF
3058
3059   fi
3060   echo $ac_n "checking for __builtin_asin""... $ac_c" 1>&6
3061 echo "configure:3062: checking for __builtin_asin" >&5
3062   cat > conftest.$ac_ext <<EOF
3063 #line 3064 "configure"
3064 #include "confdefs.h"
3065 #include <math.h>
3066 int main() {
3067  __builtin_asin(0.0);
3068 ; return 0; }
3069 EOF
3070 if { (eval echo configure:3071: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3071   rm -rf conftest*
3072   use_builtin_asin=yes
3073 else
3074   echo "configure: failed program was:" >&5
3075   cat conftest.$ac_ext >&5
3076   rm -rf conftest*
3077   use_builtin_asin=no
3078 fi
3079 rm -f conftest*
3080   echo "$ac_t""$use_builtin_asin" 1>&6
3081   if test $use_builtin_asin = "yes"; then
3082     cat >> confdefs.h <<\EOF
3083 #define HAVE_BUILTIN_ASIN 1
3084 EOF
3085
3086   fi
3087   echo $ac_n "checking for __builtin_asinf""... $ac_c" 1>&6
3088 echo "configure:3089: checking for __builtin_asinf" >&5
3089   cat > conftest.$ac_ext <<EOF
3090 #line 3091 "configure"
3091 #include "confdefs.h"
3092 #include <math.h>
3093 int main() {
3094  __builtin_asinf(0.0);
3095 ; return 0; }
3096 EOF
3097 if { (eval echo configure:3098: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3098   rm -rf conftest*
3099   use_builtin_asinf=yes
3100 else
3101   echo "configure: failed program was:" >&5
3102   cat conftest.$ac_ext >&5
3103   rm -rf conftest*
3104   use_builtin_asinf=no
3105 fi
3106 rm -f conftest*
3107   echo "$ac_t""$use_builtin_asinf" 1>&6
3108   if test $use_builtin_asinf = "yes"; then
3109     cat >> confdefs.h <<\EOF
3110 #define HAVE_BUILTIN_ASINF 1
3111 EOF
3112
3113   fi
3114   echo $ac_n "checking for __builtin_asinl""... $ac_c" 1>&6
3115 echo "configure:3116: checking for __builtin_asinl" >&5
3116   cat > conftest.$ac_ext <<EOF
3117 #line 3118 "configure"
3118 #include "confdefs.h"
3119 #include <math.h>
3120 int main() {
3121  __builtin_asinl(0.0);
3122 ; return 0; }
3123 EOF
3124 if { (eval echo configure:3125: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3125   rm -rf conftest*
3126   use_builtin_asinl=yes
3127 else
3128   echo "configure: failed program was:" >&5
3129   cat conftest.$ac_ext >&5
3130   rm -rf conftest*
3131   use_builtin_asinl=no
3132 fi
3133 rm -f conftest*
3134   echo "$ac_t""$use_builtin_asinl" 1>&6
3135   if test $use_builtin_asinl = "yes"; then
3136     cat >> confdefs.h <<\EOF
3137 #define HAVE_BUILTIN_ASINL 1
3138 EOF
3139
3140   fi
3141   echo $ac_n "checking for __builtin_atan""... $ac_c" 1>&6
3142 echo "configure:3143: checking for __builtin_atan" >&5
3143   cat > conftest.$ac_ext <<EOF
3144 #line 3145 "configure"
3145 #include "confdefs.h"
3146 #include <math.h>
3147 int main() {
3148  __builtin_atan(0.0);
3149 ; return 0; }
3150 EOF
3151 if { (eval echo configure:3152: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3152   rm -rf conftest*
3153   use_builtin_atan=yes
3154 else
3155   echo "configure: failed program was:" >&5
3156   cat conftest.$ac_ext >&5
3157   rm -rf conftest*
3158   use_builtin_atan=no
3159 fi
3160 rm -f conftest*
3161   echo "$ac_t""$use_builtin_atan" 1>&6
3162   if test $use_builtin_atan = "yes"; then
3163     cat >> confdefs.h <<\EOF
3164 #define HAVE_BUILTIN_ATAN 1
3165 EOF
3166
3167   fi
3168   echo $ac_n "checking for __builtin_atanf""... $ac_c" 1>&6
3169 echo "configure:3170: checking for __builtin_atanf" >&5
3170   cat > conftest.$ac_ext <<EOF
3171 #line 3172 "configure"
3172 #include "confdefs.h"
3173 #include <math.h>
3174 int main() {
3175  __builtin_atanf(0.0);
3176 ; return 0; }
3177 EOF
3178 if { (eval echo configure:3179: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3179   rm -rf conftest*
3180   use_builtin_atanf=yes
3181 else
3182   echo "configure: failed program was:" >&5
3183   cat conftest.$ac_ext >&5
3184   rm -rf conftest*
3185   use_builtin_atanf=no
3186 fi
3187 rm -f conftest*
3188   echo "$ac_t""$use_builtin_atanf" 1>&6
3189   if test $use_builtin_atanf = "yes"; then
3190     cat >> confdefs.h <<\EOF
3191 #define HAVE_BUILTIN_ATANF 1
3192 EOF
3193
3194   fi
3195   echo $ac_n "checking for __builtin_atanl""... $ac_c" 1>&6
3196 echo "configure:3197: checking for __builtin_atanl" >&5
3197   cat > conftest.$ac_ext <<EOF
3198 #line 3199 "configure"
3199 #include "confdefs.h"
3200 #include <math.h>
3201 int main() {
3202  __builtin_atanl(0.0);
3203 ; return 0; }
3204 EOF
3205 if { (eval echo configure:3206: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3206   rm -rf conftest*
3207   use_builtin_atanl=yes
3208 else
3209   echo "configure: failed program was:" >&5
3210   cat conftest.$ac_ext >&5
3211   rm -rf conftest*
3212   use_builtin_atanl=no
3213 fi
3214 rm -f conftest*
3215   echo "$ac_t""$use_builtin_atanl" 1>&6
3216   if test $use_builtin_atanl = "yes"; then
3217     cat >> confdefs.h <<\EOF
3218 #define HAVE_BUILTIN_ATANL 1
3219 EOF
3220
3221   fi
3222   echo $ac_n "checking for __builtin_atan2""... $ac_c" 1>&6
3223 echo "configure:3224: checking for __builtin_atan2" >&5
3224   cat > conftest.$ac_ext <<EOF
3225 #line 3226 "configure"
3226 #include "confdefs.h"
3227 #include <math.h>
3228 int main() {
3229  __builtin_atan2(0.0, 0.0);
3230 ; return 0; }
3231 EOF
3232 if { (eval echo configure:3233: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3233   rm -rf conftest*
3234   use_builtin_atan2=yes
3235 else
3236   echo "configure: failed program was:" >&5
3237   cat conftest.$ac_ext >&5
3238   rm -rf conftest*
3239   use_builtin_atan2=no
3240 fi
3241 rm -f conftest*
3242   echo "$ac_t""$use_builtin_atan2" 1>&6
3243   if test $use_builtin_atan2 = "yes"; then
3244     cat >> confdefs.h <<\EOF
3245 #define HAVE_BUILTIN_ATAN2 1
3246 EOF
3247
3248   fi
3249   echo $ac_n "checking for __builtin_atan2f""... $ac_c" 1>&6
3250 echo "configure:3251: checking for __builtin_atan2f" >&5
3251   cat > conftest.$ac_ext <<EOF
3252 #line 3253 "configure"
3253 #include "confdefs.h"
3254 #include <math.h>
3255 int main() {
3256  __builtin_atan2f(0.0, 0.0);
3257 ; return 0; }
3258 EOF
3259 if { (eval echo configure:3260: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3260   rm -rf conftest*
3261   use_builtin_atan2f=yes
3262 else
3263   echo "configure: failed program was:" >&5
3264   cat conftest.$ac_ext >&5
3265   rm -rf conftest*
3266   use_builtin_atan2f=no
3267 fi
3268 rm -f conftest*
3269   echo "$ac_t""$use_builtin_atan2f" 1>&6
3270   if test $use_builtin_atan2f = "yes"; then
3271     cat >> confdefs.h <<\EOF
3272 #define HAVE_BUILTIN_ATAN2F 1
3273 EOF
3274
3275   fi
3276   echo $ac_n "checking for __builtin_atan2l""... $ac_c" 1>&6
3277 echo "configure:3278: checking for __builtin_atan2l" >&5
3278   cat > conftest.$ac_ext <<EOF
3279 #line 3280 "configure"
3280 #include "confdefs.h"
3281 #include <math.h>
3282 int main() {
3283  __builtin_atan2l(0.0, 0.0);
3284 ; return 0; }
3285 EOF
3286 if { (eval echo configure:3287: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3287   rm -rf conftest*
3288   use_builtin_atan2l=yes
3289 else
3290   echo "configure: failed program was:" >&5
3291   cat conftest.$ac_ext >&5
3292   rm -rf conftest*
3293   use_builtin_atan2l=no
3294 fi
3295 rm -f conftest*
3296   echo "$ac_t""$use_builtin_atan2l" 1>&6
3297   if test $use_builtin_atan2l = "yes"; then
3298     cat >> confdefs.h <<\EOF
3299 #define HAVE_BUILTIN_ATAN2L 1
3300 EOF
3301
3302   fi
3303   echo $ac_n "checking for __builtin_ceil""... $ac_c" 1>&6
3304 echo "configure:3305: checking for __builtin_ceil" >&5
3305   cat > conftest.$ac_ext <<EOF
3306 #line 3307 "configure"
3307 #include "confdefs.h"
3308 #include <math.h>
3309 int main() {
3310  __builtin_fceil(0.0);
3311 ; return 0; }
3312 EOF
3313 if { (eval echo configure:3314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3314   rm -rf conftest*
3315   use_builtin_ceil=yes
3316 else
3317   echo "configure: failed program was:" >&5
3318   cat conftest.$ac_ext >&5
3319   rm -rf conftest*
3320   use_builtin_ceil=no
3321 fi
3322 rm -f conftest*
3323   echo "$ac_t""$use_builtin_ceil" 1>&6
3324   if test $use_builtin_ceil = "yes"; then
3325     cat >> confdefs.h <<\EOF
3326 #define HAVE_BUILTIN_CEIL 1
3327 EOF
3328
3329   fi
3330   echo $ac_n "checking for __builtin_ceilf""... $ac_c" 1>&6
3331 echo "configure:3332: checking for __builtin_ceilf" >&5
3332   cat > conftest.$ac_ext <<EOF
3333 #line 3334 "configure"
3334 #include "confdefs.h"
3335 #include <math.h>
3336 int main() {
3337  __builtin_ceilf(0.0);
3338 ; return 0; }
3339 EOF
3340 if { (eval echo configure:3341: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3341   rm -rf conftest*
3342   use_builtin_ceilf=yes
3343 else
3344   echo "configure: failed program was:" >&5
3345   cat conftest.$ac_ext >&5
3346   rm -rf conftest*
3347   use_builtin_ceilf=no
3348 fi
3349 rm -f conftest*
3350   echo "$ac_t""$use_builtin_ceilf" 1>&6
3351   if test $use_builtin_ceilf = "yes"; then
3352     cat >> confdefs.h <<\EOF
3353 #define HAVE_BUILTIN_CEILF 1
3354 EOF
3355
3356   fi
3357   echo $ac_n "checking for __builtin_ceill""... $ac_c" 1>&6
3358 echo "configure:3359: checking for __builtin_ceill" >&5
3359   cat > conftest.$ac_ext <<EOF
3360 #line 3361 "configure"
3361 #include "confdefs.h"
3362 #include <math.h>
3363 int main() {
3364  __builtin_ceill(0.0);
3365 ; return 0; }
3366 EOF
3367 if { (eval echo configure:3368: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3368   rm -rf conftest*
3369   use_builtin_ceill=yes
3370 else
3371   echo "configure: failed program was:" >&5
3372   cat conftest.$ac_ext >&5
3373   rm -rf conftest*
3374   use_builtin_ceill=no
3375 fi
3376 rm -f conftest*
3377   echo "$ac_t""$use_builtin_ceill" 1>&6
3378   if test $use_builtin_ceill = "yes"; then
3379     cat >> confdefs.h <<\EOF
3380 #define HAVE_BUILTIN_CEILL 1
3381 EOF
3382
3383   fi
3384   echo $ac_n "checking for __builtin_cos""... $ac_c" 1>&6
3385 echo "configure:3386: checking for __builtin_cos" >&5
3386   cat > conftest.$ac_ext <<EOF
3387 #line 3388 "configure"
3388 #include "confdefs.h"
3389 #include <math.h>
3390 int main() {
3391  __builtin_cos(0.0);
3392 ; return 0; }
3393 EOF
3394 if { (eval echo configure:3395: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3395   rm -rf conftest*
3396   use_builtin_cos=yes
3397 else
3398   echo "configure: failed program was:" >&5
3399   cat conftest.$ac_ext >&5
3400   rm -rf conftest*
3401   use_builtin_cos=no
3402 fi
3403 rm -f conftest*
3404   echo "$ac_t""$use_builtin_cos" 1>&6
3405   if test $use_builtin_cos = "yes"; then
3406     cat >> confdefs.h <<\EOF
3407 #define HAVE_BUILTIN_COS 1
3408 EOF
3409
3410   fi
3411   echo $ac_n "checking for __builtin_cosf""... $ac_c" 1>&6
3412 echo "configure:3413: checking for __builtin_cosf" >&5
3413   cat > conftest.$ac_ext <<EOF
3414 #line 3415 "configure"
3415 #include "confdefs.h"
3416 #include <math.h>
3417 int main() {
3418  __builtin_cosf(0.0);
3419 ; return 0; }
3420 EOF
3421 if { (eval echo configure:3422: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3422   rm -rf conftest*
3423   use_builtin_cosf=yes
3424 else
3425   echo "configure: failed program was:" >&5
3426   cat conftest.$ac_ext >&5
3427   rm -rf conftest*
3428   use_builtin_cosf=no
3429 fi
3430 rm -f conftest*
3431   echo "$ac_t""$use_builtin_cosf" 1>&6
3432   if test $use_builtin_cosf = "yes"; then
3433     cat >> confdefs.h <<\EOF
3434 #define HAVE_BUILTIN_COSF 1
3435 EOF
3436
3437   fi
3438   echo $ac_n "checking for __builtin_cosl""... $ac_c" 1>&6
3439 echo "configure:3440: checking for __builtin_cosl" >&5
3440   cat > conftest.$ac_ext <<EOF
3441 #line 3442 "configure"
3442 #include "confdefs.h"
3443 #include <math.h>
3444 int main() {
3445  __builtin_cosl(0.0);
3446 ; return 0; }
3447 EOF
3448 if { (eval echo configure:3449: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3449   rm -rf conftest*
3450   use_builtin_cosl=yes
3451 else
3452   echo "configure: failed program was:" >&5
3453   cat conftest.$ac_ext >&5
3454   rm -rf conftest*
3455   use_builtin_cosl=no
3456 fi
3457 rm -f conftest*
3458   echo "$ac_t""$use_builtin_cosl" 1>&6
3459   if test $use_builtin_cosl = "yes"; then
3460     cat >> confdefs.h <<\EOF
3461 #define HAVE_BUILTIN_COSL 1
3462 EOF
3463
3464   fi
3465   echo $ac_n "checking for __builtin_cosh""... $ac_c" 1>&6
3466 echo "configure:3467: checking for __builtin_cosh" >&5
3467   cat > conftest.$ac_ext <<EOF
3468 #line 3469 "configure"
3469 #include "confdefs.h"
3470 #include <math.h>
3471 int main() {
3472  __builtin_cosh(0.0);
3473 ; return 0; }
3474 EOF
3475 if { (eval echo configure:3476: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3476   rm -rf conftest*
3477   use_builtin_cosh=yes
3478 else
3479   echo "configure: failed program was:" >&5
3480   cat conftest.$ac_ext >&5
3481   rm -rf conftest*
3482   use_builtin_cosh=no
3483 fi
3484 rm -f conftest*
3485   echo "$ac_t""$use_builtin_cosh" 1>&6
3486   if test $use_builtin_cosh = "yes"; then
3487     cat >> confdefs.h <<\EOF
3488 #define HAVE_BUILTIN_COSH 1
3489 EOF
3490
3491   fi
3492   echo $ac_n "checking for __builtin_coshf""... $ac_c" 1>&6
3493 echo "configure:3494: checking for __builtin_coshf" >&5
3494   cat > conftest.$ac_ext <<EOF
3495 #line 3496 "configure"
3496 #include "confdefs.h"
3497 #include <math.h>
3498 int main() {
3499  __builtin_coshf(0.0);
3500 ; return 0; }
3501 EOF
3502 if { (eval echo configure:3503: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3503   rm -rf conftest*
3504   use_builtin_coshf=yes
3505 else
3506   echo "configure: failed program was:" >&5
3507   cat conftest.$ac_ext >&5
3508   rm -rf conftest*
3509   use_builtin_coshf=no
3510 fi
3511 rm -f conftest*
3512   echo "$ac_t""$use_builtin_coshf" 1>&6
3513   if test $use_builtin_coshf = "yes"; then
3514     cat >> confdefs.h <<\EOF
3515 #define HAVE_BUILTIN_COSHF 1
3516 EOF
3517
3518   fi
3519   echo $ac_n "checking for __builtin_coshl""... $ac_c" 1>&6
3520 echo "configure:3521: checking for __builtin_coshl" >&5
3521   cat > conftest.$ac_ext <<EOF
3522 #line 3523 "configure"
3523 #include "confdefs.h"
3524 #include <math.h>
3525 int main() {
3526  __builtin_coshl(0.0);
3527 ; return 0; }
3528 EOF
3529 if { (eval echo configure:3530: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3530   rm -rf conftest*
3531   use_builtin_coshl=yes
3532 else
3533   echo "configure: failed program was:" >&5
3534   cat conftest.$ac_ext >&5
3535   rm -rf conftest*
3536   use_builtin_coshl=no
3537 fi
3538 rm -f conftest*
3539   echo "$ac_t""$use_builtin_coshl" 1>&6
3540   if test $use_builtin_coshl = "yes"; then
3541     cat >> confdefs.h <<\EOF
3542 #define HAVE_BUILTIN_COSHL 1
3543 EOF
3544
3545   fi
3546   echo $ac_n "checking for __builtin_exp""... $ac_c" 1>&6
3547 echo "configure:3548: checking for __builtin_exp" >&5
3548   cat > conftest.$ac_ext <<EOF
3549 #line 3550 "configure"
3550 #include "confdefs.h"
3551 #include <math.h>
3552 int main() {
3553  __builtin_exp(0.0);
3554 ; return 0; }
3555 EOF
3556 if { (eval echo configure:3557: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3557   rm -rf conftest*
3558   use_builtin_exp=yes
3559 else
3560   echo "configure: failed program was:" >&5
3561   cat conftest.$ac_ext >&5
3562   rm -rf conftest*
3563   use_builtin_exp=no
3564 fi
3565 rm -f conftest*
3566   echo "$ac_t""$use_builtin_exp" 1>&6
3567   if test $use_builtin_exp = "yes"; then
3568     cat >> confdefs.h <<\EOF
3569 #define HAVE_BUILTIN_EXP 1
3570 EOF
3571
3572   fi
3573   echo $ac_n "checking for __builtin_expf""... $ac_c" 1>&6
3574 echo "configure:3575: checking for __builtin_expf" >&5
3575   cat > conftest.$ac_ext <<EOF
3576 #line 3577 "configure"
3577 #include "confdefs.h"
3578 #include <math.h>
3579 int main() {
3580  __builtin_expf(0.0);
3581 ; return 0; }
3582 EOF
3583 if { (eval echo configure:3584: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3584   rm -rf conftest*
3585   use_builtin_expf=yes
3586 else
3587   echo "configure: failed program was:" >&5
3588   cat conftest.$ac_ext >&5
3589   rm -rf conftest*
3590   use_builtin_expf=no
3591 fi
3592 rm -f conftest*
3593   echo "$ac_t""$use_builtin_expf" 1>&6
3594   if test $use_builtin_expf = "yes"; then
3595     cat >> confdefs.h <<\EOF
3596 #define HAVE_BUILTIN_EXPF 1
3597 EOF
3598
3599   fi
3600   echo $ac_n "checking for __builtin_expl""... $ac_c" 1>&6
3601 echo "configure:3602: checking for __builtin_expl" >&5
3602   cat > conftest.$ac_ext <<EOF
3603 #line 3604 "configure"
3604 #include "confdefs.h"
3605 #include <math.h>
3606 int main() {
3607  __builtin_expl(0.0);
3608 ; return 0; }
3609 EOF
3610 if { (eval echo configure:3611: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3611   rm -rf conftest*
3612   use_builtin_expl=yes
3613 else
3614   echo "configure: failed program was:" >&5
3615   cat conftest.$ac_ext >&5
3616   rm -rf conftest*
3617   use_builtin_expl=no
3618 fi
3619 rm -f conftest*
3620   echo "$ac_t""$use_builtin_expl" 1>&6
3621   if test $use_builtin_expl = "yes"; then
3622     cat >> confdefs.h <<\EOF
3623 #define HAVE_BUILTIN_EXPL 1
3624 EOF
3625
3626   fi
3627   echo $ac_n "checking for __builtin_fabs""... $ac_c" 1>&6
3628 echo "configure:3629: checking for __builtin_fabs" >&5
3629   cat > conftest.$ac_ext <<EOF
3630 #line 3631 "configure"
3631 #include "confdefs.h"
3632 #include <math.h>
3633 int main() {
3634  __builtin_fabs(0.0);
3635 ; return 0; }
3636 EOF
3637 if { (eval echo configure:3638: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3638   rm -rf conftest*
3639   use_builtin_fabs=yes
3640 else
3641   echo "configure: failed program was:" >&5
3642   cat conftest.$ac_ext >&5
3643   rm -rf conftest*
3644   use_builtin_fabs=no
3645 fi
3646 rm -f conftest*
3647   echo "$ac_t""$use_builtin_fabs" 1>&6
3648   if test $use_builtin_fabs = "yes"; then
3649     cat >> confdefs.h <<\EOF
3650 #define HAVE_BUILTIN_FABS 1
3651 EOF
3652
3653   fi
3654   echo $ac_n "checking for __builtin_fabsf""... $ac_c" 1>&6
3655 echo "configure:3656: checking for __builtin_fabsf" >&5
3656   cat > conftest.$ac_ext <<EOF
3657 #line 3658 "configure"
3658 #include "confdefs.h"
3659 #include <math.h>
3660 int main() {
3661  __builtin_fabsf(0.0);
3662 ; return 0; }
3663 EOF
3664 if { (eval echo configure:3665: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3665   rm -rf conftest*
3666   use_builtin_fabsf=yes
3667 else
3668   echo "configure: failed program was:" >&5
3669   cat conftest.$ac_ext >&5
3670   rm -rf conftest*
3671   use_builtin_fabsf=no
3672 fi
3673 rm -f conftest*
3674   echo "$ac_t""$use_builtin_fabsf" 1>&6
3675   if test $use_builtin_fabsf = "yes"; then
3676     cat >> confdefs.h <<\EOF
3677 #define HAVE_BUILTIN_FABSF 1
3678 EOF
3679
3680   fi
3681   echo $ac_n "checking for __builtin_fabsl""... $ac_c" 1>&6
3682 echo "configure:3683: checking for __builtin_fabsl" >&5
3683   cat > conftest.$ac_ext <<EOF
3684 #line 3685 "configure"
3685 #include "confdefs.h"
3686 #include <math.h>
3687 int main() {
3688  __builtin_fabsl(0.0);
3689 ; return 0; }
3690 EOF
3691 if { (eval echo configure:3692: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3692   rm -rf conftest*
3693   use_builtin_fabsl=yes
3694 else
3695   echo "configure: failed program was:" >&5
3696   cat conftest.$ac_ext >&5
3697   rm -rf conftest*
3698   use_builtin_fabsl=no
3699 fi
3700 rm -f conftest*
3701   echo "$ac_t""$use_builtin_fabsl" 1>&6
3702   if test $use_builtin_fabsl = "yes"; then
3703     cat >> confdefs.h <<\EOF
3704 #define HAVE_BUILTIN_FABSL 1
3705 EOF
3706
3707   fi
3708   echo $ac_n "checking for __builtin_floor""... $ac_c" 1>&6
3709 echo "configure:3710: checking for __builtin_floor" >&5
3710   cat > conftest.$ac_ext <<EOF
3711 #line 3712 "configure"
3712 #include "confdefs.h"
3713 #include <math.h>
3714 int main() {
3715  __builtin_floor(0.0);
3716 ; return 0; }
3717 EOF
3718 if { (eval echo configure:3719: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3719   rm -rf conftest*
3720   use_builtin_floor=yes
3721 else
3722   echo "configure: failed program was:" >&5
3723   cat conftest.$ac_ext >&5
3724   rm -rf conftest*
3725   use_builtin_floor=no
3726 fi
3727 rm -f conftest*
3728   echo "$ac_t""$use_builtin_floor" 1>&6
3729   if test $use_builtin_floor = "yes"; then
3730     cat >> confdefs.h <<\EOF
3731 #define HAVE_BUILTIN_FLOOR 1
3732 EOF
3733
3734   fi
3735   echo $ac_n "checking for __builtin_floorf""... $ac_c" 1>&6
3736 echo "configure:3737: checking for __builtin_floorf" >&5
3737   cat > conftest.$ac_ext <<EOF
3738 #line 3739 "configure"
3739 #include "confdefs.h"
3740 #include <math.h>
3741 int main() {
3742  __builtin_floorf(0.0);
3743 ; return 0; }
3744 EOF
3745 if { (eval echo configure:3746: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3746   rm -rf conftest*
3747   use_builtin_floorf=yes
3748 else
3749   echo "configure: failed program was:" >&5
3750   cat conftest.$ac_ext >&5
3751   rm -rf conftest*
3752   use_builtin_floorf=no
3753 fi
3754 rm -f conftest*
3755   echo "$ac_t""$use_builtin_floorf" 1>&6
3756   if test $use_builtin_floorf = "yes"; then
3757     cat >> confdefs.h <<\EOF
3758 #define HAVE_BUILTIN_FLOORF 1
3759 EOF
3760
3761   fi
3762   echo $ac_n "checking for __builtin_floorl""... $ac_c" 1>&6
3763 echo "configure:3764: checking for __builtin_floorl" >&5
3764   cat > conftest.$ac_ext <<EOF
3765 #line 3766 "configure"
3766 #include "confdefs.h"
3767 #include <math.h>
3768 int main() {
3769  __builtin_floorl(0.0);
3770 ; return 0; }
3771 EOF
3772 if { (eval echo configure:3773: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3773   rm -rf conftest*
3774   use_builtin_floorl=yes
3775 else
3776   echo "configure: failed program was:" >&5
3777   cat conftest.$ac_ext >&5
3778   rm -rf conftest*
3779   use_builtin_floorl=no
3780 fi
3781 rm -f conftest*
3782   echo "$ac_t""$use_builtin_floorl" 1>&6
3783   if test $use_builtin_floorl = "yes"; then
3784     cat >> confdefs.h <<\EOF
3785 #define HAVE_BUILTIN_FLOORL 1
3786 EOF
3787
3788   fi
3789   echo $ac_n "checking for __builtin_fmod""... $ac_c" 1>&6
3790 echo "configure:3791: checking for __builtin_fmod" >&5
3791   cat > conftest.$ac_ext <<EOF
3792 #line 3793 "configure"
3793 #include "confdefs.h"
3794 #include <math.h>
3795 int main() {
3796  __builtin_fmod(0.0, 0.0);
3797 ; return 0; }
3798 EOF
3799 if { (eval echo configure:3800: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3800   rm -rf conftest*
3801   use_builtin_fmod=yes
3802 else
3803   echo "configure: failed program was:" >&5
3804   cat conftest.$ac_ext >&5
3805   rm -rf conftest*
3806   use_builtin_fmod=no
3807 fi
3808 rm -f conftest*
3809   echo "$ac_t""$use_builtin_fmod" 1>&6
3810   if test $use_builtin_fmod = "yes"; then
3811     cat >> confdefs.h <<\EOF
3812 #define HAVE_BUILTIN_FMOD 1
3813 EOF
3814
3815   fi
3816   echo $ac_n "checking for __builtin_fmodf""... $ac_c" 1>&6
3817 echo "configure:3818: checking for __builtin_fmodf" >&5
3818   cat > conftest.$ac_ext <<EOF
3819 #line 3820 "configure"
3820 #include "confdefs.h"
3821 #include <math.h>
3822 int main() {
3823  __builtin_fmodf(0.0, 0.0);
3824 ; return 0; }
3825 EOF
3826 if { (eval echo configure:3827: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3827   rm -rf conftest*
3828   use_builtin_fmodf=yes
3829 else
3830   echo "configure: failed program was:" >&5
3831   cat conftest.$ac_ext >&5
3832   rm -rf conftest*
3833   use_builtin_fmodf=no
3834 fi
3835 rm -f conftest*
3836   echo "$ac_t""$use_builtin_fmodf" 1>&6
3837   if test $use_builtin_fmodf = "yes"; then
3838     cat >> confdefs.h <<\EOF
3839 #define HAVE_BUILTIN_FMODF 1
3840 EOF
3841
3842   fi
3843   echo $ac_n "checking for __builtin_fmodl""... $ac_c" 1>&6
3844 echo "configure:3845: checking for __builtin_fmodl" >&5
3845   cat > conftest.$ac_ext <<EOF
3846 #line 3847 "configure"
3847 #include "confdefs.h"
3848 #include <math.h>
3849 int main() {
3850  __builtin_fmodl(0.0, 0.0);
3851 ; return 0; }
3852 EOF
3853 if { (eval echo configure:3854: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3854   rm -rf conftest*
3855   use_builtin_fmodl=yes
3856 else
3857   echo "configure: failed program was:" >&5
3858   cat conftest.$ac_ext >&5
3859   rm -rf conftest*
3860   use_builtin_fmodl=no
3861 fi
3862 rm -f conftest*
3863   echo "$ac_t""$use_builtin_fmodl" 1>&6
3864   if test $use_builtin_fmodl = "yes"; then
3865     cat >> confdefs.h <<\EOF
3866 #define HAVE_BUILTIN_FMODL 1
3867 EOF
3868
3869   fi
3870   echo $ac_n "checking for __builtin_frexp""... $ac_c" 1>&6
3871 echo "configure:3872: checking for __builtin_frexp" >&5
3872   cat > conftest.$ac_ext <<EOF
3873 #line 3874 "configure"
3874 #include "confdefs.h"
3875 #include <math.h>
3876 int main() {
3877  __builtin_frexp(0.0, 0);
3878 ; return 0; }
3879 EOF
3880 if { (eval echo configure:3881: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3881   rm -rf conftest*
3882   use_builtin_frexp=yes
3883 else
3884   echo "configure: failed program was:" >&5
3885   cat conftest.$ac_ext >&5
3886   rm -rf conftest*
3887   use_builtin_frexp=no
3888 fi
3889 rm -f conftest*
3890   echo "$ac_t""$use_builtin_frexp" 1>&6
3891   if test $use_builtin_frexp = "yes"; then
3892     cat >> confdefs.h <<\EOF
3893 #define HAVE_BUILTIN_FREXP 1
3894 EOF
3895
3896   fi
3897   echo $ac_n "checking for __builtin_frexpf""... $ac_c" 1>&6
3898 echo "configure:3899: checking for __builtin_frexpf" >&5
3899   cat > conftest.$ac_ext <<EOF
3900 #line 3901 "configure"
3901 #include "confdefs.h"
3902 #include <math.h>
3903 int main() {
3904  __builtin_frexpf(0.0, 0);
3905 ; return 0; }
3906 EOF
3907 if { (eval echo configure:3908: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3908   rm -rf conftest*
3909   use_builtin_frexpf=yes
3910 else
3911   echo "configure: failed program was:" >&5
3912   cat conftest.$ac_ext >&5
3913   rm -rf conftest*
3914   use_builtin_frexpf=no
3915 fi
3916 rm -f conftest*
3917   echo "$ac_t""$use_builtin_frexpf" 1>&6
3918   if test $use_builtin_frexpf = "yes"; then
3919     cat >> confdefs.h <<\EOF
3920 #define HAVE_BUILTIN_FREXPF 1
3921 EOF
3922
3923   fi
3924   echo $ac_n "checking for __builtin_frexpl""... $ac_c" 1>&6
3925 echo "configure:3926: checking for __builtin_frexpl" >&5
3926   cat > conftest.$ac_ext <<EOF
3927 #line 3928 "configure"
3928 #include "confdefs.h"
3929 #include <math.h>
3930 int main() {
3931  __builtin_frexpl(0.0, 0);
3932 ; return 0; }
3933 EOF
3934 if { (eval echo configure:3935: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3935   rm -rf conftest*
3936   use_builtin_frexpl=yes
3937 else
3938   echo "configure: failed program was:" >&5
3939   cat conftest.$ac_ext >&5
3940   rm -rf conftest*
3941   use_builtin_frexpl=no
3942 fi
3943 rm -f conftest*
3944   echo "$ac_t""$use_builtin_frexpl" 1>&6
3945   if test $use_builtin_frexpl = "yes"; then
3946     cat >> confdefs.h <<\EOF
3947 #define HAVE_BUILTIN_FREXPL 1
3948 EOF
3949
3950   fi
3951   echo $ac_n "checking for __builtin_ldexp""... $ac_c" 1>&6
3952 echo "configure:3953: checking for __builtin_ldexp" >&5
3953   cat > conftest.$ac_ext <<EOF
3954 #line 3955 "configure"
3955 #include "confdefs.h"
3956 #include <math.h>
3957 int main() {
3958  __builtin_ldexp(0.0, 0);
3959 ; return 0; }
3960 EOF
3961 if { (eval echo configure:3962: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3962   rm -rf conftest*
3963   use_builtin_ldexp=yes
3964 else
3965   echo "configure: failed program was:" >&5
3966   cat conftest.$ac_ext >&5
3967   rm -rf conftest*
3968   use_builtin_ldexp=no
3969 fi
3970 rm -f conftest*
3971   echo "$ac_t""$use_builtin_ldexp" 1>&6
3972   if test $use_builtin_ldexp = "yes"; then
3973     cat >> confdefs.h <<\EOF
3974 #define HAVE_BUILTIN_LDEXP 1
3975 EOF
3976
3977   fi
3978   echo $ac_n "checking for __builtin_ldexpf""... $ac_c" 1>&6
3979 echo "configure:3980: checking for __builtin_ldexpf" >&5
3980   cat > conftest.$ac_ext <<EOF
3981 #line 3982 "configure"
3982 #include "confdefs.h"
3983 #include <math.h>
3984 int main() {
3985  __builtin_ldexpf(0.0, 0);
3986 ; return 0; }
3987 EOF
3988 if { (eval echo configure:3989: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3989   rm -rf conftest*
3990   use_builtin_ldexpf=yes
3991 else
3992   echo "configure: failed program was:" >&5
3993   cat conftest.$ac_ext >&5
3994   rm -rf conftest*
3995   use_builtin_ldexpf=no
3996 fi
3997 rm -f conftest*
3998   echo "$ac_t""$use_builtin_ldexpf" 1>&6
3999   if test $use_builtin_ldexpf = "yes"; then
4000     cat >> confdefs.h <<\EOF
4001 #define HAVE_BUILTIN_LDEXPF 1
4002 EOF
4003
4004   fi
4005   echo $ac_n "checking for __builtin_ldexpl""... $ac_c" 1>&6
4006 echo "configure:4007: checking for __builtin_ldexpl" >&5
4007   cat > conftest.$ac_ext <<EOF
4008 #line 4009 "configure"
4009 #include "confdefs.h"
4010 #include <math.h>
4011 int main() {
4012  __builtin_ldexpl(0.0, 0);
4013 ; return 0; }
4014 EOF
4015 if { (eval echo configure:4016: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4016   rm -rf conftest*
4017   use_builtin_ldexpl=yes
4018 else
4019   echo "configure: failed program was:" >&5
4020   cat conftest.$ac_ext >&5
4021   rm -rf conftest*
4022   use_builtin_ldexpl=no
4023 fi
4024 rm -f conftest*
4025   echo "$ac_t""$use_builtin_ldexpl" 1>&6
4026   if test $use_builtin_ldexpl = "yes"; then
4027     cat >> confdefs.h <<\EOF
4028 #define HAVE_BUILTIN_LDEXPL 1
4029 EOF
4030
4031   fi
4032   echo $ac_n "checking for __builtin_log""... $ac_c" 1>&6
4033 echo "configure:4034: checking for __builtin_log" >&5
4034   cat > conftest.$ac_ext <<EOF
4035 #line 4036 "configure"
4036 #include "confdefs.h"
4037 #include <math.h>
4038 int main() {
4039  __builtin_log(0.0);
4040 ; return 0; }
4041 EOF
4042 if { (eval echo configure:4043: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4043   rm -rf conftest*
4044   use_builtin_log=yes
4045 else
4046   echo "configure: failed program was:" >&5
4047   cat conftest.$ac_ext >&5
4048   rm -rf conftest*
4049   use_builtin_log=no
4050 fi
4051 rm -f conftest*
4052   echo "$ac_t""$use_builtin_log" 1>&6
4053   if test $use_builtin_log = "yes"; then
4054     cat >> confdefs.h <<\EOF
4055 #define HAVE_BUILTIN_LOG 1
4056 EOF
4057
4058   fi
4059   echo $ac_n "checking for __builtin_logf""... $ac_c" 1>&6
4060 echo "configure:4061: checking for __builtin_logf" >&5
4061   cat > conftest.$ac_ext <<EOF
4062 #line 4063 "configure"
4063 #include "confdefs.h"
4064 #include <math.h>
4065 int main() {
4066  __builtin_logf(0.0);
4067 ; return 0; }
4068 EOF
4069 if { (eval echo configure:4070: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4070   rm -rf conftest*
4071   use_builtin_logf=yes
4072 else
4073   echo "configure: failed program was:" >&5
4074   cat conftest.$ac_ext >&5
4075   rm -rf conftest*
4076   use_builtin_logf=no
4077 fi
4078 rm -f conftest*
4079   echo "$ac_t""$use_builtin_logf" 1>&6
4080   if test $use_builtin_logf = "yes"; then
4081     cat >> confdefs.h <<\EOF
4082 #define HAVE_BUILTIN_LOGF 1
4083 EOF
4084
4085   fi
4086   echo $ac_n "checking for __builtin_logl""... $ac_c" 1>&6
4087 echo "configure:4088: checking for __builtin_logl" >&5
4088   cat > conftest.$ac_ext <<EOF
4089 #line 4090 "configure"
4090 #include "confdefs.h"
4091 #include <math.h>
4092 int main() {
4093  __builtin_logl(0.0);
4094 ; return 0; }
4095 EOF
4096 if { (eval echo configure:4097: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4097   rm -rf conftest*
4098   use_builtin_logl=yes
4099 else
4100   echo "configure: failed program was:" >&5
4101   cat conftest.$ac_ext >&5
4102   rm -rf conftest*
4103   use_builtin_logl=no
4104 fi
4105 rm -f conftest*
4106   echo "$ac_t""$use_builtin_logl" 1>&6
4107   if test $use_builtin_logl = "yes"; then
4108     cat >> confdefs.h <<\EOF
4109 #define HAVE_BUILTIN_LOGL 1
4110 EOF
4111
4112   fi
4113   echo $ac_n "checking for __builtin_log10""... $ac_c" 1>&6
4114 echo "configure:4115: checking for __builtin_log10" >&5
4115   cat > conftest.$ac_ext <<EOF
4116 #line 4117 "configure"
4117 #include "confdefs.h"
4118 #include <math.h>
4119 int main() {
4120  __builtin_log10(0.0);
4121 ; return 0; }
4122 EOF
4123 if { (eval echo configure:4124: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4124   rm -rf conftest*
4125   use_builtin_log10=yes
4126 else
4127   echo "configure: failed program was:" >&5
4128   cat conftest.$ac_ext >&5
4129   rm -rf conftest*
4130   use_builtin_log10=no
4131 fi
4132 rm -f conftest*
4133   echo "$ac_t""$use_builtin_log10" 1>&6
4134   if test $use_builtin_log10 = "yes"; then
4135     cat >> confdefs.h <<\EOF
4136 #define HAVE_BUILTIN_LOG10 1
4137 EOF
4138
4139   fi
4140   echo $ac_n "checking for __builtin_log10f""... $ac_c" 1>&6
4141 echo "configure:4142: checking for __builtin_log10f" >&5
4142   cat > conftest.$ac_ext <<EOF
4143 #line 4144 "configure"
4144 #include "confdefs.h"
4145 #include <math.h>
4146 int main() {
4147  __builtin_log10f(0.0);
4148 ; return 0; }
4149 EOF
4150 if { (eval echo configure:4151: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4151   rm -rf conftest*
4152   use_builtin_log10f=yes
4153 else
4154   echo "configure: failed program was:" >&5
4155   cat conftest.$ac_ext >&5
4156   rm -rf conftest*
4157   use_builtin_log10f=no
4158 fi
4159 rm -f conftest*
4160   echo "$ac_t""$use_builtin_log10f" 1>&6
4161   if test $use_builtin_log10f = "yes"; then
4162     cat >> confdefs.h <<\EOF
4163 #define HAVE_BUILTIN_LOG10F 1
4164 EOF
4165
4166   fi
4167   echo $ac_n "checking for __builtin_log10l""... $ac_c" 1>&6
4168 echo "configure:4169: checking for __builtin_log10l" >&5
4169   cat > conftest.$ac_ext <<EOF
4170 #line 4171 "configure"
4171 #include "confdefs.h"
4172 #include <math.h>
4173 int main() {
4174  __builtin_log10l(0.0);
4175 ; return 0; }
4176 EOF
4177 if { (eval echo configure:4178: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4178   rm -rf conftest*
4179   use_builtin_log10l=yes
4180 else
4181   echo "configure: failed program was:" >&5
4182   cat conftest.$ac_ext >&5
4183   rm -rf conftest*
4184   use_builtin_log10l=no
4185 fi
4186 rm -f conftest*
4187   echo "$ac_t""$use_builtin_log10l" 1>&6
4188   if test $use_builtin_log10l = "yes"; then
4189     cat >> confdefs.h <<\EOF
4190 #define HAVE_BUILTIN_LOG10L 1
4191 EOF
4192
4193   fi
4194   echo $ac_n "checking for __builtin_modf""... $ac_c" 1>&6
4195 echo "configure:4196: checking for __builtin_modf" >&5
4196   cat > conftest.$ac_ext <<EOF
4197 #line 4198 "configure"
4198 #include "confdefs.h"
4199 #include <math.h>
4200 int main() {
4201  __builtin_modf(0.0, 0);
4202 ; return 0; }
4203 EOF
4204 if { (eval echo configure:4205: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4205   rm -rf conftest*
4206   use_builtin_modf=yes
4207 else
4208   echo "configure: failed program was:" >&5
4209   cat conftest.$ac_ext >&5
4210   rm -rf conftest*
4211   use_builtin_modf=no
4212 fi
4213 rm -f conftest*
4214   echo "$ac_t""$use_builtin_modf" 1>&6
4215   if test $use_builtin_modf = "yes"; then
4216     cat >> confdefs.h <<\EOF
4217 #define HAVE_BUILTIN_MODF 1
4218 EOF
4219
4220   fi
4221   echo $ac_n "checking for __builtin_modff""... $ac_c" 1>&6
4222 echo "configure:4223: checking for __builtin_modff" >&5
4223   cat > conftest.$ac_ext <<EOF
4224 #line 4225 "configure"
4225 #include "confdefs.h"
4226 #include <math.h>
4227 int main() {
4228  __builtin_modff(0.0, 0);
4229 ; return 0; }
4230 EOF
4231 if { (eval echo configure:4232: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4232   rm -rf conftest*
4233   use_builtin_modff=yes
4234 else
4235   echo "configure: failed program was:" >&5
4236   cat conftest.$ac_ext >&5
4237   rm -rf conftest*
4238   use_builtin_modff=no
4239 fi
4240 rm -f conftest*
4241   echo "$ac_t""$use_builtin_modff" 1>&6
4242   if test $use_builtin_modff = "yes"; then
4243     cat >> confdefs.h <<\EOF
4244 #define HAVE_BUILTIN_MODFF 1
4245 EOF
4246
4247   fi
4248   echo $ac_n "checking for __builtin_modfl""... $ac_c" 1>&6
4249 echo "configure:4250: checking for __builtin_modfl" >&5
4250   cat > conftest.$ac_ext <<EOF
4251 #line 4252 "configure"
4252 #include "confdefs.h"
4253 #include <math.h>
4254 int main() {
4255  __builtin_modfl(0.0, 0);
4256 ; return 0; }
4257 EOF
4258 if { (eval echo configure:4259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4259   rm -rf conftest*
4260   use_builtin_modfl=yes
4261 else
4262   echo "configure: failed program was:" >&5
4263   cat conftest.$ac_ext >&5
4264   rm -rf conftest*
4265   use_builtin_modfl=no
4266 fi
4267 rm -f conftest*
4268   echo "$ac_t""$use_builtin_modfl" 1>&6
4269   if test $use_builtin_modfl = "yes"; then
4270     cat >> confdefs.h <<\EOF
4271 #define HAVE_BUILTIN_MODFL 1
4272 EOF
4273
4274   fi
4275   echo $ac_n "checking for __builtin_pow""... $ac_c" 1>&6
4276 echo "configure:4277: checking for __builtin_pow" >&5
4277   cat > conftest.$ac_ext <<EOF
4278 #line 4279 "configure"
4279 #include "confdefs.h"
4280 #include <math.h>
4281 int main() {
4282  __builtin_pow(0.0, 0.0);
4283 ; return 0; }
4284 EOF
4285 if { (eval echo configure:4286: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4286   rm -rf conftest*
4287   use_builtin_pow=yes
4288 else
4289   echo "configure: failed program was:" >&5
4290   cat conftest.$ac_ext >&5
4291   rm -rf conftest*
4292   use_builtin_pow=no
4293 fi
4294 rm -f conftest*
4295   echo "$ac_t""$use_builtin_pow" 1>&6
4296   if test $use_builtin_pow = "yes"; then
4297     cat >> confdefs.h <<\EOF
4298 #define HAVE_BUILTIN_POW 1
4299 EOF
4300
4301   fi
4302   echo $ac_n "checking for __builtin_powf""... $ac_c" 1>&6
4303 echo "configure:4304: checking for __builtin_powf" >&5
4304   cat > conftest.$ac_ext <<EOF
4305 #line 4306 "configure"
4306 #include "confdefs.h"
4307 #include <math.h>
4308 int main() {
4309  __builtin_powf(0.0, 0.0);
4310 ; return 0; }
4311 EOF
4312 if { (eval echo configure:4313: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4313   rm -rf conftest*
4314   use_builtin_powf=yes
4315 else
4316   echo "configure: failed program was:" >&5
4317   cat conftest.$ac_ext >&5
4318   rm -rf conftest*
4319   use_builtin_powf=no
4320 fi
4321 rm -f conftest*
4322   echo "$ac_t""$use_builtin_powf" 1>&6
4323   if test $use_builtin_powf = "yes"; then
4324     cat >> confdefs.h <<\EOF
4325 #define HAVE_BUILTIN_POWF 1
4326 EOF
4327
4328   fi
4329   echo $ac_n "checking for __builtin_powl""... $ac_c" 1>&6
4330 echo "configure:4331: checking for __builtin_powl" >&5
4331   cat > conftest.$ac_ext <<EOF
4332 #line 4333 "configure"
4333 #include "confdefs.h"
4334 #include <math.h>
4335 int main() {
4336  __builtin_powl(0.0, 0.0);
4337 ; return 0; }
4338 EOF
4339 if { (eval echo configure:4340: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4340   rm -rf conftest*
4341   use_builtin_powl=yes
4342 else
4343   echo "configure: failed program was:" >&5
4344   cat conftest.$ac_ext >&5
4345   rm -rf conftest*
4346   use_builtin_powl=no
4347 fi
4348 rm -f conftest*
4349   echo "$ac_t""$use_builtin_powl" 1>&6
4350   if test $use_builtin_powl = "yes"; then
4351     cat >> confdefs.h <<\EOF
4352 #define HAVE_BUILTIN_POWL 1
4353 EOF
4354
4355   fi
4356   echo $ac_n "checking for __builtin_sin""... $ac_c" 1>&6
4357 echo "configure:4358: checking for __builtin_sin" >&5
4358   cat > conftest.$ac_ext <<EOF
4359 #line 4360 "configure"
4360 #include "confdefs.h"
4361 #include <math.h>
4362 int main() {
4363  __builtin_sin(0.0);
4364 ; return 0; }
4365 EOF
4366 if { (eval echo configure:4367: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4367   rm -rf conftest*
4368   use_builtin_sin=yes
4369 else
4370   echo "configure: failed program was:" >&5
4371   cat conftest.$ac_ext >&5
4372   rm -rf conftest*
4373   use_builtin_sin=no
4374 fi
4375 rm -f conftest*
4376   echo "$ac_t""$use_builtin_sin" 1>&6
4377   if test $use_builtin_sin = "yes"; then
4378     cat >> confdefs.h <<\EOF
4379 #define HAVE_BUILTIN_SIN 1
4380 EOF
4381
4382   fi
4383   echo $ac_n "checking for __builtin_sinf""... $ac_c" 1>&6
4384 echo "configure:4385: checking for __builtin_sinf" >&5
4385   cat > conftest.$ac_ext <<EOF
4386 #line 4387 "configure"
4387 #include "confdefs.h"
4388 #include <math.h>
4389 int main() {
4390  __builtin_sinf(0.0);
4391 ; return 0; }
4392 EOF
4393 if { (eval echo configure:4394: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4394   rm -rf conftest*
4395   use_builtin_sinf=yes
4396 else
4397   echo "configure: failed program was:" >&5
4398   cat conftest.$ac_ext >&5
4399   rm -rf conftest*
4400   use_builtin_sinf=no
4401 fi
4402 rm -f conftest*
4403   echo "$ac_t""$use_builtin_sinf" 1>&6
4404   if test $use_builtin_sinf = "yes"; then
4405     cat >> confdefs.h <<\EOF
4406 #define HAVE_BUILTIN_SINF 1
4407 EOF
4408
4409   fi
4410   echo $ac_n "checking for __builtin_sinl""... $ac_c" 1>&6
4411 echo "configure:4412: checking for __builtin_sinl" >&5
4412   cat > conftest.$ac_ext <<EOF
4413 #line 4414 "configure"
4414 #include "confdefs.h"
4415 #include <math.h>
4416 int main() {
4417  __builtin_sinl(0.0);
4418 ; return 0; }
4419 EOF
4420 if { (eval echo configure:4421: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4421   rm -rf conftest*
4422   use_builtin_sinl=yes
4423 else
4424   echo "configure: failed program was:" >&5
4425   cat conftest.$ac_ext >&5
4426   rm -rf conftest*
4427   use_builtin_sinl=no
4428 fi
4429 rm -f conftest*
4430   echo "$ac_t""$use_builtin_sinl" 1>&6
4431   if test $use_builtin_sinl = "yes"; then
4432     cat >> confdefs.h <<\EOF
4433 #define HAVE_BUILTIN_SINL 1
4434 EOF
4435
4436   fi
4437   echo $ac_n "checking for __builtin_sinh""... $ac_c" 1>&6
4438 echo "configure:4439: checking for __builtin_sinh" >&5
4439   cat > conftest.$ac_ext <<EOF
4440 #line 4441 "configure"
4441 #include "confdefs.h"
4442 #include <math.h>
4443 int main() {
4444  __builtin_sinh(0.0);
4445 ; return 0; }
4446 EOF
4447 if { (eval echo configure:4448: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4448   rm -rf conftest*
4449   use_builtin_sinh=yes
4450 else
4451   echo "configure: failed program was:" >&5
4452   cat conftest.$ac_ext >&5
4453   rm -rf conftest*
4454   use_builtin_sinh=no
4455 fi
4456 rm -f conftest*
4457   echo "$ac_t""$use_builtin_sinh" 1>&6
4458   if test $use_builtin_sinh = "yes"; then
4459     cat >> confdefs.h <<\EOF
4460 #define HAVE_BUILTIN_SINH 1
4461 EOF
4462
4463   fi
4464   echo $ac_n "checking for __builtin_sinhf""... $ac_c" 1>&6
4465 echo "configure:4466: checking for __builtin_sinhf" >&5
4466   cat > conftest.$ac_ext <<EOF
4467 #line 4468 "configure"
4468 #include "confdefs.h"
4469 #include <math.h>
4470 int main() {
4471  __builtin_sinhf(0.0);
4472 ; return 0; }
4473 EOF
4474 if { (eval echo configure:4475: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4475   rm -rf conftest*
4476   use_builtin_sinhf=yes
4477 else
4478   echo "configure: failed program was:" >&5
4479   cat conftest.$ac_ext >&5
4480   rm -rf conftest*
4481   use_builtin_sinhf=no
4482 fi
4483 rm -f conftest*
4484   echo "$ac_t""$use_builtin_sinhf" 1>&6
4485   if test $use_builtin_sinhf = "yes"; then
4486     cat >> confdefs.h <<\EOF
4487 #define HAVE_BUILTIN_SINHF 1
4488 EOF
4489
4490   fi
4491   echo $ac_n "checking for __builtin_sinhl""... $ac_c" 1>&6
4492 echo "configure:4493: checking for __builtin_sinhl" >&5
4493   cat > conftest.$ac_ext <<EOF
4494 #line 4495 "configure"
4495 #include "confdefs.h"
4496 #include <math.h>
4497 int main() {
4498  __builtin_sinhl(0.0);
4499 ; return 0; }
4500 EOF
4501 if { (eval echo configure:4502: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4502   rm -rf conftest*
4503   use_builtin_sinhl=yes
4504 else
4505   echo "configure: failed program was:" >&5
4506   cat conftest.$ac_ext >&5
4507   rm -rf conftest*
4508   use_builtin_sinhl=no
4509 fi
4510 rm -f conftest*
4511   echo "$ac_t""$use_builtin_sinhl" 1>&6
4512   if test $use_builtin_sinhl = "yes"; then
4513     cat >> confdefs.h <<\EOF
4514 #define HAVE_BUILTIN_SINHL 1
4515 EOF
4516
4517   fi
4518   echo $ac_n "checking for __builtin_sqrt""... $ac_c" 1>&6
4519 echo "configure:4520: checking for __builtin_sqrt" >&5
4520   cat > conftest.$ac_ext <<EOF
4521 #line 4522 "configure"
4522 #include "confdefs.h"
4523 #include <math.h>
4524 int main() {
4525  __builtin_fsqrt(0.0);
4526 ; return 0; }
4527 EOF
4528 if { (eval echo configure:4529: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4529   rm -rf conftest*
4530   use_builtin_sqrt=yes
4531 else
4532   echo "configure: failed program was:" >&5
4533   cat conftest.$ac_ext >&5
4534   rm -rf conftest*
4535   use_builtin_sqrt=no
4536 fi
4537 rm -f conftest*
4538   echo "$ac_t""$use_builtin_sqrt" 1>&6
4539   if test $use_builtin_sqrt = "yes"; then
4540     cat >> confdefs.h <<\EOF
4541 #define HAVE_BUILTIN_SQRT 1
4542 EOF
4543
4544   fi
4545   echo $ac_n "checking for __builtin_sqrtf""... $ac_c" 1>&6
4546 echo "configure:4547: checking for __builtin_sqrtf" >&5
4547   cat > conftest.$ac_ext <<EOF
4548 #line 4549 "configure"
4549 #include "confdefs.h"
4550 #include <math.h>
4551 int main() {
4552  __builtin_sqrtf(0.0);
4553 ; return 0; }
4554 EOF
4555 if { (eval echo configure:4556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4556   rm -rf conftest*
4557   use_builtin_sqrtf=yes
4558 else
4559   echo "configure: failed program was:" >&5
4560   cat conftest.$ac_ext >&5
4561   rm -rf conftest*
4562   use_builtin_sqrtf=no
4563 fi
4564 rm -f conftest*
4565   echo "$ac_t""$use_builtin_sqrtf" 1>&6
4566   if test $use_builtin_sqrtf = "yes"; then
4567     cat >> confdefs.h <<\EOF
4568 #define HAVE_BUILTIN_SQRTF 1
4569 EOF
4570
4571   fi
4572   echo $ac_n "checking for __builtin_sqrtl""... $ac_c" 1>&6
4573 echo "configure:4574: checking for __builtin_sqrtl" >&5
4574   cat > conftest.$ac_ext <<EOF
4575 #line 4576 "configure"
4576 #include "confdefs.h"
4577 #include <math.h>
4578 int main() {
4579  __builtin_sqrtl(0.0);
4580 ; return 0; }
4581 EOF
4582 if { (eval echo configure:4583: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4583   rm -rf conftest*
4584   use_builtin_sqrtl=yes
4585 else
4586   echo "configure: failed program was:" >&5
4587   cat conftest.$ac_ext >&5
4588   rm -rf conftest*
4589   use_builtin_sqrtl=no
4590 fi
4591 rm -f conftest*
4592   echo "$ac_t""$use_builtin_sqrtl" 1>&6
4593   if test $use_builtin_sqrtl = "yes"; then
4594     cat >> confdefs.h <<\EOF
4595 #define HAVE_BUILTIN_SQRTL 1
4596 EOF
4597
4598   fi
4599   echo $ac_n "checking for __builtin_tan""... $ac_c" 1>&6
4600 echo "configure:4601: checking for __builtin_tan" >&5
4601   cat > conftest.$ac_ext <<EOF
4602 #line 4603 "configure"
4603 #include "confdefs.h"
4604 #include <math.h>
4605 int main() {
4606  __builtin_tan(0.0);
4607 ; return 0; }
4608 EOF
4609 if { (eval echo configure:4610: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4610   rm -rf conftest*
4611   use_builtin_tan=yes
4612 else
4613   echo "configure: failed program was:" >&5
4614   cat conftest.$ac_ext >&5
4615   rm -rf conftest*
4616   use_builtin_tan=no
4617 fi
4618 rm -f conftest*
4619   echo "$ac_t""$use_builtin_tan" 1>&6
4620   if test $use_builtin_tan = "yes"; then
4621     cat >> confdefs.h <<\EOF
4622 #define HAVE_BUILTIN_TAN 1
4623 EOF
4624
4625   fi
4626   echo $ac_n "checking for __builtin_tanf""... $ac_c" 1>&6
4627 echo "configure:4628: checking for __builtin_tanf" >&5
4628   cat > conftest.$ac_ext <<EOF
4629 #line 4630 "configure"
4630 #include "confdefs.h"
4631 #include <math.h>
4632 int main() {
4633  __builtin_tanf(0.0);
4634 ; return 0; }
4635 EOF
4636 if { (eval echo configure:4637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4637   rm -rf conftest*
4638   use_builtin_tanf=yes
4639 else
4640   echo "configure: failed program was:" >&5
4641   cat conftest.$ac_ext >&5
4642   rm -rf conftest*
4643   use_builtin_tanf=no
4644 fi
4645 rm -f conftest*
4646   echo "$ac_t""$use_builtin_tanf" 1>&6
4647   if test $use_builtin_tanf = "yes"; then
4648     cat >> confdefs.h <<\EOF
4649 #define HAVE_BUILTIN_TANF 1
4650 EOF
4651
4652   fi
4653   echo $ac_n "checking for __builtin_tanl""... $ac_c" 1>&6
4654 echo "configure:4655: checking for __builtin_tanl" >&5
4655   cat > conftest.$ac_ext <<EOF
4656 #line 4657 "configure"
4657 #include "confdefs.h"
4658 #include <math.h>
4659 int main() {
4660  __builtin_tanl(0.0);
4661 ; return 0; }
4662 EOF
4663 if { (eval echo configure:4664: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4664   rm -rf conftest*
4665   use_builtin_tanl=yes
4666 else
4667   echo "configure: failed program was:" >&5
4668   cat conftest.$ac_ext >&5
4669   rm -rf conftest*
4670   use_builtin_tanl=no
4671 fi
4672 rm -f conftest*
4673   echo "$ac_t""$use_builtin_tanl" 1>&6
4674   if test $use_builtin_tanl = "yes"; then
4675     cat >> confdefs.h <<\EOF
4676 #define HAVE_BUILTIN_TANL 1
4677 EOF
4678
4679   fi
4680   echo $ac_n "checking for __builtin_tanh""... $ac_c" 1>&6
4681 echo "configure:4682: checking for __builtin_tanh" >&5
4682   cat > conftest.$ac_ext <<EOF
4683 #line 4684 "configure"
4684 #include "confdefs.h"
4685 #include <math.h>
4686 int main() {
4687  __builtin_tanh(0.0);
4688 ; return 0; }
4689 EOF
4690 if { (eval echo configure:4691: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4691   rm -rf conftest*
4692   use_builtin_tanh=yes
4693 else
4694   echo "configure: failed program was:" >&5
4695   cat conftest.$ac_ext >&5
4696   rm -rf conftest*
4697   use_builtin_tanh=no
4698 fi
4699 rm -f conftest*
4700   echo "$ac_t""$use_builtin_tanh" 1>&6
4701   if test $use_builtin_tanh = "yes"; then
4702     cat >> confdefs.h <<\EOF
4703 #define HAVE_BUILTIN_TANH 1
4704 EOF
4705
4706   fi
4707   echo $ac_n "checking for __builtin_tanhf""... $ac_c" 1>&6
4708 echo "configure:4709: checking for __builtin_tanhf" >&5
4709   cat > conftest.$ac_ext <<EOF
4710 #line 4711 "configure"
4711 #include "confdefs.h"
4712 #include <math.h>
4713 int main() {
4714  __builtin_tanhf(0.0);
4715 ; return 0; }
4716 EOF
4717 if { (eval echo configure:4718: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4718   rm -rf conftest*
4719   use_builtin_tanhf=yes
4720 else
4721   echo "configure: failed program was:" >&5
4722   cat conftest.$ac_ext >&5
4723   rm -rf conftest*
4724   use_builtin_tanhf=no
4725 fi
4726 rm -f conftest*
4727   echo "$ac_t""$use_builtin_tanhf" 1>&6
4728   if test $use_builtin_tanhf = "yes"; then
4729     cat >> confdefs.h <<\EOF
4730 #define HAVE_BUILTIN_TANHF 1
4731 EOF
4732
4733   fi
4734   echo $ac_n "checking for __builtin_tanhl""... $ac_c" 1>&6
4735 echo "configure:4736: checking for __builtin_tanhl" >&5
4736   cat > conftest.$ac_ext <<EOF
4737 #line 4738 "configure"
4738 #include "confdefs.h"
4739 #include <math.h>
4740 int main() {
4741  __builtin_tanhl(0.0);
4742 ; return 0; }
4743 EOF
4744 if { (eval echo configure:4745: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4745   rm -rf conftest*
4746   use_builtin_tanhl=yes
4747 else
4748   echo "configure: failed program was:" >&5
4749   cat conftest.$ac_ext >&5
4750   rm -rf conftest*
4751   use_builtin_tanhl=no
4752 fi
4753 rm -f conftest*
4754   echo "$ac_t""$use_builtin_tanhl" 1>&6
4755   if test $use_builtin_tanhl = "yes"; then
4756     cat >> confdefs.h <<\EOF
4757 #define HAVE_BUILTIN_TANHL 1
4758 EOF
4759
4760   fi
4761   ac_ext=c
4762 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4763 ac_cpp='$CPP $CPPFLAGS'
4764 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4765 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4766 cross_compiling=$ac_cv_prog_cc_cross
4767
4768
4769
4770   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4771   ac_save_CXXFLAGS="$CXXFLAGS"
4772   CXXFLAGS='-fno-builtins'
4773
4774     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4775 echo "configure:4776: checking for sin in -lm" >&5
4776 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4777 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4778   echo $ac_n "(cached) $ac_c" 1>&6
4779 else
4780   ac_save_LIBS="$LIBS"
4781 LIBS="-lm  $LIBS"
4782 cat > conftest.$ac_ext <<EOF
4783 #line 4784 "configure"
4784 #include "confdefs.h"
4785 /* Override any gcc2 internal prototype to avoid an error.  */
4786 /* We use char because int might match the return type of a gcc2
4787     builtin and then its argument prototype would still apply.  */
4788 char sin();
4789
4790 int main() {
4791 sin()
4792 ; return 0; }
4793 EOF
4794 if { (eval echo configure:4795: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4795   rm -rf conftest*
4796   eval "ac_cv_lib_$ac_lib_var=yes"
4797 else
4798   echo "configure: failed program was:" >&5
4799   cat conftest.$ac_ext >&5
4800   rm -rf conftest*
4801   eval "ac_cv_lib_$ac_lib_var=no"
4802 fi
4803 rm -f conftest*
4804 LIBS="$ac_save_LIBS"
4805
4806 fi
4807 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4808   echo "$ac_t""yes" 1>&6
4809   libm="-lm"
4810 else
4811   echo "$ac_t""no" 1>&6
4812 fi
4813
4814   ac_save_LIBS="$LIBS"
4815   LIBS="$LIBS $libm"
4816
4817     for ac_func in strtof strtold
4818 do
4819 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4820 echo "configure:4821: checking for $ac_func" >&5
4821 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4822   echo $ac_n "(cached) $ac_c" 1>&6
4823 else
4824   cat > conftest.$ac_ext <<EOF
4825 #line 4826 "configure"
4826 #include "confdefs.h"
4827 /* System header to define __stub macros and hopefully few prototypes,
4828     which can conflict with char $ac_func(); below.  */
4829 #include <assert.h>
4830 /* Override any gcc2 internal prototype to avoid an error.  */
4831 /* We use char because int might match the return type of a gcc2
4832     builtin and then its argument prototype would still apply.  */
4833 char $ac_func();
4834
4835 int main() {
4836
4837 /* The GNU C library defines this for functions which it implements
4838     to always fail with ENOSYS.  Some functions are actually named
4839     something starting with __ and the normal name is an alias.  */
4840 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4841 choke me
4842 #else
4843 $ac_func();
4844 #endif
4845
4846 ; return 0; }
4847 EOF
4848 if { (eval echo configure:4849: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4849   rm -rf conftest*
4850   eval "ac_cv_func_$ac_func=yes"
4851 else
4852   echo "configure: failed program was:" >&5
4853   cat conftest.$ac_ext >&5
4854   rm -rf conftest*
4855   eval "ac_cv_func_$ac_func=no"
4856 fi
4857 rm -f conftest*
4858 fi
4859
4860 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4861   echo "$ac_t""yes" 1>&6
4862     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4863   cat >> confdefs.h <<EOF
4864 #define $ac_tr_func 1
4865 EOF
4866
4867 else
4868   echo "$ac_t""no" 1>&6
4869 fi
4870 done
4871
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 isinf declaration""... $ac_c" 1>&6
4883 echo "configure:4884: checking for isinf declaration" >&5
4884   cat > conftest.$ac_ext <<EOF
4885 #line 4886 "configure"
4886 #include "confdefs.h"
4887 #include <math.h>
4888 int main() {
4889  isinf(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_isinf=yes
4895 else
4896   echo "configure: failed program was:" >&5
4897   cat conftest.$ac_ext >&5
4898   rm -rf conftest*
4899   use_isinf=no
4900 fi
4901 rm -f conftest*
4902   echo "$ac_t""$use_isinf" 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_isinf = x"yes"; then
4911     for ac_func in isinf
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 isnan declaration""... $ac_c" 1>&6
4978 echo "configure:4979: checking for isnan declaration" >&5
4979   cat > conftest.$ac_ext <<EOF
4980 #line 4981 "configure"
4981 #include "confdefs.h"
4982 #include <math.h>
4983 int main() {
4984  isnan(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_isnan=yes
4990 else
4991   echo "configure: failed program was:" >&5
4992   cat conftest.$ac_ext >&5
4993   rm -rf conftest*
4994   use_isnan=no
4995 fi
4996 rm -f conftest*
4997   echo "$ac_t""$use_isnan" 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_isnan = x"yes"; then
5006     for ac_func in isnan
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 finite declaration""... $ac_c" 1>&6
5073 echo "configure:5074: checking for finite declaration" >&5
5074   cat > conftest.$ac_ext <<EOF
5075 #line 5076 "configure"
5076 #include "confdefs.h"
5077 #include <math.h>
5078 int main() {
5079  finite(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_finite=yes
5085 else
5086   echo "configure: failed program was:" >&5
5087   cat conftest.$ac_ext >&5
5088   rm -rf conftest*
5089   use_finite=no
5090 fi
5091 rm -f conftest*
5092   echo "$ac_t""$use_finite" 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_finite = x"yes"; then
5101     for ac_func in finite
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 copysign declaration""... $ac_c" 1>&6
5168 echo "configure:5169: checking for copysign declaration" >&5
5169   cat > conftest.$ac_ext <<EOF
5170 #line 5171 "configure"
5171 #include "confdefs.h"
5172 #include <math.h>
5173 int main() {
5174  copysign(0, 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_copysign=yes
5180 else
5181   echo "configure: failed program was:" >&5
5182   cat conftest.$ac_ext >&5
5183   rm -rf conftest*
5184   use_copysign=no
5185 fi
5186 rm -f conftest*
5187   echo "$ac_t""$use_copysign" 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_copysign = x"yes"; then
5196     for ac_func in copysign
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 sincos declaration""... $ac_c" 1>&6
5263 echo "configure:5264: checking for sincos declaration" >&5
5264   cat > conftest.$ac_ext <<EOF
5265 #line 5266 "configure"
5266 #include "confdefs.h"
5267 #include <math.h>
5268 int main() {
5269  sincos(0, 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_sincos=yes
5275 else
5276   echo "configure: failed program was:" >&5
5277   cat conftest.$ac_ext >&5
5278   rm -rf conftest*
5279   use_sincos=no
5280 fi
5281 rm -f conftest*
5282   echo "$ac_t""$use_sincos" 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_sincos = x"yes"; then
5291     for ac_func in sincos
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 fpclass declaration""... $ac_c" 1>&6
5358 echo "configure:5359: checking for fpclass declaration" >&5
5359   cat > conftest.$ac_ext <<EOF
5360 #line 5361 "configure"
5361 #include "confdefs.h"
5362 #include <math.h>
5363 int main() {
5364  fpclass(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_fpclass=yes
5370 else
5371   echo "configure: failed program was:" >&5
5372   cat conftest.$ac_ext >&5
5373   rm -rf conftest*
5374   use_fpclass=no
5375 fi
5376 rm -f conftest*
5377   echo "$ac_t""$use_fpclass" 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_fpclass = x"yes"; then
5386     for ac_func in fpclass
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 qfpclass declaration""... $ac_c" 1>&6
5453 echo "configure:5454: checking for qfpclass declaration" >&5
5454   cat > conftest.$ac_ext <<EOF
5455 #line 5456 "configure"
5456 #include "confdefs.h"
5457 #include <math.h>
5458 int main() {
5459  qfpclass(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_qfpclass=yes
5465 else
5466   echo "configure: failed program was:" >&5
5467   cat conftest.$ac_ext >&5
5468   rm -rf conftest*
5469   use_qfpclass=no
5470 fi
5471 rm -f conftest*
5472   echo "$ac_t""$use_qfpclass" 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_qfpclass = x"yes"; then
5481     for ac_func in qfpclass
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
5541   ac_ext=C
5542 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5543 ac_cpp='$CXXCPP $CPPFLAGS'
5544 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5545 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5546 cross_compiling=$ac_cv_prog_cxx_cross
5547
5548   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5549 echo "configure:5550: checking for isnanf declaration" >&5
5550   cat > conftest.$ac_ext <<EOF
5551 #line 5552 "configure"
5552 #include "confdefs.h"
5553 #include <math.h>
5554 int main() {
5555  isnanf(0);
5556 ; return 0; }
5557 EOF
5558 if { (eval echo configure:5559: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5559   rm -rf conftest*
5560   use_isnanf=yes
5561 else
5562   echo "configure: failed program was:" >&5
5563   cat conftest.$ac_ext >&5
5564   rm -rf conftest*
5565   use_isnanf=no
5566 fi
5567 rm -f conftest*
5568   echo "$ac_t""$use_isnanf" 1>&6
5569   ac_ext=c
5570 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5571 ac_cpp='$CPP $CPPFLAGS'
5572 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5573 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5574 cross_compiling=$ac_cv_prog_cc_cross
5575
5576   if test x$use_isnanf = x"yes"; then
5577     for ac_func in isnanf
5578 do
5579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5580 echo "configure:5581: checking for $ac_func" >&5
5581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5582   echo $ac_n "(cached) $ac_c" 1>&6
5583 else
5584   cat > conftest.$ac_ext <<EOF
5585 #line 5586 "configure"
5586 #include "confdefs.h"
5587 /* System header to define __stub macros and hopefully few prototypes,
5588     which can conflict with char $ac_func(); below.  */
5589 #include <assert.h>
5590 /* Override any gcc2 internal prototype to avoid an error.  */
5591 /* We use char because int might match the return type of a gcc2
5592     builtin and then its argument prototype would still apply.  */
5593 char $ac_func();
5594
5595 int main() {
5596
5597 /* The GNU C library defines this for functions which it implements
5598     to always fail with ENOSYS.  Some functions are actually named
5599     something starting with __ and the normal name is an alias.  */
5600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5601 choke me
5602 #else
5603 $ac_func();
5604 #endif
5605
5606 ; return 0; }
5607 EOF
5608 if { (eval echo configure:5609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5609   rm -rf conftest*
5610   eval "ac_cv_func_$ac_func=yes"
5611 else
5612   echo "configure: failed program was:" >&5
5613   cat conftest.$ac_ext >&5
5614   rm -rf conftest*
5615   eval "ac_cv_func_$ac_func=no"
5616 fi
5617 rm -f conftest*
5618 fi
5619
5620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5621   echo "$ac_t""yes" 1>&6
5622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5623   cat >> confdefs.h <<EOF
5624 #define $ac_tr_func 1
5625 EOF
5626
5627 else
5628   echo "$ac_t""no" 1>&6
5629 fi
5630 done
5631
5632   fi
5633
5634
5635
5636   ac_ext=C
5637 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5638 ac_cpp='$CXXCPP $CPPFLAGS'
5639 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5640 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5641 cross_compiling=$ac_cv_prog_cxx_cross
5642
5643   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5644 echo "configure:5645: checking for isinff declaration" >&5
5645   cat > conftest.$ac_ext <<EOF
5646 #line 5647 "configure"
5647 #include "confdefs.h"
5648 #include <math.h>
5649 int main() {
5650  isinff(0);
5651 ; return 0; }
5652 EOF
5653 if { (eval echo configure:5654: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5654   rm -rf conftest*
5655   use_isinff=yes
5656 else
5657   echo "configure: failed program was:" >&5
5658   cat conftest.$ac_ext >&5
5659   rm -rf conftest*
5660   use_isinff=no
5661 fi
5662 rm -f conftest*
5663   echo "$ac_t""$use_isinff" 1>&6
5664   ac_ext=c
5665 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5666 ac_cpp='$CPP $CPPFLAGS'
5667 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5668 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5669 cross_compiling=$ac_cv_prog_cc_cross
5670
5671   if test x$use_isinff = x"yes"; then
5672     for ac_func in isinff
5673 do
5674 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5675 echo "configure:5676: checking for $ac_func" >&5
5676 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5677   echo $ac_n "(cached) $ac_c" 1>&6
5678 else
5679   cat > conftest.$ac_ext <<EOF
5680 #line 5681 "configure"
5681 #include "confdefs.h"
5682 /* System header to define __stub macros and hopefully few prototypes,
5683     which can conflict with char $ac_func(); below.  */
5684 #include <assert.h>
5685 /* Override any gcc2 internal prototype to avoid an error.  */
5686 /* We use char because int might match the return type of a gcc2
5687     builtin and then its argument prototype would still apply.  */
5688 char $ac_func();
5689
5690 int main() {
5691
5692 /* The GNU C library defines this for functions which it implements
5693     to always fail with ENOSYS.  Some functions are actually named
5694     something starting with __ and the normal name is an alias.  */
5695 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5696 choke me
5697 #else
5698 $ac_func();
5699 #endif
5700
5701 ; return 0; }
5702 EOF
5703 if { (eval echo configure:5704: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5704   rm -rf conftest*
5705   eval "ac_cv_func_$ac_func=yes"
5706 else
5707   echo "configure: failed program was:" >&5
5708   cat conftest.$ac_ext >&5
5709   rm -rf conftest*
5710   eval "ac_cv_func_$ac_func=no"
5711 fi
5712 rm -f conftest*
5713 fi
5714
5715 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5716   echo "$ac_t""yes" 1>&6
5717     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5718   cat >> confdefs.h <<EOF
5719 #define $ac_tr_func 1
5720 EOF
5721
5722 else
5723   echo "$ac_t""no" 1>&6
5724 fi
5725 done
5726
5727   fi
5728
5729
5730
5731   ac_ext=C
5732 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5733 ac_cpp='$CXXCPP $CPPFLAGS'
5734 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5735 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5736 cross_compiling=$ac_cv_prog_cxx_cross
5737
5738   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5739 echo "configure:5740: checking for acosf declaration" >&5
5740   cat > conftest.$ac_ext <<EOF
5741 #line 5742 "configure"
5742 #include "confdefs.h"
5743 #include <math.h>
5744 int main() {
5745  acosf(0);
5746 ; return 0; }
5747 EOF
5748 if { (eval echo configure:5749: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5749   rm -rf conftest*
5750   use_acosf=yes
5751 else
5752   echo "configure: failed program was:" >&5
5753   cat conftest.$ac_ext >&5
5754   rm -rf conftest*
5755   use_acosf=no
5756 fi
5757 rm -f conftest*
5758   echo "$ac_t""$use_acosf" 1>&6
5759   ac_ext=c
5760 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5761 ac_cpp='$CPP $CPPFLAGS'
5762 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5763 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5764 cross_compiling=$ac_cv_prog_cc_cross
5765
5766   if test x$use_acosf = x"yes"; then
5767     for ac_func in acosf
5768 do
5769 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5770 echo "configure:5771: checking for $ac_func" >&5
5771 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5772   echo $ac_n "(cached) $ac_c" 1>&6
5773 else
5774   cat > conftest.$ac_ext <<EOF
5775 #line 5776 "configure"
5776 #include "confdefs.h"
5777 /* System header to define __stub macros and hopefully few prototypes,
5778     which can conflict with char $ac_func(); below.  */
5779 #include <assert.h>
5780 /* Override any gcc2 internal prototype to avoid an error.  */
5781 /* We use char because int might match the return type of a gcc2
5782     builtin and then its argument prototype would still apply.  */
5783 char $ac_func();
5784
5785 int main() {
5786
5787 /* The GNU C library defines this for functions which it implements
5788     to always fail with ENOSYS.  Some functions are actually named
5789     something starting with __ and the normal name is an alias.  */
5790 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5791 choke me
5792 #else
5793 $ac_func();
5794 #endif
5795
5796 ; return 0; }
5797 EOF
5798 if { (eval echo configure:5799: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5799   rm -rf conftest*
5800   eval "ac_cv_func_$ac_func=yes"
5801 else
5802   echo "configure: failed program was:" >&5
5803   cat conftest.$ac_ext >&5
5804   rm -rf conftest*
5805   eval "ac_cv_func_$ac_func=no"
5806 fi
5807 rm -f conftest*
5808 fi
5809
5810 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5811   echo "$ac_t""yes" 1>&6
5812     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5813   cat >> confdefs.h <<EOF
5814 #define $ac_tr_func 1
5815 EOF
5816
5817 else
5818   echo "$ac_t""no" 1>&6
5819 fi
5820 done
5821
5822   fi
5823
5824
5825
5826   ac_ext=C
5827 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5828 ac_cpp='$CXXCPP $CPPFLAGS'
5829 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5830 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5831 cross_compiling=$ac_cv_prog_cxx_cross
5832
5833   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5834 echo "configure:5835: checking for asinf declaration" >&5
5835   cat > conftest.$ac_ext <<EOF
5836 #line 5837 "configure"
5837 #include "confdefs.h"
5838 #include <math.h>
5839 int main() {
5840  asinf(0);
5841 ; return 0; }
5842 EOF
5843 if { (eval echo configure:5844: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5844   rm -rf conftest*
5845   use_asinf=yes
5846 else
5847   echo "configure: failed program was:" >&5
5848   cat conftest.$ac_ext >&5
5849   rm -rf conftest*
5850   use_asinf=no
5851 fi
5852 rm -f conftest*
5853   echo "$ac_t""$use_asinf" 1>&6
5854   ac_ext=c
5855 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5856 ac_cpp='$CPP $CPPFLAGS'
5857 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5858 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5859 cross_compiling=$ac_cv_prog_cc_cross
5860
5861   if test x$use_asinf = x"yes"; then
5862     for ac_func in asinf
5863 do
5864 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5865 echo "configure:5866: checking for $ac_func" >&5
5866 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5867   echo $ac_n "(cached) $ac_c" 1>&6
5868 else
5869   cat > conftest.$ac_ext <<EOF
5870 #line 5871 "configure"
5871 #include "confdefs.h"
5872 /* System header to define __stub macros and hopefully few prototypes,
5873     which can conflict with char $ac_func(); below.  */
5874 #include <assert.h>
5875 /* Override any gcc2 internal prototype to avoid an error.  */
5876 /* We use char because int might match the return type of a gcc2
5877     builtin and then its argument prototype would still apply.  */
5878 char $ac_func();
5879
5880 int main() {
5881
5882 /* The GNU C library defines this for functions which it implements
5883     to always fail with ENOSYS.  Some functions are actually named
5884     something starting with __ and the normal name is an alias.  */
5885 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5886 choke me
5887 #else
5888 $ac_func();
5889 #endif
5890
5891 ; return 0; }
5892 EOF
5893 if { (eval echo configure:5894: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5894   rm -rf conftest*
5895   eval "ac_cv_func_$ac_func=yes"
5896 else
5897   echo "configure: failed program was:" >&5
5898   cat conftest.$ac_ext >&5
5899   rm -rf conftest*
5900   eval "ac_cv_func_$ac_func=no"
5901 fi
5902 rm -f conftest*
5903 fi
5904
5905 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5906   echo "$ac_t""yes" 1>&6
5907     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5908   cat >> confdefs.h <<EOF
5909 #define $ac_tr_func 1
5910 EOF
5911
5912 else
5913   echo "$ac_t""no" 1>&6
5914 fi
5915 done
5916
5917   fi
5918
5919
5920
5921   ac_ext=C
5922 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5923 ac_cpp='$CXXCPP $CPPFLAGS'
5924 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5925 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5926 cross_compiling=$ac_cv_prog_cxx_cross
5927
5928   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5929 echo "configure:5930: checking for atanf declaration" >&5
5930   cat > conftest.$ac_ext <<EOF
5931 #line 5932 "configure"
5932 #include "confdefs.h"
5933 #include <math.h>
5934 int main() {
5935  atanf(0);
5936 ; return 0; }
5937 EOF
5938 if { (eval echo configure:5939: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5939   rm -rf conftest*
5940   use_atanf=yes
5941 else
5942   echo "configure: failed program was:" >&5
5943   cat conftest.$ac_ext >&5
5944   rm -rf conftest*
5945   use_atanf=no
5946 fi
5947 rm -f conftest*
5948   echo "$ac_t""$use_atanf" 1>&6
5949   ac_ext=c
5950 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5951 ac_cpp='$CPP $CPPFLAGS'
5952 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5953 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5954 cross_compiling=$ac_cv_prog_cc_cross
5955
5956   if test x$use_atanf = x"yes"; then
5957     for ac_func in atanf
5958 do
5959 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5960 echo "configure:5961: checking for $ac_func" >&5
5961 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5962   echo $ac_n "(cached) $ac_c" 1>&6
5963 else
5964   cat > conftest.$ac_ext <<EOF
5965 #line 5966 "configure"
5966 #include "confdefs.h"
5967 /* System header to define __stub macros and hopefully few prototypes,
5968     which can conflict with char $ac_func(); below.  */
5969 #include <assert.h>
5970 /* Override any gcc2 internal prototype to avoid an error.  */
5971 /* We use char because int might match the return type of a gcc2
5972     builtin and then its argument prototype would still apply.  */
5973 char $ac_func();
5974
5975 int main() {
5976
5977 /* The GNU C library defines this for functions which it implements
5978     to always fail with ENOSYS.  Some functions are actually named
5979     something starting with __ and the normal name is an alias.  */
5980 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5981 choke me
5982 #else
5983 $ac_func();
5984 #endif
5985
5986 ; return 0; }
5987 EOF
5988 if { (eval echo configure:5989: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5989   rm -rf conftest*
5990   eval "ac_cv_func_$ac_func=yes"
5991 else
5992   echo "configure: failed program was:" >&5
5993   cat conftest.$ac_ext >&5
5994   rm -rf conftest*
5995   eval "ac_cv_func_$ac_func=no"
5996 fi
5997 rm -f conftest*
5998 fi
5999
6000 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6001   echo "$ac_t""yes" 1>&6
6002     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6003   cat >> confdefs.h <<EOF
6004 #define $ac_tr_func 1
6005 EOF
6006
6007 else
6008   echo "$ac_t""no" 1>&6
6009 fi
6010 done
6011
6012   fi
6013
6014
6015
6016   ac_ext=C
6017 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6018 ac_cpp='$CXXCPP $CPPFLAGS'
6019 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6020 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6021 cross_compiling=$ac_cv_prog_cxx_cross
6022
6023   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
6024 echo "configure:6025: checking for atan2f declaration" >&5
6025   cat > conftest.$ac_ext <<EOF
6026 #line 6027 "configure"
6027 #include "confdefs.h"
6028 #include <math.h>
6029 int main() {
6030  atan2f(0, 0);
6031 ; return 0; }
6032 EOF
6033 if { (eval echo configure:6034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6034   rm -rf conftest*
6035   use_atan2f=yes
6036 else
6037   echo "configure: failed program was:" >&5
6038   cat conftest.$ac_ext >&5
6039   rm -rf conftest*
6040   use_atan2f=no
6041 fi
6042 rm -f conftest*
6043   echo "$ac_t""$use_atan2f" 1>&6
6044   ac_ext=c
6045 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6046 ac_cpp='$CPP $CPPFLAGS'
6047 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6048 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6049 cross_compiling=$ac_cv_prog_cc_cross
6050
6051   if test x$use_atan2f = x"yes"; then
6052     for ac_func in atan2f
6053 do
6054 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6055 echo "configure:6056: checking for $ac_func" >&5
6056 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6057   echo $ac_n "(cached) $ac_c" 1>&6
6058 else
6059   cat > conftest.$ac_ext <<EOF
6060 #line 6061 "configure"
6061 #include "confdefs.h"
6062 /* System header to define __stub macros and hopefully few prototypes,
6063     which can conflict with char $ac_func(); below.  */
6064 #include <assert.h>
6065 /* Override any gcc2 internal prototype to avoid an error.  */
6066 /* We use char because int might match the return type of a gcc2
6067     builtin and then its argument prototype would still apply.  */
6068 char $ac_func();
6069
6070 int main() {
6071
6072 /* The GNU C library defines this for functions which it implements
6073     to always fail with ENOSYS.  Some functions are actually named
6074     something starting with __ and the normal name is an alias.  */
6075 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6076 choke me
6077 #else
6078 $ac_func();
6079 #endif
6080
6081 ; return 0; }
6082 EOF
6083 if { (eval echo configure:6084: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6084   rm -rf conftest*
6085   eval "ac_cv_func_$ac_func=yes"
6086 else
6087   echo "configure: failed program was:" >&5
6088   cat conftest.$ac_ext >&5
6089   rm -rf conftest*
6090   eval "ac_cv_func_$ac_func=no"
6091 fi
6092 rm -f conftest*
6093 fi
6094
6095 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6096   echo "$ac_t""yes" 1>&6
6097     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6098   cat >> confdefs.h <<EOF
6099 #define $ac_tr_func 1
6100 EOF
6101
6102 else
6103   echo "$ac_t""no" 1>&6
6104 fi
6105 done
6106
6107   fi
6108
6109
6110
6111   ac_ext=C
6112 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6113 ac_cpp='$CXXCPP $CPPFLAGS'
6114 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6115 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6116 cross_compiling=$ac_cv_prog_cxx_cross
6117
6118   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6119 echo "configure:6120: checking for ceilf declaration" >&5
6120   cat > conftest.$ac_ext <<EOF
6121 #line 6122 "configure"
6122 #include "confdefs.h"
6123 #include <math.h>
6124 int main() {
6125  ceilf(0);
6126 ; return 0; }
6127 EOF
6128 if { (eval echo configure:6129: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6129   rm -rf conftest*
6130   use_ceilf=yes
6131 else
6132   echo "configure: failed program was:" >&5
6133   cat conftest.$ac_ext >&5
6134   rm -rf conftest*
6135   use_ceilf=no
6136 fi
6137 rm -f conftest*
6138   echo "$ac_t""$use_ceilf" 1>&6
6139   ac_ext=c
6140 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6141 ac_cpp='$CPP $CPPFLAGS'
6142 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6143 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6144 cross_compiling=$ac_cv_prog_cc_cross
6145
6146   if test x$use_ceilf = x"yes"; then
6147     for ac_func in ceilf
6148 do
6149 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6150 echo "configure:6151: checking for $ac_func" >&5
6151 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6152   echo $ac_n "(cached) $ac_c" 1>&6
6153 else
6154   cat > conftest.$ac_ext <<EOF
6155 #line 6156 "configure"
6156 #include "confdefs.h"
6157 /* System header to define __stub macros and hopefully few prototypes,
6158     which can conflict with char $ac_func(); below.  */
6159 #include <assert.h>
6160 /* Override any gcc2 internal prototype to avoid an error.  */
6161 /* We use char because int might match the return type of a gcc2
6162     builtin and then its argument prototype would still apply.  */
6163 char $ac_func();
6164
6165 int main() {
6166
6167 /* The GNU C library defines this for functions which it implements
6168     to always fail with ENOSYS.  Some functions are actually named
6169     something starting with __ and the normal name is an alias.  */
6170 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6171 choke me
6172 #else
6173 $ac_func();
6174 #endif
6175
6176 ; return 0; }
6177 EOF
6178 if { (eval echo configure:6179: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6179   rm -rf conftest*
6180   eval "ac_cv_func_$ac_func=yes"
6181 else
6182   echo "configure: failed program was:" >&5
6183   cat conftest.$ac_ext >&5
6184   rm -rf conftest*
6185   eval "ac_cv_func_$ac_func=no"
6186 fi
6187 rm -f conftest*
6188 fi
6189
6190 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6191   echo "$ac_t""yes" 1>&6
6192     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6193   cat >> confdefs.h <<EOF
6194 #define $ac_tr_func 1
6195 EOF
6196
6197 else
6198   echo "$ac_t""no" 1>&6
6199 fi
6200 done
6201
6202   fi
6203
6204
6205
6206   ac_ext=C
6207 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6208 ac_cpp='$CXXCPP $CPPFLAGS'
6209 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6210 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6211 cross_compiling=$ac_cv_prog_cxx_cross
6212
6213   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6214 echo "configure:6215: checking for cosf declaration" >&5
6215   cat > conftest.$ac_ext <<EOF
6216 #line 6217 "configure"
6217 #include "confdefs.h"
6218 #include <math.h>
6219 int main() {
6220  cosf(0);
6221 ; return 0; }
6222 EOF
6223 if { (eval echo configure:6224: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6224   rm -rf conftest*
6225   use_cosf=yes
6226 else
6227   echo "configure: failed program was:" >&5
6228   cat conftest.$ac_ext >&5
6229   rm -rf conftest*
6230   use_cosf=no
6231 fi
6232 rm -f conftest*
6233   echo "$ac_t""$use_cosf" 1>&6
6234   ac_ext=c
6235 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6236 ac_cpp='$CPP $CPPFLAGS'
6237 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6238 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6239 cross_compiling=$ac_cv_prog_cc_cross
6240
6241   if test x$use_cosf = x"yes"; then
6242     for ac_func in cosf
6243 do
6244 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6245 echo "configure:6246: checking for $ac_func" >&5
6246 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6247   echo $ac_n "(cached) $ac_c" 1>&6
6248 else
6249   cat > conftest.$ac_ext <<EOF
6250 #line 6251 "configure"
6251 #include "confdefs.h"
6252 /* System header to define __stub macros and hopefully few prototypes,
6253     which can conflict with char $ac_func(); below.  */
6254 #include <assert.h>
6255 /* Override any gcc2 internal prototype to avoid an error.  */
6256 /* We use char because int might match the return type of a gcc2
6257     builtin and then its argument prototype would still apply.  */
6258 char $ac_func();
6259
6260 int main() {
6261
6262 /* The GNU C library defines this for functions which it implements
6263     to always fail with ENOSYS.  Some functions are actually named
6264     something starting with __ and the normal name is an alias.  */
6265 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6266 choke me
6267 #else
6268 $ac_func();
6269 #endif
6270
6271 ; return 0; }
6272 EOF
6273 if { (eval echo configure:6274: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6274   rm -rf conftest*
6275   eval "ac_cv_func_$ac_func=yes"
6276 else
6277   echo "configure: failed program was:" >&5
6278   cat conftest.$ac_ext >&5
6279   rm -rf conftest*
6280   eval "ac_cv_func_$ac_func=no"
6281 fi
6282 rm -f conftest*
6283 fi
6284
6285 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6286   echo "$ac_t""yes" 1>&6
6287     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6288   cat >> confdefs.h <<EOF
6289 #define $ac_tr_func 1
6290 EOF
6291
6292 else
6293   echo "$ac_t""no" 1>&6
6294 fi
6295 done
6296
6297   fi
6298
6299
6300
6301   ac_ext=C
6302 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6303 ac_cpp='$CXXCPP $CPPFLAGS'
6304 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6305 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6306 cross_compiling=$ac_cv_prog_cxx_cross
6307
6308   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6309 echo "configure:6310: checking for coshf declaration" >&5
6310   cat > conftest.$ac_ext <<EOF
6311 #line 6312 "configure"
6312 #include "confdefs.h"
6313 #include <math.h>
6314 int main() {
6315  coshf(0);
6316 ; return 0; }
6317 EOF
6318 if { (eval echo configure:6319: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6319   rm -rf conftest*
6320   use_coshf=yes
6321 else
6322   echo "configure: failed program was:" >&5
6323   cat conftest.$ac_ext >&5
6324   rm -rf conftest*
6325   use_coshf=no
6326 fi
6327 rm -f conftest*
6328   echo "$ac_t""$use_coshf" 1>&6
6329   ac_ext=c
6330 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6331 ac_cpp='$CPP $CPPFLAGS'
6332 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6333 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6334 cross_compiling=$ac_cv_prog_cc_cross
6335
6336   if test x$use_coshf = x"yes"; then
6337     for ac_func in coshf
6338 do
6339 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6340 echo "configure:6341: checking for $ac_func" >&5
6341 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6342   echo $ac_n "(cached) $ac_c" 1>&6
6343 else
6344   cat > conftest.$ac_ext <<EOF
6345 #line 6346 "configure"
6346 #include "confdefs.h"
6347 /* System header to define __stub macros and hopefully few prototypes,
6348     which can conflict with char $ac_func(); below.  */
6349 #include <assert.h>
6350 /* Override any gcc2 internal prototype to avoid an error.  */
6351 /* We use char because int might match the return type of a gcc2
6352     builtin and then its argument prototype would still apply.  */
6353 char $ac_func();
6354
6355 int main() {
6356
6357 /* The GNU C library defines this for functions which it implements
6358     to always fail with ENOSYS.  Some functions are actually named
6359     something starting with __ and the normal name is an alias.  */
6360 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6361 choke me
6362 #else
6363 $ac_func();
6364 #endif
6365
6366 ; return 0; }
6367 EOF
6368 if { (eval echo configure:6369: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6369   rm -rf conftest*
6370   eval "ac_cv_func_$ac_func=yes"
6371 else
6372   echo "configure: failed program was:" >&5
6373   cat conftest.$ac_ext >&5
6374   rm -rf conftest*
6375   eval "ac_cv_func_$ac_func=no"
6376 fi
6377 rm -f conftest*
6378 fi
6379
6380 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6381   echo "$ac_t""yes" 1>&6
6382     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6383   cat >> confdefs.h <<EOF
6384 #define $ac_tr_func 1
6385 EOF
6386
6387 else
6388   echo "$ac_t""no" 1>&6
6389 fi
6390 done
6391
6392   fi
6393
6394
6395
6396   ac_ext=C
6397 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6398 ac_cpp='$CXXCPP $CPPFLAGS'
6399 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6400 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6401 cross_compiling=$ac_cv_prog_cxx_cross
6402
6403   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6404 echo "configure:6405: checking for expf declaration" >&5
6405   cat > conftest.$ac_ext <<EOF
6406 #line 6407 "configure"
6407 #include "confdefs.h"
6408 #include <math.h>
6409 int main() {
6410  expf(0);
6411 ; return 0; }
6412 EOF
6413 if { (eval echo configure:6414: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6414   rm -rf conftest*
6415   use_expf=yes
6416 else
6417   echo "configure: failed program was:" >&5
6418   cat conftest.$ac_ext >&5
6419   rm -rf conftest*
6420   use_expf=no
6421 fi
6422 rm -f conftest*
6423   echo "$ac_t""$use_expf" 1>&6
6424   ac_ext=c
6425 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6426 ac_cpp='$CPP $CPPFLAGS'
6427 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6428 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6429 cross_compiling=$ac_cv_prog_cc_cross
6430
6431   if test x$use_expf = x"yes"; then
6432     for ac_func in expf
6433 do
6434 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6435 echo "configure:6436: checking for $ac_func" >&5
6436 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6437   echo $ac_n "(cached) $ac_c" 1>&6
6438 else
6439   cat > conftest.$ac_ext <<EOF
6440 #line 6441 "configure"
6441 #include "confdefs.h"
6442 /* System header to define __stub macros and hopefully few prototypes,
6443     which can conflict with char $ac_func(); below.  */
6444 #include <assert.h>
6445 /* Override any gcc2 internal prototype to avoid an error.  */
6446 /* We use char because int might match the return type of a gcc2
6447     builtin and then its argument prototype would still apply.  */
6448 char $ac_func();
6449
6450 int main() {
6451
6452 /* The GNU C library defines this for functions which it implements
6453     to always fail with ENOSYS.  Some functions are actually named
6454     something starting with __ and the normal name is an alias.  */
6455 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6456 choke me
6457 #else
6458 $ac_func();
6459 #endif
6460
6461 ; return 0; }
6462 EOF
6463 if { (eval echo configure:6464: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6464   rm -rf conftest*
6465   eval "ac_cv_func_$ac_func=yes"
6466 else
6467   echo "configure: failed program was:" >&5
6468   cat conftest.$ac_ext >&5
6469   rm -rf conftest*
6470   eval "ac_cv_func_$ac_func=no"
6471 fi
6472 rm -f conftest*
6473 fi
6474
6475 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6476   echo "$ac_t""yes" 1>&6
6477     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6478   cat >> confdefs.h <<EOF
6479 #define $ac_tr_func 1
6480 EOF
6481
6482 else
6483   echo "$ac_t""no" 1>&6
6484 fi
6485 done
6486
6487   fi
6488
6489
6490
6491   ac_ext=C
6492 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6493 ac_cpp='$CXXCPP $CPPFLAGS'
6494 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6495 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6496 cross_compiling=$ac_cv_prog_cxx_cross
6497
6498   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6499 echo "configure:6500: checking for fabsf declaration" >&5
6500   cat > conftest.$ac_ext <<EOF
6501 #line 6502 "configure"
6502 #include "confdefs.h"
6503 #include <math.h>
6504 int main() {
6505  fabsf(0);
6506 ; return 0; }
6507 EOF
6508 if { (eval echo configure:6509: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6509   rm -rf conftest*
6510   use_fabsf=yes
6511 else
6512   echo "configure: failed program was:" >&5
6513   cat conftest.$ac_ext >&5
6514   rm -rf conftest*
6515   use_fabsf=no
6516 fi
6517 rm -f conftest*
6518   echo "$ac_t""$use_fabsf" 1>&6
6519   ac_ext=c
6520 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6521 ac_cpp='$CPP $CPPFLAGS'
6522 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6523 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6524 cross_compiling=$ac_cv_prog_cc_cross
6525
6526   if test x$use_fabsf = x"yes"; then
6527     for ac_func in fabsf
6528 do
6529 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6530 echo "configure:6531: checking for $ac_func" >&5
6531 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6532   echo $ac_n "(cached) $ac_c" 1>&6
6533 else
6534   cat > conftest.$ac_ext <<EOF
6535 #line 6536 "configure"
6536 #include "confdefs.h"
6537 /* System header to define __stub macros and hopefully few prototypes,
6538     which can conflict with char $ac_func(); below.  */
6539 #include <assert.h>
6540 /* Override any gcc2 internal prototype to avoid an error.  */
6541 /* We use char because int might match the return type of a gcc2
6542     builtin and then its argument prototype would still apply.  */
6543 char $ac_func();
6544
6545 int main() {
6546
6547 /* The GNU C library defines this for functions which it implements
6548     to always fail with ENOSYS.  Some functions are actually named
6549     something starting with __ and the normal name is an alias.  */
6550 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6551 choke me
6552 #else
6553 $ac_func();
6554 #endif
6555
6556 ; return 0; }
6557 EOF
6558 if { (eval echo configure:6559: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6559   rm -rf conftest*
6560   eval "ac_cv_func_$ac_func=yes"
6561 else
6562   echo "configure: failed program was:" >&5
6563   cat conftest.$ac_ext >&5
6564   rm -rf conftest*
6565   eval "ac_cv_func_$ac_func=no"
6566 fi
6567 rm -f conftest*
6568 fi
6569
6570 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6571   echo "$ac_t""yes" 1>&6
6572     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6573   cat >> confdefs.h <<EOF
6574 #define $ac_tr_func 1
6575 EOF
6576
6577 else
6578   echo "$ac_t""no" 1>&6
6579 fi
6580 done
6581
6582   fi
6583
6584
6585
6586   ac_ext=C
6587 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6588 ac_cpp='$CXXCPP $CPPFLAGS'
6589 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6590 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6591 cross_compiling=$ac_cv_prog_cxx_cross
6592
6593   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6594 echo "configure:6595: checking for floorf declaration" >&5
6595   cat > conftest.$ac_ext <<EOF
6596 #line 6597 "configure"
6597 #include "confdefs.h"
6598 #include <math.h>
6599 int main() {
6600  floorf(0);
6601 ; return 0; }
6602 EOF
6603 if { (eval echo configure:6604: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6604   rm -rf conftest*
6605   use_floorf=yes
6606 else
6607   echo "configure: failed program was:" >&5
6608   cat conftest.$ac_ext >&5
6609   rm -rf conftest*
6610   use_floorf=no
6611 fi
6612 rm -f conftest*
6613   echo "$ac_t""$use_floorf" 1>&6
6614   ac_ext=c
6615 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6616 ac_cpp='$CPP $CPPFLAGS'
6617 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6618 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6619 cross_compiling=$ac_cv_prog_cc_cross
6620
6621   if test x$use_floorf = x"yes"; then
6622     for ac_func in floorf
6623 do
6624 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6625 echo "configure:6626: checking for $ac_func" >&5
6626 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6627   echo $ac_n "(cached) $ac_c" 1>&6
6628 else
6629   cat > conftest.$ac_ext <<EOF
6630 #line 6631 "configure"
6631 #include "confdefs.h"
6632 /* System header to define __stub macros and hopefully few prototypes,
6633     which can conflict with char $ac_func(); below.  */
6634 #include <assert.h>
6635 /* Override any gcc2 internal prototype to avoid an error.  */
6636 /* We use char because int might match the return type of a gcc2
6637     builtin and then its argument prototype would still apply.  */
6638 char $ac_func();
6639
6640 int main() {
6641
6642 /* The GNU C library defines this for functions which it implements
6643     to always fail with ENOSYS.  Some functions are actually named
6644     something starting with __ and the normal name is an alias.  */
6645 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6646 choke me
6647 #else
6648 $ac_func();
6649 #endif
6650
6651 ; return 0; }
6652 EOF
6653 if { (eval echo configure:6654: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6654   rm -rf conftest*
6655   eval "ac_cv_func_$ac_func=yes"
6656 else
6657   echo "configure: failed program was:" >&5
6658   cat conftest.$ac_ext >&5
6659   rm -rf conftest*
6660   eval "ac_cv_func_$ac_func=no"
6661 fi
6662 rm -f conftest*
6663 fi
6664
6665 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6666   echo "$ac_t""yes" 1>&6
6667     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6668   cat >> confdefs.h <<EOF
6669 #define $ac_tr_func 1
6670 EOF
6671
6672 else
6673   echo "$ac_t""no" 1>&6
6674 fi
6675 done
6676
6677   fi
6678
6679
6680
6681   ac_ext=C
6682 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6683 ac_cpp='$CXXCPP $CPPFLAGS'
6684 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6685 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6686 cross_compiling=$ac_cv_prog_cxx_cross
6687
6688   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6689 echo "configure:6690: checking for fmodf declaration" >&5
6690   cat > conftest.$ac_ext <<EOF
6691 #line 6692 "configure"
6692 #include "confdefs.h"
6693 #include <math.h>
6694 int main() {
6695  fmodf(0, 0);
6696 ; return 0; }
6697 EOF
6698 if { (eval echo configure:6699: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6699   rm -rf conftest*
6700   use_fmodf=yes
6701 else
6702   echo "configure: failed program was:" >&5
6703   cat conftest.$ac_ext >&5
6704   rm -rf conftest*
6705   use_fmodf=no
6706 fi
6707 rm -f conftest*
6708   echo "$ac_t""$use_fmodf" 1>&6
6709   ac_ext=c
6710 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6711 ac_cpp='$CPP $CPPFLAGS'
6712 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6713 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6714 cross_compiling=$ac_cv_prog_cc_cross
6715
6716   if test x$use_fmodf = x"yes"; then
6717     for ac_func in fmodf
6718 do
6719 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6720 echo "configure:6721: checking for $ac_func" >&5
6721 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6722   echo $ac_n "(cached) $ac_c" 1>&6
6723 else
6724   cat > conftest.$ac_ext <<EOF
6725 #line 6726 "configure"
6726 #include "confdefs.h"
6727 /* System header to define __stub macros and hopefully few prototypes,
6728     which can conflict with char $ac_func(); below.  */
6729 #include <assert.h>
6730 /* Override any gcc2 internal prototype to avoid an error.  */
6731 /* We use char because int might match the return type of a gcc2
6732     builtin and then its argument prototype would still apply.  */
6733 char $ac_func();
6734
6735 int main() {
6736
6737 /* The GNU C library defines this for functions which it implements
6738     to always fail with ENOSYS.  Some functions are actually named
6739     something starting with __ and the normal name is an alias.  */
6740 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6741 choke me
6742 #else
6743 $ac_func();
6744 #endif
6745
6746 ; return 0; }
6747 EOF
6748 if { (eval echo configure:6749: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6749   rm -rf conftest*
6750   eval "ac_cv_func_$ac_func=yes"
6751 else
6752   echo "configure: failed program was:" >&5
6753   cat conftest.$ac_ext >&5
6754   rm -rf conftest*
6755   eval "ac_cv_func_$ac_func=no"
6756 fi
6757 rm -f conftest*
6758 fi
6759
6760 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6761   echo "$ac_t""yes" 1>&6
6762     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6763   cat >> confdefs.h <<EOF
6764 #define $ac_tr_func 1
6765 EOF
6766
6767 else
6768   echo "$ac_t""no" 1>&6
6769 fi
6770 done
6771
6772   fi
6773
6774
6775
6776   ac_ext=C
6777 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6778 ac_cpp='$CXXCPP $CPPFLAGS'
6779 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6780 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6781 cross_compiling=$ac_cv_prog_cxx_cross
6782
6783   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6784 echo "configure:6785: checking for frexpf declaration" >&5
6785   cat > conftest.$ac_ext <<EOF
6786 #line 6787 "configure"
6787 #include "confdefs.h"
6788 #include <math.h>
6789 int main() {
6790  frexpf(0, 0);
6791 ; return 0; }
6792 EOF
6793 if { (eval echo configure:6794: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6794   rm -rf conftest*
6795   use_frexpf=yes
6796 else
6797   echo "configure: failed program was:" >&5
6798   cat conftest.$ac_ext >&5
6799   rm -rf conftest*
6800   use_frexpf=no
6801 fi
6802 rm -f conftest*
6803   echo "$ac_t""$use_frexpf" 1>&6
6804   ac_ext=c
6805 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6806 ac_cpp='$CPP $CPPFLAGS'
6807 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6808 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6809 cross_compiling=$ac_cv_prog_cc_cross
6810
6811   if test x$use_frexpf = x"yes"; then
6812     for ac_func in frexpf
6813 do
6814 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6815 echo "configure:6816: checking for $ac_func" >&5
6816 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6817   echo $ac_n "(cached) $ac_c" 1>&6
6818 else
6819   cat > conftest.$ac_ext <<EOF
6820 #line 6821 "configure"
6821 #include "confdefs.h"
6822 /* System header to define __stub macros and hopefully few prototypes,
6823     which can conflict with char $ac_func(); below.  */
6824 #include <assert.h>
6825 /* Override any gcc2 internal prototype to avoid an error.  */
6826 /* We use char because int might match the return type of a gcc2
6827     builtin and then its argument prototype would still apply.  */
6828 char $ac_func();
6829
6830 int main() {
6831
6832 /* The GNU C library defines this for functions which it implements
6833     to always fail with ENOSYS.  Some functions are actually named
6834     something starting with __ and the normal name is an alias.  */
6835 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6836 choke me
6837 #else
6838 $ac_func();
6839 #endif
6840
6841 ; return 0; }
6842 EOF
6843 if { (eval echo configure:6844: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6844   rm -rf conftest*
6845   eval "ac_cv_func_$ac_func=yes"
6846 else
6847   echo "configure: failed program was:" >&5
6848   cat conftest.$ac_ext >&5
6849   rm -rf conftest*
6850   eval "ac_cv_func_$ac_func=no"
6851 fi
6852 rm -f conftest*
6853 fi
6854
6855 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6856   echo "$ac_t""yes" 1>&6
6857     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6858   cat >> confdefs.h <<EOF
6859 #define $ac_tr_func 1
6860 EOF
6861
6862 else
6863   echo "$ac_t""no" 1>&6
6864 fi
6865 done
6866
6867   fi
6868
6869
6870
6871   ac_ext=C
6872 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6873 ac_cpp='$CXXCPP $CPPFLAGS'
6874 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6875 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6876 cross_compiling=$ac_cv_prog_cxx_cross
6877
6878   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6879 echo "configure:6880: checking for ldexpf declaration" >&5
6880   cat > conftest.$ac_ext <<EOF
6881 #line 6882 "configure"
6882 #include "confdefs.h"
6883 #include <math.h>
6884 int main() {
6885  ldexpf(0, 0);
6886 ; return 0; }
6887 EOF
6888 if { (eval echo configure:6889: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6889   rm -rf conftest*
6890   use_ldexpf=yes
6891 else
6892   echo "configure: failed program was:" >&5
6893   cat conftest.$ac_ext >&5
6894   rm -rf conftest*
6895   use_ldexpf=no
6896 fi
6897 rm -f conftest*
6898   echo "$ac_t""$use_ldexpf" 1>&6
6899   ac_ext=c
6900 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6901 ac_cpp='$CPP $CPPFLAGS'
6902 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6903 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6904 cross_compiling=$ac_cv_prog_cc_cross
6905
6906   if test x$use_ldexpf = x"yes"; then
6907     for ac_func in ldexpf
6908 do
6909 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6910 echo "configure:6911: checking for $ac_func" >&5
6911 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6912   echo $ac_n "(cached) $ac_c" 1>&6
6913 else
6914   cat > conftest.$ac_ext <<EOF
6915 #line 6916 "configure"
6916 #include "confdefs.h"
6917 /* System header to define __stub macros and hopefully few prototypes,
6918     which can conflict with char $ac_func(); below.  */
6919 #include <assert.h>
6920 /* Override any gcc2 internal prototype to avoid an error.  */
6921 /* We use char because int might match the return type of a gcc2
6922     builtin and then its argument prototype would still apply.  */
6923 char $ac_func();
6924
6925 int main() {
6926
6927 /* The GNU C library defines this for functions which it implements
6928     to always fail with ENOSYS.  Some functions are actually named
6929     something starting with __ and the normal name is an alias.  */
6930 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6931 choke me
6932 #else
6933 $ac_func();
6934 #endif
6935
6936 ; return 0; }
6937 EOF
6938 if { (eval echo configure:6939: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6939   rm -rf conftest*
6940   eval "ac_cv_func_$ac_func=yes"
6941 else
6942   echo "configure: failed program was:" >&5
6943   cat conftest.$ac_ext >&5
6944   rm -rf conftest*
6945   eval "ac_cv_func_$ac_func=no"
6946 fi
6947 rm -f conftest*
6948 fi
6949
6950 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6951   echo "$ac_t""yes" 1>&6
6952     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6953   cat >> confdefs.h <<EOF
6954 #define $ac_tr_func 1
6955 EOF
6956
6957 else
6958   echo "$ac_t""no" 1>&6
6959 fi
6960 done
6961
6962   fi
6963
6964
6965
6966   ac_ext=C
6967 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6968 ac_cpp='$CXXCPP $CPPFLAGS'
6969 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6970 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6971 cross_compiling=$ac_cv_prog_cxx_cross
6972
6973   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6974 echo "configure:6975: checking for logf declaration" >&5
6975   cat > conftest.$ac_ext <<EOF
6976 #line 6977 "configure"
6977 #include "confdefs.h"
6978 #include <math.h>
6979 int main() {
6980  logf(0);
6981 ; return 0; }
6982 EOF
6983 if { (eval echo configure:6984: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6984   rm -rf conftest*
6985   use_logf=yes
6986 else
6987   echo "configure: failed program was:" >&5
6988   cat conftest.$ac_ext >&5
6989   rm -rf conftest*
6990   use_logf=no
6991 fi
6992 rm -f conftest*
6993   echo "$ac_t""$use_logf" 1>&6
6994   ac_ext=c
6995 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6996 ac_cpp='$CPP $CPPFLAGS'
6997 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6998 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6999 cross_compiling=$ac_cv_prog_cc_cross
7000
7001   if test x$use_logf = x"yes"; then
7002     for ac_func in logf
7003 do
7004 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7005 echo "configure:7006: checking for $ac_func" >&5
7006 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7007   echo $ac_n "(cached) $ac_c" 1>&6
7008 else
7009   cat > conftest.$ac_ext <<EOF
7010 #line 7011 "configure"
7011 #include "confdefs.h"
7012 /* System header to define __stub macros and hopefully few prototypes,
7013     which can conflict with char $ac_func(); below.  */
7014 #include <assert.h>
7015 /* Override any gcc2 internal prototype to avoid an error.  */
7016 /* We use char because int might match the return type of a gcc2
7017     builtin and then its argument prototype would still apply.  */
7018 char $ac_func();
7019
7020 int main() {
7021
7022 /* The GNU C library defines this for functions which it implements
7023     to always fail with ENOSYS.  Some functions are actually named
7024     something starting with __ and the normal name is an alias.  */
7025 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7026 choke me
7027 #else
7028 $ac_func();
7029 #endif
7030
7031 ; return 0; }
7032 EOF
7033 if { (eval echo configure:7034: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7034   rm -rf conftest*
7035   eval "ac_cv_func_$ac_func=yes"
7036 else
7037   echo "configure: failed program was:" >&5
7038   cat conftest.$ac_ext >&5
7039   rm -rf conftest*
7040   eval "ac_cv_func_$ac_func=no"
7041 fi
7042 rm -f conftest*
7043 fi
7044
7045 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7046   echo "$ac_t""yes" 1>&6
7047     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7048   cat >> confdefs.h <<EOF
7049 #define $ac_tr_func 1
7050 EOF
7051
7052 else
7053   echo "$ac_t""no" 1>&6
7054 fi
7055 done
7056
7057   fi
7058
7059
7060
7061   ac_ext=C
7062 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7063 ac_cpp='$CXXCPP $CPPFLAGS'
7064 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7065 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7066 cross_compiling=$ac_cv_prog_cxx_cross
7067
7068   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7069 echo "configure:7070: checking for log10f declaration" >&5
7070   cat > conftest.$ac_ext <<EOF
7071 #line 7072 "configure"
7072 #include "confdefs.h"
7073 #include <math.h>
7074 int main() {
7075  log10f(0);
7076 ; return 0; }
7077 EOF
7078 if { (eval echo configure:7079: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7079   rm -rf conftest*
7080   use_log10f=yes
7081 else
7082   echo "configure: failed program was:" >&5
7083   cat conftest.$ac_ext >&5
7084   rm -rf conftest*
7085   use_log10f=no
7086 fi
7087 rm -f conftest*
7088   echo "$ac_t""$use_log10f" 1>&6
7089   ac_ext=c
7090 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7091 ac_cpp='$CPP $CPPFLAGS'
7092 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7093 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7094 cross_compiling=$ac_cv_prog_cc_cross
7095
7096   if test x$use_log10f = x"yes"; then
7097     for ac_func in log10f
7098 do
7099 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7100 echo "configure:7101: checking for $ac_func" >&5
7101 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7102   echo $ac_n "(cached) $ac_c" 1>&6
7103 else
7104   cat > conftest.$ac_ext <<EOF
7105 #line 7106 "configure"
7106 #include "confdefs.h"
7107 /* System header to define __stub macros and hopefully few prototypes,
7108     which can conflict with char $ac_func(); below.  */
7109 #include <assert.h>
7110 /* Override any gcc2 internal prototype to avoid an error.  */
7111 /* We use char because int might match the return type of a gcc2
7112     builtin and then its argument prototype would still apply.  */
7113 char $ac_func();
7114
7115 int main() {
7116
7117 /* The GNU C library defines this for functions which it implements
7118     to always fail with ENOSYS.  Some functions are actually named
7119     something starting with __ and the normal name is an alias.  */
7120 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7121 choke me
7122 #else
7123 $ac_func();
7124 #endif
7125
7126 ; return 0; }
7127 EOF
7128 if { (eval echo configure:7129: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7129   rm -rf conftest*
7130   eval "ac_cv_func_$ac_func=yes"
7131 else
7132   echo "configure: failed program was:" >&5
7133   cat conftest.$ac_ext >&5
7134   rm -rf conftest*
7135   eval "ac_cv_func_$ac_func=no"
7136 fi
7137 rm -f conftest*
7138 fi
7139
7140 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7141   echo "$ac_t""yes" 1>&6
7142     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7143   cat >> confdefs.h <<EOF
7144 #define $ac_tr_func 1
7145 EOF
7146
7147 else
7148   echo "$ac_t""no" 1>&6
7149 fi
7150 done
7151
7152   fi
7153
7154
7155
7156   ac_ext=C
7157 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7158 ac_cpp='$CXXCPP $CPPFLAGS'
7159 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7160 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7161 cross_compiling=$ac_cv_prog_cxx_cross
7162
7163   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7164 echo "configure:7165: checking for modff declaration" >&5
7165   cat > conftest.$ac_ext <<EOF
7166 #line 7167 "configure"
7167 #include "confdefs.h"
7168 #include <math.h>
7169 int main() {
7170  modff(0, 0);
7171 ; return 0; }
7172 EOF
7173 if { (eval echo configure:7174: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7174   rm -rf conftest*
7175   use_modff=yes
7176 else
7177   echo "configure: failed program was:" >&5
7178   cat conftest.$ac_ext >&5
7179   rm -rf conftest*
7180   use_modff=no
7181 fi
7182 rm -f conftest*
7183   echo "$ac_t""$use_modff" 1>&6
7184   ac_ext=c
7185 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7186 ac_cpp='$CPP $CPPFLAGS'
7187 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7188 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7189 cross_compiling=$ac_cv_prog_cc_cross
7190
7191   if test x$use_modff = x"yes"; then
7192     for ac_func in modff
7193 do
7194 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7195 echo "configure:7196: checking for $ac_func" >&5
7196 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7197   echo $ac_n "(cached) $ac_c" 1>&6
7198 else
7199   cat > conftest.$ac_ext <<EOF
7200 #line 7201 "configure"
7201 #include "confdefs.h"
7202 /* System header to define __stub macros and hopefully few prototypes,
7203     which can conflict with char $ac_func(); below.  */
7204 #include <assert.h>
7205 /* Override any gcc2 internal prototype to avoid an error.  */
7206 /* We use char because int might match the return type of a gcc2
7207     builtin and then its argument prototype would still apply.  */
7208 char $ac_func();
7209
7210 int main() {
7211
7212 /* The GNU C library defines this for functions which it implements
7213     to always fail with ENOSYS.  Some functions are actually named
7214     something starting with __ and the normal name is an alias.  */
7215 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7216 choke me
7217 #else
7218 $ac_func();
7219 #endif
7220
7221 ; return 0; }
7222 EOF
7223 if { (eval echo configure:7224: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7224   rm -rf conftest*
7225   eval "ac_cv_func_$ac_func=yes"
7226 else
7227   echo "configure: failed program was:" >&5
7228   cat conftest.$ac_ext >&5
7229   rm -rf conftest*
7230   eval "ac_cv_func_$ac_func=no"
7231 fi
7232 rm -f conftest*
7233 fi
7234
7235 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7236   echo "$ac_t""yes" 1>&6
7237     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7238   cat >> confdefs.h <<EOF
7239 #define $ac_tr_func 1
7240 EOF
7241
7242 else
7243   echo "$ac_t""no" 1>&6
7244 fi
7245 done
7246
7247   fi
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 powf declaration""... $ac_c" 1>&6
7259 echo "configure:7260: checking for powf declaration" >&5
7260   cat > conftest.$ac_ext <<EOF
7261 #line 7262 "configure"
7262 #include "confdefs.h"
7263 #include <math.h>
7264 int main() {
7265  powf(0, 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_powf=yes
7271 else
7272   echo "configure: failed program was:" >&5
7273   cat conftest.$ac_ext >&5
7274   rm -rf conftest*
7275   use_powf=no
7276 fi
7277 rm -f conftest*
7278   echo "$ac_t""$use_powf" 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_powf = x"yes"; then
7287     for ac_func in powf
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 sinf declaration""... $ac_c" 1>&6
7354 echo "configure:7355: checking for sinf declaration" >&5
7355   cat > conftest.$ac_ext <<EOF
7356 #line 7357 "configure"
7357 #include "confdefs.h"
7358 #include <math.h>
7359 int main() {
7360  sinf(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_sinf=yes
7366 else
7367   echo "configure: failed program was:" >&5
7368   cat conftest.$ac_ext >&5
7369   rm -rf conftest*
7370   use_sinf=no
7371 fi
7372 rm -f conftest*
7373   echo "$ac_t""$use_sinf" 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_sinf = x"yes"; then
7382     for ac_func in sinf
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 sinhf declaration""... $ac_c" 1>&6
7449 echo "configure:7450: checking for sinhf declaration" >&5
7450   cat > conftest.$ac_ext <<EOF
7451 #line 7452 "configure"
7452 #include "confdefs.h"
7453 #include <math.h>
7454 int main() {
7455  sinhf(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_sinhf=yes
7461 else
7462   echo "configure: failed program was:" >&5
7463   cat conftest.$ac_ext >&5
7464   rm -rf conftest*
7465   use_sinhf=no
7466 fi
7467 rm -f conftest*
7468   echo "$ac_t""$use_sinhf" 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_sinhf = x"yes"; then
7477     for ac_func in sinhf
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 sqrtf declaration""... $ac_c" 1>&6
7544 echo "configure:7545: checking for sqrtf declaration" >&5
7545   cat > conftest.$ac_ext <<EOF
7546 #line 7547 "configure"
7547 #include "confdefs.h"
7548 #include <math.h>
7549 int main() {
7550  sqrtf(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_sqrtf=yes
7556 else
7557   echo "configure: failed program was:" >&5
7558   cat conftest.$ac_ext >&5
7559   rm -rf conftest*
7560   use_sqrtf=no
7561 fi
7562 rm -f conftest*
7563   echo "$ac_t""$use_sqrtf" 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_sqrtf = x"yes"; then
7572     for ac_func in sqrtf
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 tanf declaration""... $ac_c" 1>&6
7639 echo "configure:7640: checking for tanf declaration" >&5
7640   cat > conftest.$ac_ext <<EOF
7641 #line 7642 "configure"
7642 #include "confdefs.h"
7643 #include <math.h>
7644 int main() {
7645  tanf(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_tanf=yes
7651 else
7652   echo "configure: failed program was:" >&5
7653   cat conftest.$ac_ext >&5
7654   rm -rf conftest*
7655   use_tanf=no
7656 fi
7657 rm -f conftest*
7658   echo "$ac_t""$use_tanf" 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_tanf = x"yes"; then
7667     for ac_func in tanf
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 tanhf declaration""... $ac_c" 1>&6
7734 echo "configure:7735: checking for tanhf declaration" >&5
7735   cat > conftest.$ac_ext <<EOF
7736 #line 7737 "configure"
7737 #include "confdefs.h"
7738 #include <math.h>
7739 int main() {
7740  tanhf(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_tanhf=yes
7746 else
7747   echo "configure: failed program was:" >&5
7748   cat conftest.$ac_ext >&5
7749   rm -rf conftest*
7750   use_tanhf=no
7751 fi
7752 rm -f conftest*
7753   echo "$ac_t""$use_tanhf" 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_tanhf = x"yes"; then
7762     for ac_func in tanhf
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 sincosf declaration""... $ac_c" 1>&6
7829 echo "configure:7830: checking for sincosf declaration" >&5
7830   cat > conftest.$ac_ext <<EOF
7831 #line 7832 "configure"
7832 #include "confdefs.h"
7833 #include <math.h>
7834 int main() {
7835  sincosf(0, 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_sincosf=yes
7841 else
7842   echo "configure: failed program was:" >&5
7843   cat conftest.$ac_ext >&5
7844   rm -rf conftest*
7845   use_sincosf=no
7846 fi
7847 rm -f conftest*
7848   echo "$ac_t""$use_sincosf" 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_sincosf = x"yes"; then
7857     for ac_func in sincosf
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 finitef declaration""... $ac_c" 1>&6
7924 echo "configure:7925: checking for finitef declaration" >&5
7925   cat > conftest.$ac_ext <<EOF
7926 #line 7927 "configure"
7927 #include "confdefs.h"
7928 #include <math.h>
7929 int main() {
7930  finitef(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_finitef=yes
7936 else
7937   echo "configure: failed program was:" >&5
7938   cat conftest.$ac_ext >&5
7939   rm -rf conftest*
7940   use_finitef=no
7941 fi
7942 rm -f conftest*
7943   echo "$ac_t""$use_finitef" 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_finitef = x"yes"; then
7952     for ac_func in finitef
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
8012   ac_ext=C
8013 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8014 ac_cpp='$CXXCPP $CPPFLAGS'
8015 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8016 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8017 cross_compiling=$ac_cv_prog_cxx_cross
8018
8019   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8020 echo "configure:8021: checking for isnanl declaration" >&5
8021   cat > conftest.$ac_ext <<EOF
8022 #line 8023 "configure"
8023 #include "confdefs.h"
8024 #include <math.h>
8025 int main() {
8026  isnanl(0);
8027 ; return 0; }
8028 EOF
8029 if { (eval echo configure:8030: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8030   rm -rf conftest*
8031   use_isnanl=yes
8032 else
8033   echo "configure: failed program was:" >&5
8034   cat conftest.$ac_ext >&5
8035   rm -rf conftest*
8036   use_isnanl=no
8037 fi
8038 rm -f conftest*
8039   echo "$ac_t""$use_isnanl" 1>&6
8040   ac_ext=c
8041 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8042 ac_cpp='$CPP $CPPFLAGS'
8043 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8044 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8045 cross_compiling=$ac_cv_prog_cc_cross
8046
8047   if test x$use_isnanl = x"yes"; then
8048     for ac_func in isnanl
8049 do
8050 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8051 echo "configure:8052: checking for $ac_func" >&5
8052 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8053   echo $ac_n "(cached) $ac_c" 1>&6
8054 else
8055   cat > conftest.$ac_ext <<EOF
8056 #line 8057 "configure"
8057 #include "confdefs.h"
8058 /* System header to define __stub macros and hopefully few prototypes,
8059     which can conflict with char $ac_func(); below.  */
8060 #include <assert.h>
8061 /* Override any gcc2 internal prototype to avoid an error.  */
8062 /* We use char because int might match the return type of a gcc2
8063     builtin and then its argument prototype would still apply.  */
8064 char $ac_func();
8065
8066 int main() {
8067
8068 /* The GNU C library defines this for functions which it implements
8069     to always fail with ENOSYS.  Some functions are actually named
8070     something starting with __ and the normal name is an alias.  */
8071 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8072 choke me
8073 #else
8074 $ac_func();
8075 #endif
8076
8077 ; return 0; }
8078 EOF
8079 if { (eval echo configure:8080: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8080   rm -rf conftest*
8081   eval "ac_cv_func_$ac_func=yes"
8082 else
8083   echo "configure: failed program was:" >&5
8084   cat conftest.$ac_ext >&5
8085   rm -rf conftest*
8086   eval "ac_cv_func_$ac_func=no"
8087 fi
8088 rm -f conftest*
8089 fi
8090
8091 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8092   echo "$ac_t""yes" 1>&6
8093     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8094   cat >> confdefs.h <<EOF
8095 #define $ac_tr_func 1
8096 EOF
8097
8098 else
8099   echo "$ac_t""no" 1>&6
8100 fi
8101 done
8102
8103   fi
8104
8105
8106
8107   ac_ext=C
8108 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8109 ac_cpp='$CXXCPP $CPPFLAGS'
8110 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8111 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8112 cross_compiling=$ac_cv_prog_cxx_cross
8113
8114   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8115 echo "configure:8116: checking for isinfl declaration" >&5
8116   cat > conftest.$ac_ext <<EOF
8117 #line 8118 "configure"
8118 #include "confdefs.h"
8119 #include <math.h>
8120 int main() {
8121  isinfl(0);
8122 ; return 0; }
8123 EOF
8124 if { (eval echo configure:8125: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8125   rm -rf conftest*
8126   use_isinfl=yes
8127 else
8128   echo "configure: failed program was:" >&5
8129   cat conftest.$ac_ext >&5
8130   rm -rf conftest*
8131   use_isinfl=no
8132 fi
8133 rm -f conftest*
8134   echo "$ac_t""$use_isinfl" 1>&6
8135   ac_ext=c
8136 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8137 ac_cpp='$CPP $CPPFLAGS'
8138 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8139 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8140 cross_compiling=$ac_cv_prog_cc_cross
8141
8142   if test x$use_isinfl = x"yes"; then
8143     for ac_func in isinfl
8144 do
8145 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8146 echo "configure:8147: checking for $ac_func" >&5
8147 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8148   echo $ac_n "(cached) $ac_c" 1>&6
8149 else
8150   cat > conftest.$ac_ext <<EOF
8151 #line 8152 "configure"
8152 #include "confdefs.h"
8153 /* System header to define __stub macros and hopefully few prototypes,
8154     which can conflict with char $ac_func(); below.  */
8155 #include <assert.h>
8156 /* Override any gcc2 internal prototype to avoid an error.  */
8157 /* We use char because int might match the return type of a gcc2
8158     builtin and then its argument prototype would still apply.  */
8159 char $ac_func();
8160
8161 int main() {
8162
8163 /* The GNU C library defines this for functions which it implements
8164     to always fail with ENOSYS.  Some functions are actually named
8165     something starting with __ and the normal name is an alias.  */
8166 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8167 choke me
8168 #else
8169 $ac_func();
8170 #endif
8171
8172 ; return 0; }
8173 EOF
8174 if { (eval echo configure:8175: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8175   rm -rf conftest*
8176   eval "ac_cv_func_$ac_func=yes"
8177 else
8178   echo "configure: failed program was:" >&5
8179   cat conftest.$ac_ext >&5
8180   rm -rf conftest*
8181   eval "ac_cv_func_$ac_func=no"
8182 fi
8183 rm -f conftest*
8184 fi
8185
8186 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8187   echo "$ac_t""yes" 1>&6
8188     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8189   cat >> confdefs.h <<EOF
8190 #define $ac_tr_func 1
8191 EOF
8192
8193 else
8194   echo "$ac_t""no" 1>&6
8195 fi
8196 done
8197
8198   fi
8199
8200
8201
8202   ac_ext=C
8203 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8204 ac_cpp='$CXXCPP $CPPFLAGS'
8205 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8206 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8207 cross_compiling=$ac_cv_prog_cxx_cross
8208
8209   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8210 echo "configure:8211: checking for copysignl declaration" >&5
8211   cat > conftest.$ac_ext <<EOF
8212 #line 8213 "configure"
8213 #include "confdefs.h"
8214 #include <math.h>
8215 int main() {
8216  copysignl(0);
8217 ; return 0; }
8218 EOF
8219 if { (eval echo configure:8220: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8220   rm -rf conftest*
8221   use_copysignl=yes
8222 else
8223   echo "configure: failed program was:" >&5
8224   cat conftest.$ac_ext >&5
8225   rm -rf conftest*
8226   use_copysignl=no
8227 fi
8228 rm -f conftest*
8229   echo "$ac_t""$use_copysignl" 1>&6
8230   ac_ext=c
8231 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8232 ac_cpp='$CPP $CPPFLAGS'
8233 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8234 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8235 cross_compiling=$ac_cv_prog_cc_cross
8236
8237   if test x$use_copysignl = x"yes"; then
8238     for ac_func in copysignl
8239 do
8240 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8241 echo "configure:8242: checking for $ac_func" >&5
8242 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8243   echo $ac_n "(cached) $ac_c" 1>&6
8244 else
8245   cat > conftest.$ac_ext <<EOF
8246 #line 8247 "configure"
8247 #include "confdefs.h"
8248 /* System header to define __stub macros and hopefully few prototypes,
8249     which can conflict with char $ac_func(); below.  */
8250 #include <assert.h>
8251 /* Override any gcc2 internal prototype to avoid an error.  */
8252 /* We use char because int might match the return type of a gcc2
8253     builtin and then its argument prototype would still apply.  */
8254 char $ac_func();
8255
8256 int main() {
8257
8258 /* The GNU C library defines this for functions which it implements
8259     to always fail with ENOSYS.  Some functions are actually named
8260     something starting with __ and the normal name is an alias.  */
8261 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8262 choke me
8263 #else
8264 $ac_func();
8265 #endif
8266
8267 ; return 0; }
8268 EOF
8269 if { (eval echo configure:8270: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8270   rm -rf conftest*
8271   eval "ac_cv_func_$ac_func=yes"
8272 else
8273   echo "configure: failed program was:" >&5
8274   cat conftest.$ac_ext >&5
8275   rm -rf conftest*
8276   eval "ac_cv_func_$ac_func=no"
8277 fi
8278 rm -f conftest*
8279 fi
8280
8281 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8282   echo "$ac_t""yes" 1>&6
8283     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8284   cat >> confdefs.h <<EOF
8285 #define $ac_tr_func 1
8286 EOF
8287
8288 else
8289   echo "$ac_t""no" 1>&6
8290 fi
8291 done
8292
8293   fi
8294
8295
8296
8297   ac_ext=C
8298 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8299 ac_cpp='$CXXCPP $CPPFLAGS'
8300 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8301 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8302 cross_compiling=$ac_cv_prog_cxx_cross
8303
8304   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8305 echo "configure:8306: checking for acosl declaration" >&5
8306   cat > conftest.$ac_ext <<EOF
8307 #line 8308 "configure"
8308 #include "confdefs.h"
8309 #include <math.h>
8310 int main() {
8311  acosl(0);
8312 ; return 0; }
8313 EOF
8314 if { (eval echo configure:8315: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8315   rm -rf conftest*
8316   use_acosl=yes
8317 else
8318   echo "configure: failed program was:" >&5
8319   cat conftest.$ac_ext >&5
8320   rm -rf conftest*
8321   use_acosl=no
8322 fi
8323 rm -f conftest*
8324   echo "$ac_t""$use_acosl" 1>&6
8325   ac_ext=c
8326 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8327 ac_cpp='$CPP $CPPFLAGS'
8328 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8329 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8330 cross_compiling=$ac_cv_prog_cc_cross
8331
8332   if test x$use_acosl = x"yes"; then
8333     for ac_func in acosl
8334 do
8335 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8336 echo "configure:8337: checking for $ac_func" >&5
8337 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8338   echo $ac_n "(cached) $ac_c" 1>&6
8339 else
8340   cat > conftest.$ac_ext <<EOF
8341 #line 8342 "configure"
8342 #include "confdefs.h"
8343 /* System header to define __stub macros and hopefully few prototypes,
8344     which can conflict with char $ac_func(); below.  */
8345 #include <assert.h>
8346 /* Override any gcc2 internal prototype to avoid an error.  */
8347 /* We use char because int might match the return type of a gcc2
8348     builtin and then its argument prototype would still apply.  */
8349 char $ac_func();
8350
8351 int main() {
8352
8353 /* The GNU C library defines this for functions which it implements
8354     to always fail with ENOSYS.  Some functions are actually named
8355     something starting with __ and the normal name is an alias.  */
8356 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8357 choke me
8358 #else
8359 $ac_func();
8360 #endif
8361
8362 ; return 0; }
8363 EOF
8364 if { (eval echo configure:8365: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8365   rm -rf conftest*
8366   eval "ac_cv_func_$ac_func=yes"
8367 else
8368   echo "configure: failed program was:" >&5
8369   cat conftest.$ac_ext >&5
8370   rm -rf conftest*
8371   eval "ac_cv_func_$ac_func=no"
8372 fi
8373 rm -f conftest*
8374 fi
8375
8376 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8377   echo "$ac_t""yes" 1>&6
8378     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8379   cat >> confdefs.h <<EOF
8380 #define $ac_tr_func 1
8381 EOF
8382
8383 else
8384   echo "$ac_t""no" 1>&6
8385 fi
8386 done
8387
8388   fi
8389
8390
8391
8392   ac_ext=C
8393 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8394 ac_cpp='$CXXCPP $CPPFLAGS'
8395 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8396 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8397 cross_compiling=$ac_cv_prog_cxx_cross
8398
8399   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8400 echo "configure:8401: checking for asinl declaration" >&5
8401   cat > conftest.$ac_ext <<EOF
8402 #line 8403 "configure"
8403 #include "confdefs.h"
8404 #include <math.h>
8405 int main() {
8406  asinl(0);
8407 ; return 0; }
8408 EOF
8409 if { (eval echo configure:8410: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8410   rm -rf conftest*
8411   use_asinl=yes
8412 else
8413   echo "configure: failed program was:" >&5
8414   cat conftest.$ac_ext >&5
8415   rm -rf conftest*
8416   use_asinl=no
8417 fi
8418 rm -f conftest*
8419   echo "$ac_t""$use_asinl" 1>&6
8420   ac_ext=c
8421 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8422 ac_cpp='$CPP $CPPFLAGS'
8423 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8424 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8425 cross_compiling=$ac_cv_prog_cc_cross
8426
8427   if test x$use_asinl = x"yes"; then
8428     for ac_func in asinl
8429 do
8430 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8431 echo "configure:8432: checking for $ac_func" >&5
8432 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8433   echo $ac_n "(cached) $ac_c" 1>&6
8434 else
8435   cat > conftest.$ac_ext <<EOF
8436 #line 8437 "configure"
8437 #include "confdefs.h"
8438 /* System header to define __stub macros and hopefully few prototypes,
8439     which can conflict with char $ac_func(); below.  */
8440 #include <assert.h>
8441 /* Override any gcc2 internal prototype to avoid an error.  */
8442 /* We use char because int might match the return type of a gcc2
8443     builtin and then its argument prototype would still apply.  */
8444 char $ac_func();
8445
8446 int main() {
8447
8448 /* The GNU C library defines this for functions which it implements
8449     to always fail with ENOSYS.  Some functions are actually named
8450     something starting with __ and the normal name is an alias.  */
8451 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8452 choke me
8453 #else
8454 $ac_func();
8455 #endif
8456
8457 ; return 0; }
8458 EOF
8459 if { (eval echo configure:8460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8460   rm -rf conftest*
8461   eval "ac_cv_func_$ac_func=yes"
8462 else
8463   echo "configure: failed program was:" >&5
8464   cat conftest.$ac_ext >&5
8465   rm -rf conftest*
8466   eval "ac_cv_func_$ac_func=no"
8467 fi
8468 rm -f conftest*
8469 fi
8470
8471 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8472   echo "$ac_t""yes" 1>&6
8473     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8474   cat >> confdefs.h <<EOF
8475 #define $ac_tr_func 1
8476 EOF
8477
8478 else
8479   echo "$ac_t""no" 1>&6
8480 fi
8481 done
8482
8483   fi
8484
8485
8486
8487   ac_ext=C
8488 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8489 ac_cpp='$CXXCPP $CPPFLAGS'
8490 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8491 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8492 cross_compiling=$ac_cv_prog_cxx_cross
8493
8494   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8495 echo "configure:8496: checking for atanl declaration" >&5
8496   cat > conftest.$ac_ext <<EOF
8497 #line 8498 "configure"
8498 #include "confdefs.h"
8499 #include <math.h>
8500 int main() {
8501  atanl(0);
8502 ; return 0; }
8503 EOF
8504 if { (eval echo configure:8505: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8505   rm -rf conftest*
8506   use_atanl=yes
8507 else
8508   echo "configure: failed program was:" >&5
8509   cat conftest.$ac_ext >&5
8510   rm -rf conftest*
8511   use_atanl=no
8512 fi
8513 rm -f conftest*
8514   echo "$ac_t""$use_atanl" 1>&6
8515   ac_ext=c
8516 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8517 ac_cpp='$CPP $CPPFLAGS'
8518 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8519 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8520 cross_compiling=$ac_cv_prog_cc_cross
8521
8522   if test x$use_atanl = x"yes"; then
8523     for ac_func in atanl
8524 do
8525 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8526 echo "configure:8527: checking for $ac_func" >&5
8527 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8528   echo $ac_n "(cached) $ac_c" 1>&6
8529 else
8530   cat > conftest.$ac_ext <<EOF
8531 #line 8532 "configure"
8532 #include "confdefs.h"
8533 /* System header to define __stub macros and hopefully few prototypes,
8534     which can conflict with char $ac_func(); below.  */
8535 #include <assert.h>
8536 /* Override any gcc2 internal prototype to avoid an error.  */
8537 /* We use char because int might match the return type of a gcc2
8538     builtin and then its argument prototype would still apply.  */
8539 char $ac_func();
8540
8541 int main() {
8542
8543 /* The GNU C library defines this for functions which it implements
8544     to always fail with ENOSYS.  Some functions are actually named
8545     something starting with __ and the normal name is an alias.  */
8546 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8547 choke me
8548 #else
8549 $ac_func();
8550 #endif
8551
8552 ; return 0; }
8553 EOF
8554 if { (eval echo configure:8555: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8555   rm -rf conftest*
8556   eval "ac_cv_func_$ac_func=yes"
8557 else
8558   echo "configure: failed program was:" >&5
8559   cat conftest.$ac_ext >&5
8560   rm -rf conftest*
8561   eval "ac_cv_func_$ac_func=no"
8562 fi
8563 rm -f conftest*
8564 fi
8565
8566 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8567   echo "$ac_t""yes" 1>&6
8568     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8569   cat >> confdefs.h <<EOF
8570 #define $ac_tr_func 1
8571 EOF
8572
8573 else
8574   echo "$ac_t""no" 1>&6
8575 fi
8576 done
8577
8578   fi
8579
8580
8581
8582   ac_ext=C
8583 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8584 ac_cpp='$CXXCPP $CPPFLAGS'
8585 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8586 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8587 cross_compiling=$ac_cv_prog_cxx_cross
8588
8589   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8590 echo "configure:8591: checking for atan2l declaration" >&5
8591   cat > conftest.$ac_ext <<EOF
8592 #line 8593 "configure"
8593 #include "confdefs.h"
8594 #include <math.h>
8595 int main() {
8596  atan2l(0, 0);
8597 ; return 0; }
8598 EOF
8599 if { (eval echo configure:8600: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8600   rm -rf conftest*
8601   use_atan2l=yes
8602 else
8603   echo "configure: failed program was:" >&5
8604   cat conftest.$ac_ext >&5
8605   rm -rf conftest*
8606   use_atan2l=no
8607 fi
8608 rm -f conftest*
8609   echo "$ac_t""$use_atan2l" 1>&6
8610   ac_ext=c
8611 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8612 ac_cpp='$CPP $CPPFLAGS'
8613 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8614 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8615 cross_compiling=$ac_cv_prog_cc_cross
8616
8617   if test x$use_atan2l = x"yes"; then
8618     for ac_func in atan2l
8619 do
8620 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8621 echo "configure:8622: checking for $ac_func" >&5
8622 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8623   echo $ac_n "(cached) $ac_c" 1>&6
8624 else
8625   cat > conftest.$ac_ext <<EOF
8626 #line 8627 "configure"
8627 #include "confdefs.h"
8628 /* System header to define __stub macros and hopefully few prototypes,
8629     which can conflict with char $ac_func(); below.  */
8630 #include <assert.h>
8631 /* Override any gcc2 internal prototype to avoid an error.  */
8632 /* We use char because int might match the return type of a gcc2
8633     builtin and then its argument prototype would still apply.  */
8634 char $ac_func();
8635
8636 int main() {
8637
8638 /* The GNU C library defines this for functions which it implements
8639     to always fail with ENOSYS.  Some functions are actually named
8640     something starting with __ and the normal name is an alias.  */
8641 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8642 choke me
8643 #else
8644 $ac_func();
8645 #endif
8646
8647 ; return 0; }
8648 EOF
8649 if { (eval echo configure:8650: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8650   rm -rf conftest*
8651   eval "ac_cv_func_$ac_func=yes"
8652 else
8653   echo "configure: failed program was:" >&5
8654   cat conftest.$ac_ext >&5
8655   rm -rf conftest*
8656   eval "ac_cv_func_$ac_func=no"
8657 fi
8658 rm -f conftest*
8659 fi
8660
8661 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8662   echo "$ac_t""yes" 1>&6
8663     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8664   cat >> confdefs.h <<EOF
8665 #define $ac_tr_func 1
8666 EOF
8667
8668 else
8669   echo "$ac_t""no" 1>&6
8670 fi
8671 done
8672
8673   fi
8674
8675
8676
8677   ac_ext=C
8678 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8679 ac_cpp='$CXXCPP $CPPFLAGS'
8680 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8681 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8682 cross_compiling=$ac_cv_prog_cxx_cross
8683
8684   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8685 echo "configure:8686: checking for ceill declaration" >&5
8686   cat > conftest.$ac_ext <<EOF
8687 #line 8688 "configure"
8688 #include "confdefs.h"
8689 #include <math.h>
8690 int main() {
8691  ceill(0);
8692 ; return 0; }
8693 EOF
8694 if { (eval echo configure:8695: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8695   rm -rf conftest*
8696   use_ceill=yes
8697 else
8698   echo "configure: failed program was:" >&5
8699   cat conftest.$ac_ext >&5
8700   rm -rf conftest*
8701   use_ceill=no
8702 fi
8703 rm -f conftest*
8704   echo "$ac_t""$use_ceill" 1>&6
8705   ac_ext=c
8706 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8707 ac_cpp='$CPP $CPPFLAGS'
8708 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8709 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8710 cross_compiling=$ac_cv_prog_cc_cross
8711
8712   if test x$use_ceill = x"yes"; then
8713     for ac_func in ceill
8714 do
8715 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8716 echo "configure:8717: checking for $ac_func" >&5
8717 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8718   echo $ac_n "(cached) $ac_c" 1>&6
8719 else
8720   cat > conftest.$ac_ext <<EOF
8721 #line 8722 "configure"
8722 #include "confdefs.h"
8723 /* System header to define __stub macros and hopefully few prototypes,
8724     which can conflict with char $ac_func(); below.  */
8725 #include <assert.h>
8726 /* Override any gcc2 internal prototype to avoid an error.  */
8727 /* We use char because int might match the return type of a gcc2
8728     builtin and then its argument prototype would still apply.  */
8729 char $ac_func();
8730
8731 int main() {
8732
8733 /* The GNU C library defines this for functions which it implements
8734     to always fail with ENOSYS.  Some functions are actually named
8735     something starting with __ and the normal name is an alias.  */
8736 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8737 choke me
8738 #else
8739 $ac_func();
8740 #endif
8741
8742 ; return 0; }
8743 EOF
8744 if { (eval echo configure:8745: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8745   rm -rf conftest*
8746   eval "ac_cv_func_$ac_func=yes"
8747 else
8748   echo "configure: failed program was:" >&5
8749   cat conftest.$ac_ext >&5
8750   rm -rf conftest*
8751   eval "ac_cv_func_$ac_func=no"
8752 fi
8753 rm -f conftest*
8754 fi
8755
8756 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8757   echo "$ac_t""yes" 1>&6
8758     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8759   cat >> confdefs.h <<EOF
8760 #define $ac_tr_func 1
8761 EOF
8762
8763 else
8764   echo "$ac_t""no" 1>&6
8765 fi
8766 done
8767
8768   fi
8769
8770
8771
8772   ac_ext=C
8773 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8774 ac_cpp='$CXXCPP $CPPFLAGS'
8775 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8776 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8777 cross_compiling=$ac_cv_prog_cxx_cross
8778
8779   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8780 echo "configure:8781: checking for cosl declaration" >&5
8781   cat > conftest.$ac_ext <<EOF
8782 #line 8783 "configure"
8783 #include "confdefs.h"
8784 #include <math.h>
8785 int main() {
8786  cosl(0);
8787 ; return 0; }
8788 EOF
8789 if { (eval echo configure:8790: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8790   rm -rf conftest*
8791   use_cosl=yes
8792 else
8793   echo "configure: failed program was:" >&5
8794   cat conftest.$ac_ext >&5
8795   rm -rf conftest*
8796   use_cosl=no
8797 fi
8798 rm -f conftest*
8799   echo "$ac_t""$use_cosl" 1>&6
8800   ac_ext=c
8801 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8802 ac_cpp='$CPP $CPPFLAGS'
8803 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8804 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8805 cross_compiling=$ac_cv_prog_cc_cross
8806
8807   if test x$use_cosl = x"yes"; then
8808     for ac_func in cosl
8809 do
8810 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8811 echo "configure:8812: checking for $ac_func" >&5
8812 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8813   echo $ac_n "(cached) $ac_c" 1>&6
8814 else
8815   cat > conftest.$ac_ext <<EOF
8816 #line 8817 "configure"
8817 #include "confdefs.h"
8818 /* System header to define __stub macros and hopefully few prototypes,
8819     which can conflict with char $ac_func(); below.  */
8820 #include <assert.h>
8821 /* Override any gcc2 internal prototype to avoid an error.  */
8822 /* We use char because int might match the return type of a gcc2
8823     builtin and then its argument prototype would still apply.  */
8824 char $ac_func();
8825
8826 int main() {
8827
8828 /* The GNU C library defines this for functions which it implements
8829     to always fail with ENOSYS.  Some functions are actually named
8830     something starting with __ and the normal name is an alias.  */
8831 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8832 choke me
8833 #else
8834 $ac_func();
8835 #endif
8836
8837 ; return 0; }
8838 EOF
8839 if { (eval echo configure:8840: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8840   rm -rf conftest*
8841   eval "ac_cv_func_$ac_func=yes"
8842 else
8843   echo "configure: failed program was:" >&5
8844   cat conftest.$ac_ext >&5
8845   rm -rf conftest*
8846   eval "ac_cv_func_$ac_func=no"
8847 fi
8848 rm -f conftest*
8849 fi
8850
8851 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8852   echo "$ac_t""yes" 1>&6
8853     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8854   cat >> confdefs.h <<EOF
8855 #define $ac_tr_func 1
8856 EOF
8857
8858 else
8859   echo "$ac_t""no" 1>&6
8860 fi
8861 done
8862
8863   fi
8864
8865
8866
8867   ac_ext=C
8868 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8869 ac_cpp='$CXXCPP $CPPFLAGS'
8870 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8871 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8872 cross_compiling=$ac_cv_prog_cxx_cross
8873
8874   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
8875 echo "configure:8876: checking for coshl declaration" >&5
8876   cat > conftest.$ac_ext <<EOF
8877 #line 8878 "configure"
8878 #include "confdefs.h"
8879 #include <math.h>
8880 int main() {
8881  coshl(0);
8882 ; return 0; }
8883 EOF
8884 if { (eval echo configure:8885: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8885   rm -rf conftest*
8886   use_coshl=yes
8887 else
8888   echo "configure: failed program was:" >&5
8889   cat conftest.$ac_ext >&5
8890   rm -rf conftest*
8891   use_coshl=no
8892 fi
8893 rm -f conftest*
8894   echo "$ac_t""$use_coshl" 1>&6
8895   ac_ext=c
8896 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8897 ac_cpp='$CPP $CPPFLAGS'
8898 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8899 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8900 cross_compiling=$ac_cv_prog_cc_cross
8901
8902   if test x$use_coshl = x"yes"; then
8903     for ac_func in coshl
8904 do
8905 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8906 echo "configure:8907: checking for $ac_func" >&5
8907 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8908   echo $ac_n "(cached) $ac_c" 1>&6
8909 else
8910   cat > conftest.$ac_ext <<EOF
8911 #line 8912 "configure"
8912 #include "confdefs.h"
8913 /* System header to define __stub macros and hopefully few prototypes,
8914     which can conflict with char $ac_func(); below.  */
8915 #include <assert.h>
8916 /* Override any gcc2 internal prototype to avoid an error.  */
8917 /* We use char because int might match the return type of a gcc2
8918     builtin and then its argument prototype would still apply.  */
8919 char $ac_func();
8920
8921 int main() {
8922
8923 /* The GNU C library defines this for functions which it implements
8924     to always fail with ENOSYS.  Some functions are actually named
8925     something starting with __ and the normal name is an alias.  */
8926 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8927 choke me
8928 #else
8929 $ac_func();
8930 #endif
8931
8932 ; return 0; }
8933 EOF
8934 if { (eval echo configure:8935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8935   rm -rf conftest*
8936   eval "ac_cv_func_$ac_func=yes"
8937 else
8938   echo "configure: failed program was:" >&5
8939   cat conftest.$ac_ext >&5
8940   rm -rf conftest*
8941   eval "ac_cv_func_$ac_func=no"
8942 fi
8943 rm -f conftest*
8944 fi
8945
8946 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8947   echo "$ac_t""yes" 1>&6
8948     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8949   cat >> confdefs.h <<EOF
8950 #define $ac_tr_func 1
8951 EOF
8952
8953 else
8954   echo "$ac_t""no" 1>&6
8955 fi
8956 done
8957
8958   fi
8959
8960
8961
8962   ac_ext=C
8963 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8964 ac_cpp='$CXXCPP $CPPFLAGS'
8965 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8966 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8967 cross_compiling=$ac_cv_prog_cxx_cross
8968
8969   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
8970 echo "configure:8971: checking for expl declaration" >&5
8971   cat > conftest.$ac_ext <<EOF
8972 #line 8973 "configure"
8973 #include "confdefs.h"
8974 #include <math.h>
8975 int main() {
8976  expl(0);
8977 ; return 0; }
8978 EOF
8979 if { (eval echo configure:8980: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8980   rm -rf conftest*
8981   use_expl=yes
8982 else
8983   echo "configure: failed program was:" >&5
8984   cat conftest.$ac_ext >&5
8985   rm -rf conftest*
8986   use_expl=no
8987 fi
8988 rm -f conftest*
8989   echo "$ac_t""$use_expl" 1>&6
8990   ac_ext=c
8991 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8992 ac_cpp='$CPP $CPPFLAGS'
8993 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8994 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8995 cross_compiling=$ac_cv_prog_cc_cross
8996
8997   if test x$use_expl = x"yes"; then
8998     for ac_func in expl
8999 do
9000 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9001 echo "configure:9002: checking for $ac_func" >&5
9002 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9003   echo $ac_n "(cached) $ac_c" 1>&6
9004 else
9005   cat > conftest.$ac_ext <<EOF
9006 #line 9007 "configure"
9007 #include "confdefs.h"
9008 /* System header to define __stub macros and hopefully few prototypes,
9009     which can conflict with char $ac_func(); below.  */
9010 #include <assert.h>
9011 /* Override any gcc2 internal prototype to avoid an error.  */
9012 /* We use char because int might match the return type of a gcc2
9013     builtin and then its argument prototype would still apply.  */
9014 char $ac_func();
9015
9016 int main() {
9017
9018 /* The GNU C library defines this for functions which it implements
9019     to always fail with ENOSYS.  Some functions are actually named
9020     something starting with __ and the normal name is an alias.  */
9021 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9022 choke me
9023 #else
9024 $ac_func();
9025 #endif
9026
9027 ; return 0; }
9028 EOF
9029 if { (eval echo configure:9030: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9030   rm -rf conftest*
9031   eval "ac_cv_func_$ac_func=yes"
9032 else
9033   echo "configure: failed program was:" >&5
9034   cat conftest.$ac_ext >&5
9035   rm -rf conftest*
9036   eval "ac_cv_func_$ac_func=no"
9037 fi
9038 rm -f conftest*
9039 fi
9040
9041 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9042   echo "$ac_t""yes" 1>&6
9043     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9044   cat >> confdefs.h <<EOF
9045 #define $ac_tr_func 1
9046 EOF
9047
9048 else
9049   echo "$ac_t""no" 1>&6
9050 fi
9051 done
9052
9053   fi
9054
9055
9056
9057   ac_ext=C
9058 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9059 ac_cpp='$CXXCPP $CPPFLAGS'
9060 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9061 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9062 cross_compiling=$ac_cv_prog_cxx_cross
9063
9064   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9065 echo "configure:9066: checking for fabsl declaration" >&5
9066   cat > conftest.$ac_ext <<EOF
9067 #line 9068 "configure"
9068 #include "confdefs.h"
9069 #include <math.h>
9070 int main() {
9071  fabsl(0);
9072 ; return 0; }
9073 EOF
9074 if { (eval echo configure:9075: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9075   rm -rf conftest*
9076   use_fabsl=yes
9077 else
9078   echo "configure: failed program was:" >&5
9079   cat conftest.$ac_ext >&5
9080   rm -rf conftest*
9081   use_fabsl=no
9082 fi
9083 rm -f conftest*
9084   echo "$ac_t""$use_fabsl" 1>&6
9085   ac_ext=c
9086 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9087 ac_cpp='$CPP $CPPFLAGS'
9088 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9089 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9090 cross_compiling=$ac_cv_prog_cc_cross
9091
9092   if test x$use_fabsl = x"yes"; then
9093     for ac_func in fabsl
9094 do
9095 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9096 echo "configure:9097: checking for $ac_func" >&5
9097 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9098   echo $ac_n "(cached) $ac_c" 1>&6
9099 else
9100   cat > conftest.$ac_ext <<EOF
9101 #line 9102 "configure"
9102 #include "confdefs.h"
9103 /* System header to define __stub macros and hopefully few prototypes,
9104     which can conflict with char $ac_func(); below.  */
9105 #include <assert.h>
9106 /* Override any gcc2 internal prototype to avoid an error.  */
9107 /* We use char because int might match the return type of a gcc2
9108     builtin and then its argument prototype would still apply.  */
9109 char $ac_func();
9110
9111 int main() {
9112
9113 /* The GNU C library defines this for functions which it implements
9114     to always fail with ENOSYS.  Some functions are actually named
9115     something starting with __ and the normal name is an alias.  */
9116 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9117 choke me
9118 #else
9119 $ac_func();
9120 #endif
9121
9122 ; return 0; }
9123 EOF
9124 if { (eval echo configure:9125: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9125   rm -rf conftest*
9126   eval "ac_cv_func_$ac_func=yes"
9127 else
9128   echo "configure: failed program was:" >&5
9129   cat conftest.$ac_ext >&5
9130   rm -rf conftest*
9131   eval "ac_cv_func_$ac_func=no"
9132 fi
9133 rm -f conftest*
9134 fi
9135
9136 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9137   echo "$ac_t""yes" 1>&6
9138     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9139   cat >> confdefs.h <<EOF
9140 #define $ac_tr_func 1
9141 EOF
9142
9143 else
9144   echo "$ac_t""no" 1>&6
9145 fi
9146 done
9147
9148   fi
9149
9150
9151
9152   ac_ext=C
9153 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9154 ac_cpp='$CXXCPP $CPPFLAGS'
9155 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9156 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9157 cross_compiling=$ac_cv_prog_cxx_cross
9158
9159   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9160 echo "configure:9161: checking for floorl declaration" >&5
9161   cat > conftest.$ac_ext <<EOF
9162 #line 9163 "configure"
9163 #include "confdefs.h"
9164 #include <math.h>
9165 int main() {
9166  floorl(0);
9167 ; return 0; }
9168 EOF
9169 if { (eval echo configure:9170: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9170   rm -rf conftest*
9171   use_floorl=yes
9172 else
9173   echo "configure: failed program was:" >&5
9174   cat conftest.$ac_ext >&5
9175   rm -rf conftest*
9176   use_floorl=no
9177 fi
9178 rm -f conftest*
9179   echo "$ac_t""$use_floorl" 1>&6
9180   ac_ext=c
9181 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9182 ac_cpp='$CPP $CPPFLAGS'
9183 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9184 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9185 cross_compiling=$ac_cv_prog_cc_cross
9186
9187   if test x$use_floorl = x"yes"; then
9188     for ac_func in floorl
9189 do
9190 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9191 echo "configure:9192: checking for $ac_func" >&5
9192 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9193   echo $ac_n "(cached) $ac_c" 1>&6
9194 else
9195   cat > conftest.$ac_ext <<EOF
9196 #line 9197 "configure"
9197 #include "confdefs.h"
9198 /* System header to define __stub macros and hopefully few prototypes,
9199     which can conflict with char $ac_func(); below.  */
9200 #include <assert.h>
9201 /* Override any gcc2 internal prototype to avoid an error.  */
9202 /* We use char because int might match the return type of a gcc2
9203     builtin and then its argument prototype would still apply.  */
9204 char $ac_func();
9205
9206 int main() {
9207
9208 /* The GNU C library defines this for functions which it implements
9209     to always fail with ENOSYS.  Some functions are actually named
9210     something starting with __ and the normal name is an alias.  */
9211 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9212 choke me
9213 #else
9214 $ac_func();
9215 #endif
9216
9217 ; return 0; }
9218 EOF
9219 if { (eval echo configure:9220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9220   rm -rf conftest*
9221   eval "ac_cv_func_$ac_func=yes"
9222 else
9223   echo "configure: failed program was:" >&5
9224   cat conftest.$ac_ext >&5
9225   rm -rf conftest*
9226   eval "ac_cv_func_$ac_func=no"
9227 fi
9228 rm -f conftest*
9229 fi
9230
9231 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9232   echo "$ac_t""yes" 1>&6
9233     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9234   cat >> confdefs.h <<EOF
9235 #define $ac_tr_func 1
9236 EOF
9237
9238 else
9239   echo "$ac_t""no" 1>&6
9240 fi
9241 done
9242
9243   fi
9244
9245
9246
9247   ac_ext=C
9248 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9249 ac_cpp='$CXXCPP $CPPFLAGS'
9250 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9251 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9252 cross_compiling=$ac_cv_prog_cxx_cross
9253
9254   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9255 echo "configure:9256: checking for fmodl declaration" >&5
9256   cat > conftest.$ac_ext <<EOF
9257 #line 9258 "configure"
9258 #include "confdefs.h"
9259 #include <math.h>
9260 int main() {
9261  fmodl(0, 0);
9262 ; return 0; }
9263 EOF
9264 if { (eval echo configure:9265: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9265   rm -rf conftest*
9266   use_fmodl=yes
9267 else
9268   echo "configure: failed program was:" >&5
9269   cat conftest.$ac_ext >&5
9270   rm -rf conftest*
9271   use_fmodl=no
9272 fi
9273 rm -f conftest*
9274   echo "$ac_t""$use_fmodl" 1>&6
9275   ac_ext=c
9276 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9277 ac_cpp='$CPP $CPPFLAGS'
9278 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9279 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9280 cross_compiling=$ac_cv_prog_cc_cross
9281
9282   if test x$use_fmodl = x"yes"; then
9283     for ac_func in fmodl
9284 do
9285 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9286 echo "configure:9287: checking for $ac_func" >&5
9287 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9288   echo $ac_n "(cached) $ac_c" 1>&6
9289 else
9290   cat > conftest.$ac_ext <<EOF
9291 #line 9292 "configure"
9292 #include "confdefs.h"
9293 /* System header to define __stub macros and hopefully few prototypes,
9294     which can conflict with char $ac_func(); below.  */
9295 #include <assert.h>
9296 /* Override any gcc2 internal prototype to avoid an error.  */
9297 /* We use char because int might match the return type of a gcc2
9298     builtin and then its argument prototype would still apply.  */
9299 char $ac_func();
9300
9301 int main() {
9302
9303 /* The GNU C library defines this for functions which it implements
9304     to always fail with ENOSYS.  Some functions are actually named
9305     something starting with __ and the normal name is an alias.  */
9306 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9307 choke me
9308 #else
9309 $ac_func();
9310 #endif
9311
9312 ; return 0; }
9313 EOF
9314 if { (eval echo configure:9315: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9315   rm -rf conftest*
9316   eval "ac_cv_func_$ac_func=yes"
9317 else
9318   echo "configure: failed program was:" >&5
9319   cat conftest.$ac_ext >&5
9320   rm -rf conftest*
9321   eval "ac_cv_func_$ac_func=no"
9322 fi
9323 rm -f conftest*
9324 fi
9325
9326 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9327   echo "$ac_t""yes" 1>&6
9328     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9329   cat >> confdefs.h <<EOF
9330 #define $ac_tr_func 1
9331 EOF
9332
9333 else
9334   echo "$ac_t""no" 1>&6
9335 fi
9336 done
9337
9338   fi
9339
9340
9341
9342   ac_ext=C
9343 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9344 ac_cpp='$CXXCPP $CPPFLAGS'
9345 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9346 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9347 cross_compiling=$ac_cv_prog_cxx_cross
9348
9349   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9350 echo "configure:9351: checking for frexpl declaration" >&5
9351   cat > conftest.$ac_ext <<EOF
9352 #line 9353 "configure"
9353 #include "confdefs.h"
9354 #include <math.h>
9355 int main() {
9356  frexpl(0, 0);
9357 ; return 0; }
9358 EOF
9359 if { (eval echo configure:9360: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9360   rm -rf conftest*
9361   use_frexpl=yes
9362 else
9363   echo "configure: failed program was:" >&5
9364   cat conftest.$ac_ext >&5
9365   rm -rf conftest*
9366   use_frexpl=no
9367 fi
9368 rm -f conftest*
9369   echo "$ac_t""$use_frexpl" 1>&6
9370   ac_ext=c
9371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9372 ac_cpp='$CPP $CPPFLAGS'
9373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9375 cross_compiling=$ac_cv_prog_cc_cross
9376
9377   if test x$use_frexpl = x"yes"; then
9378     for ac_func in frexpl
9379 do
9380 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9381 echo "configure:9382: checking for $ac_func" >&5
9382 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9383   echo $ac_n "(cached) $ac_c" 1>&6
9384 else
9385   cat > conftest.$ac_ext <<EOF
9386 #line 9387 "configure"
9387 #include "confdefs.h"
9388 /* System header to define __stub macros and hopefully few prototypes,
9389     which can conflict with char $ac_func(); below.  */
9390 #include <assert.h>
9391 /* Override any gcc2 internal prototype to avoid an error.  */
9392 /* We use char because int might match the return type of a gcc2
9393     builtin and then its argument prototype would still apply.  */
9394 char $ac_func();
9395
9396 int main() {
9397
9398 /* The GNU C library defines this for functions which it implements
9399     to always fail with ENOSYS.  Some functions are actually named
9400     something starting with __ and the normal name is an alias.  */
9401 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9402 choke me
9403 #else
9404 $ac_func();
9405 #endif
9406
9407 ; return 0; }
9408 EOF
9409 if { (eval echo configure:9410: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9410   rm -rf conftest*
9411   eval "ac_cv_func_$ac_func=yes"
9412 else
9413   echo "configure: failed program was:" >&5
9414   cat conftest.$ac_ext >&5
9415   rm -rf conftest*
9416   eval "ac_cv_func_$ac_func=no"
9417 fi
9418 rm -f conftest*
9419 fi
9420
9421 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9422   echo "$ac_t""yes" 1>&6
9423     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9424   cat >> confdefs.h <<EOF
9425 #define $ac_tr_func 1
9426 EOF
9427
9428 else
9429   echo "$ac_t""no" 1>&6
9430 fi
9431 done
9432
9433   fi
9434
9435
9436
9437   ac_ext=C
9438 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9439 ac_cpp='$CXXCPP $CPPFLAGS'
9440 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9441 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9442 cross_compiling=$ac_cv_prog_cxx_cross
9443
9444   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9445 echo "configure:9446: checking for ldexpl declaration" >&5
9446   cat > conftest.$ac_ext <<EOF
9447 #line 9448 "configure"
9448 #include "confdefs.h"
9449 #include <math.h>
9450 int main() {
9451  ldexpl(0, 0);
9452 ; return 0; }
9453 EOF
9454 if { (eval echo configure:9455: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9455   rm -rf conftest*
9456   use_ldexpl=yes
9457 else
9458   echo "configure: failed program was:" >&5
9459   cat conftest.$ac_ext >&5
9460   rm -rf conftest*
9461   use_ldexpl=no
9462 fi
9463 rm -f conftest*
9464   echo "$ac_t""$use_ldexpl" 1>&6
9465   ac_ext=c
9466 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9467 ac_cpp='$CPP $CPPFLAGS'
9468 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9469 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9470 cross_compiling=$ac_cv_prog_cc_cross
9471
9472   if test x$use_ldexpl = x"yes"; then
9473     for ac_func in ldexpl
9474 do
9475 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9476 echo "configure:9477: checking for $ac_func" >&5
9477 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9478   echo $ac_n "(cached) $ac_c" 1>&6
9479 else
9480   cat > conftest.$ac_ext <<EOF
9481 #line 9482 "configure"
9482 #include "confdefs.h"
9483 /* System header to define __stub macros and hopefully few prototypes,
9484     which can conflict with char $ac_func(); below.  */
9485 #include <assert.h>
9486 /* Override any gcc2 internal prototype to avoid an error.  */
9487 /* We use char because int might match the return type of a gcc2
9488     builtin and then its argument prototype would still apply.  */
9489 char $ac_func();
9490
9491 int main() {
9492
9493 /* The GNU C library defines this for functions which it implements
9494     to always fail with ENOSYS.  Some functions are actually named
9495     something starting with __ and the normal name is an alias.  */
9496 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9497 choke me
9498 #else
9499 $ac_func();
9500 #endif
9501
9502 ; return 0; }
9503 EOF
9504 if { (eval echo configure:9505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9505   rm -rf conftest*
9506   eval "ac_cv_func_$ac_func=yes"
9507 else
9508   echo "configure: failed program was:" >&5
9509   cat conftest.$ac_ext >&5
9510   rm -rf conftest*
9511   eval "ac_cv_func_$ac_func=no"
9512 fi
9513 rm -f conftest*
9514 fi
9515
9516 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9517   echo "$ac_t""yes" 1>&6
9518     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9519   cat >> confdefs.h <<EOF
9520 #define $ac_tr_func 1
9521 EOF
9522
9523 else
9524   echo "$ac_t""no" 1>&6
9525 fi
9526 done
9527
9528   fi
9529
9530
9531
9532   ac_ext=C
9533 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9534 ac_cpp='$CXXCPP $CPPFLAGS'
9535 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9536 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9537 cross_compiling=$ac_cv_prog_cxx_cross
9538
9539   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9540 echo "configure:9541: checking for logl declaration" >&5
9541   cat > conftest.$ac_ext <<EOF
9542 #line 9543 "configure"
9543 #include "confdefs.h"
9544 #include <math.h>
9545 int main() {
9546  logl(0);
9547 ; return 0; }
9548 EOF
9549 if { (eval echo configure:9550: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9550   rm -rf conftest*
9551   use_logl=yes
9552 else
9553   echo "configure: failed program was:" >&5
9554   cat conftest.$ac_ext >&5
9555   rm -rf conftest*
9556   use_logl=no
9557 fi
9558 rm -f conftest*
9559   echo "$ac_t""$use_logl" 1>&6
9560   ac_ext=c
9561 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9562 ac_cpp='$CPP $CPPFLAGS'
9563 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9564 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9565 cross_compiling=$ac_cv_prog_cc_cross
9566
9567   if test x$use_logl = x"yes"; then
9568     for ac_func in logl
9569 do
9570 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9571 echo "configure:9572: checking for $ac_func" >&5
9572 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9573   echo $ac_n "(cached) $ac_c" 1>&6
9574 else
9575   cat > conftest.$ac_ext <<EOF
9576 #line 9577 "configure"
9577 #include "confdefs.h"
9578 /* System header to define __stub macros and hopefully few prototypes,
9579     which can conflict with char $ac_func(); below.  */
9580 #include <assert.h>
9581 /* Override any gcc2 internal prototype to avoid an error.  */
9582 /* We use char because int might match the return type of a gcc2
9583     builtin and then its argument prototype would still apply.  */
9584 char $ac_func();
9585
9586 int main() {
9587
9588 /* The GNU C library defines this for functions which it implements
9589     to always fail with ENOSYS.  Some functions are actually named
9590     something starting with __ and the normal name is an alias.  */
9591 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9592 choke me
9593 #else
9594 $ac_func();
9595 #endif
9596
9597 ; return 0; }
9598 EOF
9599 if { (eval echo configure:9600: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9600   rm -rf conftest*
9601   eval "ac_cv_func_$ac_func=yes"
9602 else
9603   echo "configure: failed program was:" >&5
9604   cat conftest.$ac_ext >&5
9605   rm -rf conftest*
9606   eval "ac_cv_func_$ac_func=no"
9607 fi
9608 rm -f conftest*
9609 fi
9610
9611 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9612   echo "$ac_t""yes" 1>&6
9613     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9614   cat >> confdefs.h <<EOF
9615 #define $ac_tr_func 1
9616 EOF
9617
9618 else
9619   echo "$ac_t""no" 1>&6
9620 fi
9621 done
9622
9623   fi
9624
9625
9626
9627   ac_ext=C
9628 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9629 ac_cpp='$CXXCPP $CPPFLAGS'
9630 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9631 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9632 cross_compiling=$ac_cv_prog_cxx_cross
9633
9634   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9635 echo "configure:9636: checking for log10l declaration" >&5
9636   cat > conftest.$ac_ext <<EOF
9637 #line 9638 "configure"
9638 #include "confdefs.h"
9639 #include <math.h>
9640 int main() {
9641  log10l(0);
9642 ; return 0; }
9643 EOF
9644 if { (eval echo configure:9645: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9645   rm -rf conftest*
9646   use_log10l=yes
9647 else
9648   echo "configure: failed program was:" >&5
9649   cat conftest.$ac_ext >&5
9650   rm -rf conftest*
9651   use_log10l=no
9652 fi
9653 rm -f conftest*
9654   echo "$ac_t""$use_log10l" 1>&6
9655   ac_ext=c
9656 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9657 ac_cpp='$CPP $CPPFLAGS'
9658 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9659 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9660 cross_compiling=$ac_cv_prog_cc_cross
9661
9662   if test x$use_log10l = x"yes"; then
9663     for ac_func in log10l
9664 do
9665 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9666 echo "configure:9667: checking for $ac_func" >&5
9667 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9668   echo $ac_n "(cached) $ac_c" 1>&6
9669 else
9670   cat > conftest.$ac_ext <<EOF
9671 #line 9672 "configure"
9672 #include "confdefs.h"
9673 /* System header to define __stub macros and hopefully few prototypes,
9674     which can conflict with char $ac_func(); below.  */
9675 #include <assert.h>
9676 /* Override any gcc2 internal prototype to avoid an error.  */
9677 /* We use char because int might match the return type of a gcc2
9678     builtin and then its argument prototype would still apply.  */
9679 char $ac_func();
9680
9681 int main() {
9682
9683 /* The GNU C library defines this for functions which it implements
9684     to always fail with ENOSYS.  Some functions are actually named
9685     something starting with __ and the normal name is an alias.  */
9686 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9687 choke me
9688 #else
9689 $ac_func();
9690 #endif
9691
9692 ; return 0; }
9693 EOF
9694 if { (eval echo configure:9695: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9695   rm -rf conftest*
9696   eval "ac_cv_func_$ac_func=yes"
9697 else
9698   echo "configure: failed program was:" >&5
9699   cat conftest.$ac_ext >&5
9700   rm -rf conftest*
9701   eval "ac_cv_func_$ac_func=no"
9702 fi
9703 rm -f conftest*
9704 fi
9705
9706 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9707   echo "$ac_t""yes" 1>&6
9708     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9709   cat >> confdefs.h <<EOF
9710 #define $ac_tr_func 1
9711 EOF
9712
9713 else
9714   echo "$ac_t""no" 1>&6
9715 fi
9716 done
9717
9718   fi
9719
9720
9721
9722   ac_ext=C
9723 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9724 ac_cpp='$CXXCPP $CPPFLAGS'
9725 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9726 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9727 cross_compiling=$ac_cv_prog_cxx_cross
9728
9729   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
9730 echo "configure:9731: checking for modfl declaration" >&5
9731   cat > conftest.$ac_ext <<EOF
9732 #line 9733 "configure"
9733 #include "confdefs.h"
9734 #include <math.h>
9735 int main() {
9736  modfl(0, 0);
9737 ; return 0; }
9738 EOF
9739 if { (eval echo configure:9740: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9740   rm -rf conftest*
9741   use_modfl=yes
9742 else
9743   echo "configure: failed program was:" >&5
9744   cat conftest.$ac_ext >&5
9745   rm -rf conftest*
9746   use_modfl=no
9747 fi
9748 rm -f conftest*
9749   echo "$ac_t""$use_modfl" 1>&6
9750   ac_ext=c
9751 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9752 ac_cpp='$CPP $CPPFLAGS'
9753 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9754 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9755 cross_compiling=$ac_cv_prog_cc_cross
9756
9757   if test x$use_modfl = x"yes"; then
9758     for ac_func in modfl
9759 do
9760 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9761 echo "configure:9762: checking for $ac_func" >&5
9762 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9763   echo $ac_n "(cached) $ac_c" 1>&6
9764 else
9765   cat > conftest.$ac_ext <<EOF
9766 #line 9767 "configure"
9767 #include "confdefs.h"
9768 /* System header to define __stub macros and hopefully few prototypes,
9769     which can conflict with char $ac_func(); below.  */
9770 #include <assert.h>
9771 /* Override any gcc2 internal prototype to avoid an error.  */
9772 /* We use char because int might match the return type of a gcc2
9773     builtin and then its argument prototype would still apply.  */
9774 char $ac_func();
9775
9776 int main() {
9777
9778 /* The GNU C library defines this for functions which it implements
9779     to always fail with ENOSYS.  Some functions are actually named
9780     something starting with __ and the normal name is an alias.  */
9781 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9782 choke me
9783 #else
9784 $ac_func();
9785 #endif
9786
9787 ; return 0; }
9788 EOF
9789 if { (eval echo configure:9790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9790   rm -rf conftest*
9791   eval "ac_cv_func_$ac_func=yes"
9792 else
9793   echo "configure: failed program was:" >&5
9794   cat conftest.$ac_ext >&5
9795   rm -rf conftest*
9796   eval "ac_cv_func_$ac_func=no"
9797 fi
9798 rm -f conftest*
9799 fi
9800
9801 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9802   echo "$ac_t""yes" 1>&6
9803     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9804   cat >> confdefs.h <<EOF
9805 #define $ac_tr_func 1
9806 EOF
9807
9808 else
9809   echo "$ac_t""no" 1>&6
9810 fi
9811 done
9812
9813   fi
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 powl declaration""... $ac_c" 1>&6
9825 echo "configure:9826: checking for powl declaration" >&5
9826   cat > conftest.$ac_ext <<EOF
9827 #line 9828 "configure"
9828 #include "confdefs.h"
9829 #include <math.h>
9830 int main() {
9831  powl(0, 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_powl=yes
9837 else
9838   echo "configure: failed program was:" >&5
9839   cat conftest.$ac_ext >&5
9840   rm -rf conftest*
9841   use_powl=no
9842 fi
9843 rm -f conftest*
9844   echo "$ac_t""$use_powl" 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_powl = x"yes"; then
9853     for ac_func in powl
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 sinl declaration""... $ac_c" 1>&6
9920 echo "configure:9921: checking for sinl declaration" >&5
9921   cat > conftest.$ac_ext <<EOF
9922 #line 9923 "configure"
9923 #include "confdefs.h"
9924 #include <math.h>
9925 int main() {
9926  sinl(0, 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_sinl=yes
9932 else
9933   echo "configure: failed program was:" >&5
9934   cat conftest.$ac_ext >&5
9935   rm -rf conftest*
9936   use_sinl=no
9937 fi
9938 rm -f conftest*
9939   echo "$ac_t""$use_sinl" 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_sinl = x"yes"; then
9948     for ac_func in sinl
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 sinhl declaration""... $ac_c" 1>&6
10015 echo "configure:10016: checking for sinhl declaration" >&5
10016   cat > conftest.$ac_ext <<EOF
10017 #line 10018 "configure"
10018 #include "confdefs.h"
10019 #include <math.h>
10020 int main() {
10021  sinhl(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_sinhl=yes
10027 else
10028   echo "configure: failed program was:" >&5
10029   cat conftest.$ac_ext >&5
10030   rm -rf conftest*
10031   use_sinhl=no
10032 fi
10033 rm -f conftest*
10034   echo "$ac_t""$use_sinhl" 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_sinhl = x"yes"; then
10043     for ac_func in sinhl
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 sqrtl declaration""... $ac_c" 1>&6
10110 echo "configure:10111: checking for sqrtl declaration" >&5
10111   cat > conftest.$ac_ext <<EOF
10112 #line 10113 "configure"
10113 #include "confdefs.h"
10114 #include <math.h>
10115 int main() {
10116  sqrtl(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_sqrtl=yes
10122 else
10123   echo "configure: failed program was:" >&5
10124   cat conftest.$ac_ext >&5
10125   rm -rf conftest*
10126   use_sqrtl=no
10127 fi
10128 rm -f conftest*
10129   echo "$ac_t""$use_sqrtl" 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_sqrtl = x"yes"; then
10138     for ac_func in sqrtl
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 tanl declaration""... $ac_c" 1>&6
10205 echo "configure:10206: checking for tanl declaration" >&5
10206   cat > conftest.$ac_ext <<EOF
10207 #line 10208 "configure"
10208 #include "confdefs.h"
10209 #include <math.h>
10210 int main() {
10211  tanl(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_tanl=yes
10217 else
10218   echo "configure: failed program was:" >&5
10219   cat conftest.$ac_ext >&5
10220   rm -rf conftest*
10221   use_tanl=no
10222 fi
10223 rm -f conftest*
10224   echo "$ac_t""$use_tanl" 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_tanl = x"yes"; then
10233     for ac_func in tanl
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 tanhl declaration""... $ac_c" 1>&6
10300 echo "configure:10301: checking for tanhl declaration" >&5
10301   cat > conftest.$ac_ext <<EOF
10302 #line 10303 "configure"
10303 #include "confdefs.h"
10304 #include <math.h>
10305 int main() {
10306  tanhl(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_tanhl=yes
10312 else
10313   echo "configure: failed program was:" >&5
10314   cat conftest.$ac_ext >&5
10315   rm -rf conftest*
10316   use_tanhl=no
10317 fi
10318 rm -f conftest*
10319   echo "$ac_t""$use_tanhl" 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_tanhl = x"yes"; then
10328     for ac_func in tanhl
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 sincosl declaration""... $ac_c" 1>&6
10395 echo "configure:10396: checking for sincosl declaration" >&5
10396   cat > conftest.$ac_ext <<EOF
10397 #line 10398 "configure"
10398 #include "confdefs.h"
10399 #include <math.h>
10400 int main() {
10401  sincosl(0, 0, 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_sincosl=yes
10407 else
10408   echo "configure: failed program was:" >&5
10409   cat conftest.$ac_ext >&5
10410   rm -rf conftest*
10411   use_sincosl=no
10412 fi
10413 rm -f conftest*
10414   echo "$ac_t""$use_sincosl" 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_sincosl = x"yes"; then
10423     for ac_func in sincosl
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   ac_ext=C
10483 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10484 ac_cpp='$CXXCPP $CPPFLAGS'
10485 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10486 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10487 cross_compiling=$ac_cv_prog_cxx_cross
10488
10489   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10490 echo "configure:10491: checking for finitel declaration" >&5
10491   cat > conftest.$ac_ext <<EOF
10492 #line 10493 "configure"
10493 #include "confdefs.h"
10494 #include <math.h>
10495 int main() {
10496  finitel(0);
10497 ; return 0; }
10498 EOF
10499 if { (eval echo configure:10500: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10500   rm -rf conftest*
10501   use_finitel=yes
10502 else
10503   echo "configure: failed program was:" >&5
10504   cat conftest.$ac_ext >&5
10505   rm -rf conftest*
10506   use_finitel=no
10507 fi
10508 rm -f conftest*
10509   echo "$ac_t""$use_finitel" 1>&6
10510   ac_ext=c
10511 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10512 ac_cpp='$CPP $CPPFLAGS'
10513 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10514 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10515 cross_compiling=$ac_cv_prog_cc_cross
10516
10517   if test x$use_finitel = x"yes"; then
10518     for ac_func in finitel
10519 do
10520 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10521 echo "configure:10522: checking for $ac_func" >&5
10522 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10523   echo $ac_n "(cached) $ac_c" 1>&6
10524 else
10525   cat > conftest.$ac_ext <<EOF
10526 #line 10527 "configure"
10527 #include "confdefs.h"
10528 /* System header to define __stub macros and hopefully few prototypes,
10529     which can conflict with char $ac_func(); below.  */
10530 #include <assert.h>
10531 /* Override any gcc2 internal prototype to avoid an error.  */
10532 /* We use char because int might match the return type of a gcc2
10533     builtin and then its argument prototype would still apply.  */
10534 char $ac_func();
10535
10536 int main() {
10537
10538 /* The GNU C library defines this for functions which it implements
10539     to always fail with ENOSYS.  Some functions are actually named
10540     something starting with __ and the normal name is an alias.  */
10541 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10542 choke me
10543 #else
10544 $ac_func();
10545 #endif
10546
10547 ; return 0; }
10548 EOF
10549 if { (eval echo configure:10550: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10550   rm -rf conftest*
10551   eval "ac_cv_func_$ac_func=yes"
10552 else
10553   echo "configure: failed program was:" >&5
10554   cat conftest.$ac_ext >&5
10555   rm -rf conftest*
10556   eval "ac_cv_func_$ac_func=no"
10557 fi
10558 rm -f conftest*
10559 fi
10560
10561 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10562   echo "$ac_t""yes" 1>&6
10563     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10564   cat >> confdefs.h <<EOF
10565 #define $ac_tr_func 1
10566 EOF
10567
10568 else
10569   echo "$ac_t""no" 1>&6
10570 fi
10571 done
10572
10573   fi
10574
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 _isinf declaration""... $ac_c" 1>&6
10586 echo "configure:10587: checking for _isinf declaration" >&5
10587   cat > conftest.$ac_ext <<EOF
10588 #line 10589 "configure"
10589 #include "confdefs.h"
10590 #include <math.h>
10591 int main() {
10592  _isinf(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__isinf=yes
10598 else
10599   echo "configure: failed program was:" >&5
10600   cat conftest.$ac_ext >&5
10601   rm -rf conftest*
10602   use__isinf=no
10603 fi
10604 rm -f conftest*
10605   echo "$ac_t""$use__isinf" 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__isinf = x"yes"; then
10614     for ac_func in _isinf
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 _isnan declaration""... $ac_c" 1>&6
10681 echo "configure:10682: checking for _isnan declaration" >&5
10682   cat > conftest.$ac_ext <<EOF
10683 #line 10684 "configure"
10684 #include "confdefs.h"
10685 #include <math.h>
10686 int main() {
10687  _isnan(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__isnan=yes
10693 else
10694   echo "configure: failed program was:" >&5
10695   cat conftest.$ac_ext >&5
10696   rm -rf conftest*
10697   use__isnan=no
10698 fi
10699 rm -f conftest*
10700   echo "$ac_t""$use__isnan" 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__isnan = x"yes"; then
10709     for ac_func in _isnan
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 _finite declaration""... $ac_c" 1>&6
10776 echo "configure:10777: checking for _finite declaration" >&5
10777   cat > conftest.$ac_ext <<EOF
10778 #line 10779 "configure"
10779 #include "confdefs.h"
10780 #include <math.h>
10781 int main() {
10782  _finite(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__finite=yes
10788 else
10789   echo "configure: failed program was:" >&5
10790   cat conftest.$ac_ext >&5
10791   rm -rf conftest*
10792   use__finite=no
10793 fi
10794 rm -f conftest*
10795   echo "$ac_t""$use__finite" 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__finite = x"yes"; then
10804     for ac_func in _finite
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 _copysign declaration""... $ac_c" 1>&6
10871 echo "configure:10872: checking for _copysign declaration" >&5
10872   cat > conftest.$ac_ext <<EOF
10873 #line 10874 "configure"
10874 #include "confdefs.h"
10875 #include <math.h>
10876 int main() {
10877  _copysign(0, 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__copysign=yes
10883 else
10884   echo "configure: failed program was:" >&5
10885   cat conftest.$ac_ext >&5
10886   rm -rf conftest*
10887   use__copysign=no
10888 fi
10889 rm -f conftest*
10890   echo "$ac_t""$use__copysign" 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__copysign = x"yes"; then
10899     for ac_func in _copysign
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 _sincos declaration""... $ac_c" 1>&6
10966 echo "configure:10967: checking for _sincos declaration" >&5
10967   cat > conftest.$ac_ext <<EOF
10968 #line 10969 "configure"
10969 #include "confdefs.h"
10970 #include <math.h>
10971 int main() {
10972  _sincos(0, 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__sincos=yes
10978 else
10979   echo "configure: failed program was:" >&5
10980   cat conftest.$ac_ext >&5
10981   rm -rf conftest*
10982   use__sincos=no
10983 fi
10984 rm -f conftest*
10985   echo "$ac_t""$use__sincos" 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__sincos = x"yes"; then
10994     for ac_func in _sincos
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 _fpclass declaration""... $ac_c" 1>&6
11061 echo "configure:11062: checking for _fpclass declaration" >&5
11062   cat > conftest.$ac_ext <<EOF
11063 #line 11064 "configure"
11064 #include "confdefs.h"
11065 #include <math.h>
11066 int main() {
11067  _fpclass(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__fpclass=yes
11073 else
11074   echo "configure: failed program was:" >&5
11075   cat conftest.$ac_ext >&5
11076   rm -rf conftest*
11077   use__fpclass=no
11078 fi
11079 rm -f conftest*
11080   echo "$ac_t""$use__fpclass" 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__fpclass = x"yes"; then
11089     for ac_func in _fpclass
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 _qfpclass declaration""... $ac_c" 1>&6
11156 echo "configure:11157: checking for _qfpclass declaration" >&5
11157   cat > conftest.$ac_ext <<EOF
11158 #line 11159 "configure"
11159 #include "confdefs.h"
11160 #include <math.h>
11161 int main() {
11162  _qfpclass(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__qfpclass=yes
11168 else
11169   echo "configure: failed program was:" >&5
11170   cat conftest.$ac_ext >&5
11171   rm -rf conftest*
11172   use__qfpclass=no
11173 fi
11174 rm -f conftest*
11175   echo "$ac_t""$use__qfpclass" 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__qfpclass = x"yes"; then
11184     for ac_func in _qfpclass
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
11244   ac_ext=C
11245 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11246 ac_cpp='$CXXCPP $CPPFLAGS'
11247 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11248 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11249 cross_compiling=$ac_cv_prog_cxx_cross
11250
11251   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11252 echo "configure:11253: checking for _isnanf declaration" >&5
11253   cat > conftest.$ac_ext <<EOF
11254 #line 11255 "configure"
11255 #include "confdefs.h"
11256 #include <math.h>
11257 int main() {
11258  _isnanf(0);
11259 ; return 0; }
11260 EOF
11261 if { (eval echo configure:11262: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11262   rm -rf conftest*
11263   use__isnanf=yes
11264 else
11265   echo "configure: failed program was:" >&5
11266   cat conftest.$ac_ext >&5
11267   rm -rf conftest*
11268   use__isnanf=no
11269 fi
11270 rm -f conftest*
11271   echo "$ac_t""$use__isnanf" 1>&6
11272   ac_ext=c
11273 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11274 ac_cpp='$CPP $CPPFLAGS'
11275 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11276 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11277 cross_compiling=$ac_cv_prog_cc_cross
11278
11279   if test x$use__isnanf = x"yes"; then
11280     for ac_func in _isnanf
11281 do
11282 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11283 echo "configure:11284: checking for $ac_func" >&5
11284 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11285   echo $ac_n "(cached) $ac_c" 1>&6
11286 else
11287   cat > conftest.$ac_ext <<EOF
11288 #line 11289 "configure"
11289 #include "confdefs.h"
11290 /* System header to define __stub macros and hopefully few prototypes,
11291     which can conflict with char $ac_func(); below.  */
11292 #include <assert.h>
11293 /* Override any gcc2 internal prototype to avoid an error.  */
11294 /* We use char because int might match the return type of a gcc2
11295     builtin and then its argument prototype would still apply.  */
11296 char $ac_func();
11297
11298 int main() {
11299
11300 /* The GNU C library defines this for functions which it implements
11301     to always fail with ENOSYS.  Some functions are actually named
11302     something starting with __ and the normal name is an alias.  */
11303 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11304 choke me
11305 #else
11306 $ac_func();
11307 #endif
11308
11309 ; return 0; }
11310 EOF
11311 if { (eval echo configure:11312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11312   rm -rf conftest*
11313   eval "ac_cv_func_$ac_func=yes"
11314 else
11315   echo "configure: failed program was:" >&5
11316   cat conftest.$ac_ext >&5
11317   rm -rf conftest*
11318   eval "ac_cv_func_$ac_func=no"
11319 fi
11320 rm -f conftest*
11321 fi
11322
11323 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11324   echo "$ac_t""yes" 1>&6
11325     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11326   cat >> confdefs.h <<EOF
11327 #define $ac_tr_func 1
11328 EOF
11329
11330 else
11331   echo "$ac_t""no" 1>&6
11332 fi
11333 done
11334
11335   fi
11336
11337
11338
11339   ac_ext=C
11340 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11341 ac_cpp='$CXXCPP $CPPFLAGS'
11342 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11343 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11344 cross_compiling=$ac_cv_prog_cxx_cross
11345
11346   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11347 echo "configure:11348: checking for _isinff declaration" >&5
11348   cat > conftest.$ac_ext <<EOF
11349 #line 11350 "configure"
11350 #include "confdefs.h"
11351 #include <math.h>
11352 int main() {
11353  _isinff(0);
11354 ; return 0; }
11355 EOF
11356 if { (eval echo configure:11357: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11357   rm -rf conftest*
11358   use__isinff=yes
11359 else
11360   echo "configure: failed program was:" >&5
11361   cat conftest.$ac_ext >&5
11362   rm -rf conftest*
11363   use__isinff=no
11364 fi
11365 rm -f conftest*
11366   echo "$ac_t""$use__isinff" 1>&6
11367   ac_ext=c
11368 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11369 ac_cpp='$CPP $CPPFLAGS'
11370 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11371 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11372 cross_compiling=$ac_cv_prog_cc_cross
11373
11374   if test x$use__isinff = x"yes"; then
11375     for ac_func in _isinff
11376 do
11377 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11378 echo "configure:11379: checking for $ac_func" >&5
11379 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11380   echo $ac_n "(cached) $ac_c" 1>&6
11381 else
11382   cat > conftest.$ac_ext <<EOF
11383 #line 11384 "configure"
11384 #include "confdefs.h"
11385 /* System header to define __stub macros and hopefully few prototypes,
11386     which can conflict with char $ac_func(); below.  */
11387 #include <assert.h>
11388 /* Override any gcc2 internal prototype to avoid an error.  */
11389 /* We use char because int might match the return type of a gcc2
11390     builtin and then its argument prototype would still apply.  */
11391 char $ac_func();
11392
11393 int main() {
11394
11395 /* The GNU C library defines this for functions which it implements
11396     to always fail with ENOSYS.  Some functions are actually named
11397     something starting with __ and the normal name is an alias.  */
11398 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11399 choke me
11400 #else
11401 $ac_func();
11402 #endif
11403
11404 ; return 0; }
11405 EOF
11406 if { (eval echo configure:11407: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11407   rm -rf conftest*
11408   eval "ac_cv_func_$ac_func=yes"
11409 else
11410   echo "configure: failed program was:" >&5
11411   cat conftest.$ac_ext >&5
11412   rm -rf conftest*
11413   eval "ac_cv_func_$ac_func=no"
11414 fi
11415 rm -f conftest*
11416 fi
11417
11418 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11419   echo "$ac_t""yes" 1>&6
11420     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11421   cat >> confdefs.h <<EOF
11422 #define $ac_tr_func 1
11423 EOF
11424
11425 else
11426   echo "$ac_t""no" 1>&6
11427 fi
11428 done
11429
11430   fi
11431
11432
11433
11434   ac_ext=C
11435 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11436 ac_cpp='$CXXCPP $CPPFLAGS'
11437 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11438 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11439 cross_compiling=$ac_cv_prog_cxx_cross
11440
11441   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11442 echo "configure:11443: checking for _acosf declaration" >&5
11443   cat > conftest.$ac_ext <<EOF
11444 #line 11445 "configure"
11445 #include "confdefs.h"
11446 #include <math.h>
11447 int main() {
11448  _acosf(0);
11449 ; return 0; }
11450 EOF
11451 if { (eval echo configure:11452: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11452   rm -rf conftest*
11453   use__acosf=yes
11454 else
11455   echo "configure: failed program was:" >&5
11456   cat conftest.$ac_ext >&5
11457   rm -rf conftest*
11458   use__acosf=no
11459 fi
11460 rm -f conftest*
11461   echo "$ac_t""$use__acosf" 1>&6
11462   ac_ext=c
11463 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11464 ac_cpp='$CPP $CPPFLAGS'
11465 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11466 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11467 cross_compiling=$ac_cv_prog_cc_cross
11468
11469   if test x$use__acosf = x"yes"; then
11470     for ac_func in _acosf
11471 do
11472 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11473 echo "configure:11474: checking for $ac_func" >&5
11474 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11475   echo $ac_n "(cached) $ac_c" 1>&6
11476 else
11477   cat > conftest.$ac_ext <<EOF
11478 #line 11479 "configure"
11479 #include "confdefs.h"
11480 /* System header to define __stub macros and hopefully few prototypes,
11481     which can conflict with char $ac_func(); below.  */
11482 #include <assert.h>
11483 /* Override any gcc2 internal prototype to avoid an error.  */
11484 /* We use char because int might match the return type of a gcc2
11485     builtin and then its argument prototype would still apply.  */
11486 char $ac_func();
11487
11488 int main() {
11489
11490 /* The GNU C library defines this for functions which it implements
11491     to always fail with ENOSYS.  Some functions are actually named
11492     something starting with __ and the normal name is an alias.  */
11493 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11494 choke me
11495 #else
11496 $ac_func();
11497 #endif
11498
11499 ; return 0; }
11500 EOF
11501 if { (eval echo configure:11502: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11502   rm -rf conftest*
11503   eval "ac_cv_func_$ac_func=yes"
11504 else
11505   echo "configure: failed program was:" >&5
11506   cat conftest.$ac_ext >&5
11507   rm -rf conftest*
11508   eval "ac_cv_func_$ac_func=no"
11509 fi
11510 rm -f conftest*
11511 fi
11512
11513 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11514   echo "$ac_t""yes" 1>&6
11515     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11516   cat >> confdefs.h <<EOF
11517 #define $ac_tr_func 1
11518 EOF
11519
11520 else
11521   echo "$ac_t""no" 1>&6
11522 fi
11523 done
11524
11525   fi
11526
11527
11528
11529   ac_ext=C
11530 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11531 ac_cpp='$CXXCPP $CPPFLAGS'
11532 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11533 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11534 cross_compiling=$ac_cv_prog_cxx_cross
11535
11536   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11537 echo "configure:11538: checking for _asinf declaration" >&5
11538   cat > conftest.$ac_ext <<EOF
11539 #line 11540 "configure"
11540 #include "confdefs.h"
11541 #include <math.h>
11542 int main() {
11543  _asinf(0);
11544 ; return 0; }
11545 EOF
11546 if { (eval echo configure:11547: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11547   rm -rf conftest*
11548   use__asinf=yes
11549 else
11550   echo "configure: failed program was:" >&5
11551   cat conftest.$ac_ext >&5
11552   rm -rf conftest*
11553   use__asinf=no
11554 fi
11555 rm -f conftest*
11556   echo "$ac_t""$use__asinf" 1>&6
11557   ac_ext=c
11558 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11559 ac_cpp='$CPP $CPPFLAGS'
11560 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11561 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11562 cross_compiling=$ac_cv_prog_cc_cross
11563
11564   if test x$use__asinf = x"yes"; then
11565     for ac_func in _asinf
11566 do
11567 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11568 echo "configure:11569: checking for $ac_func" >&5
11569 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11570   echo $ac_n "(cached) $ac_c" 1>&6
11571 else
11572   cat > conftest.$ac_ext <<EOF
11573 #line 11574 "configure"
11574 #include "confdefs.h"
11575 /* System header to define __stub macros and hopefully few prototypes,
11576     which can conflict with char $ac_func(); below.  */
11577 #include <assert.h>
11578 /* Override any gcc2 internal prototype to avoid an error.  */
11579 /* We use char because int might match the return type of a gcc2
11580     builtin and then its argument prototype would still apply.  */
11581 char $ac_func();
11582
11583 int main() {
11584
11585 /* The GNU C library defines this for functions which it implements
11586     to always fail with ENOSYS.  Some functions are actually named
11587     something starting with __ and the normal name is an alias.  */
11588 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11589 choke me
11590 #else
11591 $ac_func();
11592 #endif
11593
11594 ; return 0; }
11595 EOF
11596 if { (eval echo configure:11597: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11597   rm -rf conftest*
11598   eval "ac_cv_func_$ac_func=yes"
11599 else
11600   echo "configure: failed program was:" >&5
11601   cat conftest.$ac_ext >&5
11602   rm -rf conftest*
11603   eval "ac_cv_func_$ac_func=no"
11604 fi
11605 rm -f conftest*
11606 fi
11607
11608 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11609   echo "$ac_t""yes" 1>&6
11610     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11611   cat >> confdefs.h <<EOF
11612 #define $ac_tr_func 1
11613 EOF
11614
11615 else
11616   echo "$ac_t""no" 1>&6
11617 fi
11618 done
11619
11620   fi
11621
11622
11623
11624   ac_ext=C
11625 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11626 ac_cpp='$CXXCPP $CPPFLAGS'
11627 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11628 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11629 cross_compiling=$ac_cv_prog_cxx_cross
11630
11631   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
11632 echo "configure:11633: checking for _atanf declaration" >&5
11633   cat > conftest.$ac_ext <<EOF
11634 #line 11635 "configure"
11635 #include "confdefs.h"
11636 #include <math.h>
11637 int main() {
11638  _atanf(0);
11639 ; return 0; }
11640 EOF
11641 if { (eval echo configure:11642: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11642   rm -rf conftest*
11643   use__atanf=yes
11644 else
11645   echo "configure: failed program was:" >&5
11646   cat conftest.$ac_ext >&5
11647   rm -rf conftest*
11648   use__atanf=no
11649 fi
11650 rm -f conftest*
11651   echo "$ac_t""$use__atanf" 1>&6
11652   ac_ext=c
11653 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11654 ac_cpp='$CPP $CPPFLAGS'
11655 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11656 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11657 cross_compiling=$ac_cv_prog_cc_cross
11658
11659   if test x$use__atanf = x"yes"; then
11660     for ac_func in _atanf
11661 do
11662 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11663 echo "configure:11664: checking for $ac_func" >&5
11664 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11665   echo $ac_n "(cached) $ac_c" 1>&6
11666 else
11667   cat > conftest.$ac_ext <<EOF
11668 #line 11669 "configure"
11669 #include "confdefs.h"
11670 /* System header to define __stub macros and hopefully few prototypes,
11671     which can conflict with char $ac_func(); below.  */
11672 #include <assert.h>
11673 /* Override any gcc2 internal prototype to avoid an error.  */
11674 /* We use char because int might match the return type of a gcc2
11675     builtin and then its argument prototype would still apply.  */
11676 char $ac_func();
11677
11678 int main() {
11679
11680 /* The GNU C library defines this for functions which it implements
11681     to always fail with ENOSYS.  Some functions are actually named
11682     something starting with __ and the normal name is an alias.  */
11683 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11684 choke me
11685 #else
11686 $ac_func();
11687 #endif
11688
11689 ; return 0; }
11690 EOF
11691 if { (eval echo configure:11692: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11692   rm -rf conftest*
11693   eval "ac_cv_func_$ac_func=yes"
11694 else
11695   echo "configure: failed program was:" >&5
11696   cat conftest.$ac_ext >&5
11697   rm -rf conftest*
11698   eval "ac_cv_func_$ac_func=no"
11699 fi
11700 rm -f conftest*
11701 fi
11702
11703 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11704   echo "$ac_t""yes" 1>&6
11705     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11706   cat >> confdefs.h <<EOF
11707 #define $ac_tr_func 1
11708 EOF
11709
11710 else
11711   echo "$ac_t""no" 1>&6
11712 fi
11713 done
11714
11715   fi
11716
11717
11718
11719   ac_ext=C
11720 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11721 ac_cpp='$CXXCPP $CPPFLAGS'
11722 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11723 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11724 cross_compiling=$ac_cv_prog_cxx_cross
11725
11726   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
11727 echo "configure:11728: checking for _atan2f declaration" >&5
11728   cat > conftest.$ac_ext <<EOF
11729 #line 11730 "configure"
11730 #include "confdefs.h"
11731 #include <math.h>
11732 int main() {
11733  _atan2f(0, 0);
11734 ; return 0; }
11735 EOF
11736 if { (eval echo configure:11737: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11737   rm -rf conftest*
11738   use__atan2f=yes
11739 else
11740   echo "configure: failed program was:" >&5
11741   cat conftest.$ac_ext >&5
11742   rm -rf conftest*
11743   use__atan2f=no
11744 fi
11745 rm -f conftest*
11746   echo "$ac_t""$use__atan2f" 1>&6
11747   ac_ext=c
11748 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11749 ac_cpp='$CPP $CPPFLAGS'
11750 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11751 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11752 cross_compiling=$ac_cv_prog_cc_cross
11753
11754   if test x$use__atan2f = x"yes"; then
11755     for ac_func in _atan2f
11756 do
11757 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11758 echo "configure:11759: checking for $ac_func" >&5
11759 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11760   echo $ac_n "(cached) $ac_c" 1>&6
11761 else
11762   cat > conftest.$ac_ext <<EOF
11763 #line 11764 "configure"
11764 #include "confdefs.h"
11765 /* System header to define __stub macros and hopefully few prototypes,
11766     which can conflict with char $ac_func(); below.  */
11767 #include <assert.h>
11768 /* Override any gcc2 internal prototype to avoid an error.  */
11769 /* We use char because int might match the return type of a gcc2
11770     builtin and then its argument prototype would still apply.  */
11771 char $ac_func();
11772
11773 int main() {
11774
11775 /* The GNU C library defines this for functions which it implements
11776     to always fail with ENOSYS.  Some functions are actually named
11777     something starting with __ and the normal name is an alias.  */
11778 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11779 choke me
11780 #else
11781 $ac_func();
11782 #endif
11783
11784 ; return 0; }
11785 EOF
11786 if { (eval echo configure:11787: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11787   rm -rf conftest*
11788   eval "ac_cv_func_$ac_func=yes"
11789 else
11790   echo "configure: failed program was:" >&5
11791   cat conftest.$ac_ext >&5
11792   rm -rf conftest*
11793   eval "ac_cv_func_$ac_func=no"
11794 fi
11795 rm -f conftest*
11796 fi
11797
11798 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11799   echo "$ac_t""yes" 1>&6
11800     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11801   cat >> confdefs.h <<EOF
11802 #define $ac_tr_func 1
11803 EOF
11804
11805 else
11806   echo "$ac_t""no" 1>&6
11807 fi
11808 done
11809
11810   fi
11811
11812
11813
11814   ac_ext=C
11815 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11816 ac_cpp='$CXXCPP $CPPFLAGS'
11817 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11818 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11819 cross_compiling=$ac_cv_prog_cxx_cross
11820
11821   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
11822 echo "configure:11823: checking for _ceilf declaration" >&5
11823   cat > conftest.$ac_ext <<EOF
11824 #line 11825 "configure"
11825 #include "confdefs.h"
11826 #include <math.h>
11827 int main() {
11828  _ceilf(0);
11829 ; return 0; }
11830 EOF
11831 if { (eval echo configure:11832: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11832   rm -rf conftest*
11833   use__ceilf=yes
11834 else
11835   echo "configure: failed program was:" >&5
11836   cat conftest.$ac_ext >&5
11837   rm -rf conftest*
11838   use__ceilf=no
11839 fi
11840 rm -f conftest*
11841   echo "$ac_t""$use__ceilf" 1>&6
11842   ac_ext=c
11843 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11844 ac_cpp='$CPP $CPPFLAGS'
11845 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11846 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11847 cross_compiling=$ac_cv_prog_cc_cross
11848
11849   if test x$use__ceilf = x"yes"; then
11850     for ac_func in _ceilf
11851 do
11852 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11853 echo "configure:11854: checking for $ac_func" >&5
11854 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11855   echo $ac_n "(cached) $ac_c" 1>&6
11856 else
11857   cat > conftest.$ac_ext <<EOF
11858 #line 11859 "configure"
11859 #include "confdefs.h"
11860 /* System header to define __stub macros and hopefully few prototypes,
11861     which can conflict with char $ac_func(); below.  */
11862 #include <assert.h>
11863 /* Override any gcc2 internal prototype to avoid an error.  */
11864 /* We use char because int might match the return type of a gcc2
11865     builtin and then its argument prototype would still apply.  */
11866 char $ac_func();
11867
11868 int main() {
11869
11870 /* The GNU C library defines this for functions which it implements
11871     to always fail with ENOSYS.  Some functions are actually named
11872     something starting with __ and the normal name is an alias.  */
11873 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11874 choke me
11875 #else
11876 $ac_func();
11877 #endif
11878
11879 ; return 0; }
11880 EOF
11881 if { (eval echo configure:11882: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11882   rm -rf conftest*
11883   eval "ac_cv_func_$ac_func=yes"
11884 else
11885   echo "configure: failed program was:" >&5
11886   cat conftest.$ac_ext >&5
11887   rm -rf conftest*
11888   eval "ac_cv_func_$ac_func=no"
11889 fi
11890 rm -f conftest*
11891 fi
11892
11893 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11894   echo "$ac_t""yes" 1>&6
11895     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11896   cat >> confdefs.h <<EOF
11897 #define $ac_tr_func 1
11898 EOF
11899
11900 else
11901   echo "$ac_t""no" 1>&6
11902 fi
11903 done
11904
11905   fi
11906
11907
11908
11909   ac_ext=C
11910 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11911 ac_cpp='$CXXCPP $CPPFLAGS'
11912 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11913 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11914 cross_compiling=$ac_cv_prog_cxx_cross
11915
11916   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
11917 echo "configure:11918: checking for _cosf declaration" >&5
11918   cat > conftest.$ac_ext <<EOF
11919 #line 11920 "configure"
11920 #include "confdefs.h"
11921 #include <math.h>
11922 int main() {
11923  _cosf(0);
11924 ; return 0; }
11925 EOF
11926 if { (eval echo configure:11927: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11927   rm -rf conftest*
11928   use__cosf=yes
11929 else
11930   echo "configure: failed program was:" >&5
11931   cat conftest.$ac_ext >&5
11932   rm -rf conftest*
11933   use__cosf=no
11934 fi
11935 rm -f conftest*
11936   echo "$ac_t""$use__cosf" 1>&6
11937   ac_ext=c
11938 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11939 ac_cpp='$CPP $CPPFLAGS'
11940 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11941 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11942 cross_compiling=$ac_cv_prog_cc_cross
11943
11944   if test x$use__cosf = x"yes"; then
11945     for ac_func in _cosf
11946 do
11947 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11948 echo "configure:11949: checking for $ac_func" >&5
11949 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11950   echo $ac_n "(cached) $ac_c" 1>&6
11951 else
11952   cat > conftest.$ac_ext <<EOF
11953 #line 11954 "configure"
11954 #include "confdefs.h"
11955 /* System header to define __stub macros and hopefully few prototypes,
11956     which can conflict with char $ac_func(); below.  */
11957 #include <assert.h>
11958 /* Override any gcc2 internal prototype to avoid an error.  */
11959 /* We use char because int might match the return type of a gcc2
11960     builtin and then its argument prototype would still apply.  */
11961 char $ac_func();
11962
11963 int main() {
11964
11965 /* The GNU C library defines this for functions which it implements
11966     to always fail with ENOSYS.  Some functions are actually named
11967     something starting with __ and the normal name is an alias.  */
11968 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11969 choke me
11970 #else
11971 $ac_func();
11972 #endif
11973
11974 ; return 0; }
11975 EOF
11976 if { (eval echo configure:11977: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11977   rm -rf conftest*
11978   eval "ac_cv_func_$ac_func=yes"
11979 else
11980   echo "configure: failed program was:" >&5
11981   cat conftest.$ac_ext >&5
11982   rm -rf conftest*
11983   eval "ac_cv_func_$ac_func=no"
11984 fi
11985 rm -f conftest*
11986 fi
11987
11988 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11989   echo "$ac_t""yes" 1>&6
11990     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11991   cat >> confdefs.h <<EOF
11992 #define $ac_tr_func 1
11993 EOF
11994
11995 else
11996   echo "$ac_t""no" 1>&6
11997 fi
11998 done
11999
12000   fi
12001
12002
12003
12004   ac_ext=C
12005 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12006 ac_cpp='$CXXCPP $CPPFLAGS'
12007 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12008 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12009 cross_compiling=$ac_cv_prog_cxx_cross
12010
12011   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12012 echo "configure:12013: checking for _coshf declaration" >&5
12013   cat > conftest.$ac_ext <<EOF
12014 #line 12015 "configure"
12015 #include "confdefs.h"
12016 #include <math.h>
12017 int main() {
12018  _coshf(0);
12019 ; return 0; }
12020 EOF
12021 if { (eval echo configure:12022: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12022   rm -rf conftest*
12023   use__coshf=yes
12024 else
12025   echo "configure: failed program was:" >&5
12026   cat conftest.$ac_ext >&5
12027   rm -rf conftest*
12028   use__coshf=no
12029 fi
12030 rm -f conftest*
12031   echo "$ac_t""$use__coshf" 1>&6
12032   ac_ext=c
12033 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12034 ac_cpp='$CPP $CPPFLAGS'
12035 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12036 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12037 cross_compiling=$ac_cv_prog_cc_cross
12038
12039   if test x$use__coshf = x"yes"; then
12040     for ac_func in _coshf
12041 do
12042 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12043 echo "configure:12044: checking for $ac_func" >&5
12044 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12045   echo $ac_n "(cached) $ac_c" 1>&6
12046 else
12047   cat > conftest.$ac_ext <<EOF
12048 #line 12049 "configure"
12049 #include "confdefs.h"
12050 /* System header to define __stub macros and hopefully few prototypes,
12051     which can conflict with char $ac_func(); below.  */
12052 #include <assert.h>
12053 /* Override any gcc2 internal prototype to avoid an error.  */
12054 /* We use char because int might match the return type of a gcc2
12055     builtin and then its argument prototype would still apply.  */
12056 char $ac_func();
12057
12058 int main() {
12059
12060 /* The GNU C library defines this for functions which it implements
12061     to always fail with ENOSYS.  Some functions are actually named
12062     something starting with __ and the normal name is an alias.  */
12063 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12064 choke me
12065 #else
12066 $ac_func();
12067 #endif
12068
12069 ; return 0; }
12070 EOF
12071 if { (eval echo configure:12072: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12072   rm -rf conftest*
12073   eval "ac_cv_func_$ac_func=yes"
12074 else
12075   echo "configure: failed program was:" >&5
12076   cat conftest.$ac_ext >&5
12077   rm -rf conftest*
12078   eval "ac_cv_func_$ac_func=no"
12079 fi
12080 rm -f conftest*
12081 fi
12082
12083 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12084   echo "$ac_t""yes" 1>&6
12085     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12086   cat >> confdefs.h <<EOF
12087 #define $ac_tr_func 1
12088 EOF
12089
12090 else
12091   echo "$ac_t""no" 1>&6
12092 fi
12093 done
12094
12095   fi
12096
12097
12098
12099   ac_ext=C
12100 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12101 ac_cpp='$CXXCPP $CPPFLAGS'
12102 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12103 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12104 cross_compiling=$ac_cv_prog_cxx_cross
12105
12106   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12107 echo "configure:12108: checking for _expf declaration" >&5
12108   cat > conftest.$ac_ext <<EOF
12109 #line 12110 "configure"
12110 #include "confdefs.h"
12111 #include <math.h>
12112 int main() {
12113  _expf(0);
12114 ; return 0; }
12115 EOF
12116 if { (eval echo configure:12117: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12117   rm -rf conftest*
12118   use__expf=yes
12119 else
12120   echo "configure: failed program was:" >&5
12121   cat conftest.$ac_ext >&5
12122   rm -rf conftest*
12123   use__expf=no
12124 fi
12125 rm -f conftest*
12126   echo "$ac_t""$use__expf" 1>&6
12127   ac_ext=c
12128 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12129 ac_cpp='$CPP $CPPFLAGS'
12130 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12131 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12132 cross_compiling=$ac_cv_prog_cc_cross
12133
12134   if test x$use__expf = x"yes"; then
12135     for ac_func in _expf
12136 do
12137 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12138 echo "configure:12139: checking for $ac_func" >&5
12139 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12140   echo $ac_n "(cached) $ac_c" 1>&6
12141 else
12142   cat > conftest.$ac_ext <<EOF
12143 #line 12144 "configure"
12144 #include "confdefs.h"
12145 /* System header to define __stub macros and hopefully few prototypes,
12146     which can conflict with char $ac_func(); below.  */
12147 #include <assert.h>
12148 /* Override any gcc2 internal prototype to avoid an error.  */
12149 /* We use char because int might match the return type of a gcc2
12150     builtin and then its argument prototype would still apply.  */
12151 char $ac_func();
12152
12153 int main() {
12154
12155 /* The GNU C library defines this for functions which it implements
12156     to always fail with ENOSYS.  Some functions are actually named
12157     something starting with __ and the normal name is an alias.  */
12158 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12159 choke me
12160 #else
12161 $ac_func();
12162 #endif
12163
12164 ; return 0; }
12165 EOF
12166 if { (eval echo configure:12167: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12167   rm -rf conftest*
12168   eval "ac_cv_func_$ac_func=yes"
12169 else
12170   echo "configure: failed program was:" >&5
12171   cat conftest.$ac_ext >&5
12172   rm -rf conftest*
12173   eval "ac_cv_func_$ac_func=no"
12174 fi
12175 rm -f conftest*
12176 fi
12177
12178 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12179   echo "$ac_t""yes" 1>&6
12180     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12181   cat >> confdefs.h <<EOF
12182 #define $ac_tr_func 1
12183 EOF
12184
12185 else
12186   echo "$ac_t""no" 1>&6
12187 fi
12188 done
12189
12190   fi
12191
12192
12193
12194   ac_ext=C
12195 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12196 ac_cpp='$CXXCPP $CPPFLAGS'
12197 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12198 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12199 cross_compiling=$ac_cv_prog_cxx_cross
12200
12201   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12202 echo "configure:12203: checking for _fabsf declaration" >&5
12203   cat > conftest.$ac_ext <<EOF
12204 #line 12205 "configure"
12205 #include "confdefs.h"
12206 #include <math.h>
12207 int main() {
12208  _fabsf(0);
12209 ; return 0; }
12210 EOF
12211 if { (eval echo configure:12212: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12212   rm -rf conftest*
12213   use__fabsf=yes
12214 else
12215   echo "configure: failed program was:" >&5
12216   cat conftest.$ac_ext >&5
12217   rm -rf conftest*
12218   use__fabsf=no
12219 fi
12220 rm -f conftest*
12221   echo "$ac_t""$use__fabsf" 1>&6
12222   ac_ext=c
12223 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12224 ac_cpp='$CPP $CPPFLAGS'
12225 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12226 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12227 cross_compiling=$ac_cv_prog_cc_cross
12228
12229   if test x$use__fabsf = x"yes"; then
12230     for ac_func in _fabsf
12231 do
12232 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12233 echo "configure:12234: checking for $ac_func" >&5
12234 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12235   echo $ac_n "(cached) $ac_c" 1>&6
12236 else
12237   cat > conftest.$ac_ext <<EOF
12238 #line 12239 "configure"
12239 #include "confdefs.h"
12240 /* System header to define __stub macros and hopefully few prototypes,
12241     which can conflict with char $ac_func(); below.  */
12242 #include <assert.h>
12243 /* Override any gcc2 internal prototype to avoid an error.  */
12244 /* We use char because int might match the return type of a gcc2
12245     builtin and then its argument prototype would still apply.  */
12246 char $ac_func();
12247
12248 int main() {
12249
12250 /* The GNU C library defines this for functions which it implements
12251     to always fail with ENOSYS.  Some functions are actually named
12252     something starting with __ and the normal name is an alias.  */
12253 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12254 choke me
12255 #else
12256 $ac_func();
12257 #endif
12258
12259 ; return 0; }
12260 EOF
12261 if { (eval echo configure:12262: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12262   rm -rf conftest*
12263   eval "ac_cv_func_$ac_func=yes"
12264 else
12265   echo "configure: failed program was:" >&5
12266   cat conftest.$ac_ext >&5
12267   rm -rf conftest*
12268   eval "ac_cv_func_$ac_func=no"
12269 fi
12270 rm -f conftest*
12271 fi
12272
12273 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12274   echo "$ac_t""yes" 1>&6
12275     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12276   cat >> confdefs.h <<EOF
12277 #define $ac_tr_func 1
12278 EOF
12279
12280 else
12281   echo "$ac_t""no" 1>&6
12282 fi
12283 done
12284
12285   fi
12286
12287
12288
12289   ac_ext=C
12290 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12291 ac_cpp='$CXXCPP $CPPFLAGS'
12292 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12293 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12294 cross_compiling=$ac_cv_prog_cxx_cross
12295
12296   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12297 echo "configure:12298: checking for _floorf declaration" >&5
12298   cat > conftest.$ac_ext <<EOF
12299 #line 12300 "configure"
12300 #include "confdefs.h"
12301 #include <math.h>
12302 int main() {
12303  _floorf(0);
12304 ; return 0; }
12305 EOF
12306 if { (eval echo configure:12307: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12307   rm -rf conftest*
12308   use__floorf=yes
12309 else
12310   echo "configure: failed program was:" >&5
12311   cat conftest.$ac_ext >&5
12312   rm -rf conftest*
12313   use__floorf=no
12314 fi
12315 rm -f conftest*
12316   echo "$ac_t""$use__floorf" 1>&6
12317   ac_ext=c
12318 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12319 ac_cpp='$CPP $CPPFLAGS'
12320 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12321 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12322 cross_compiling=$ac_cv_prog_cc_cross
12323
12324   if test x$use__floorf = x"yes"; then
12325     for ac_func in _floorf
12326 do
12327 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12328 echo "configure:12329: checking for $ac_func" >&5
12329 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12330   echo $ac_n "(cached) $ac_c" 1>&6
12331 else
12332   cat > conftest.$ac_ext <<EOF
12333 #line 12334 "configure"
12334 #include "confdefs.h"
12335 /* System header to define __stub macros and hopefully few prototypes,
12336     which can conflict with char $ac_func(); below.  */
12337 #include <assert.h>
12338 /* Override any gcc2 internal prototype to avoid an error.  */
12339 /* We use char because int might match the return type of a gcc2
12340     builtin and then its argument prototype would still apply.  */
12341 char $ac_func();
12342
12343 int main() {
12344
12345 /* The GNU C library defines this for functions which it implements
12346     to always fail with ENOSYS.  Some functions are actually named
12347     something starting with __ and the normal name is an alias.  */
12348 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12349 choke me
12350 #else
12351 $ac_func();
12352 #endif
12353
12354 ; return 0; }
12355 EOF
12356 if { (eval echo configure:12357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12357   rm -rf conftest*
12358   eval "ac_cv_func_$ac_func=yes"
12359 else
12360   echo "configure: failed program was:" >&5
12361   cat conftest.$ac_ext >&5
12362   rm -rf conftest*
12363   eval "ac_cv_func_$ac_func=no"
12364 fi
12365 rm -f conftest*
12366 fi
12367
12368 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12369   echo "$ac_t""yes" 1>&6
12370     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12371   cat >> confdefs.h <<EOF
12372 #define $ac_tr_func 1
12373 EOF
12374
12375 else
12376   echo "$ac_t""no" 1>&6
12377 fi
12378 done
12379
12380   fi
12381
12382
12383
12384   ac_ext=C
12385 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12386 ac_cpp='$CXXCPP $CPPFLAGS'
12387 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12388 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12389 cross_compiling=$ac_cv_prog_cxx_cross
12390
12391   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12392 echo "configure:12393: checking for _fmodf declaration" >&5
12393   cat > conftest.$ac_ext <<EOF
12394 #line 12395 "configure"
12395 #include "confdefs.h"
12396 #include <math.h>
12397 int main() {
12398  _fmodf(0, 0);
12399 ; return 0; }
12400 EOF
12401 if { (eval echo configure:12402: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12402   rm -rf conftest*
12403   use__fmodf=yes
12404 else
12405   echo "configure: failed program was:" >&5
12406   cat conftest.$ac_ext >&5
12407   rm -rf conftest*
12408   use__fmodf=no
12409 fi
12410 rm -f conftest*
12411   echo "$ac_t""$use__fmodf" 1>&6
12412   ac_ext=c
12413 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12414 ac_cpp='$CPP $CPPFLAGS'
12415 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12416 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12417 cross_compiling=$ac_cv_prog_cc_cross
12418
12419   if test x$use__fmodf = x"yes"; then
12420     for ac_func in _fmodf
12421 do
12422 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12423 echo "configure:12424: checking for $ac_func" >&5
12424 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12425   echo $ac_n "(cached) $ac_c" 1>&6
12426 else
12427   cat > conftest.$ac_ext <<EOF
12428 #line 12429 "configure"
12429 #include "confdefs.h"
12430 /* System header to define __stub macros and hopefully few prototypes,
12431     which can conflict with char $ac_func(); below.  */
12432 #include <assert.h>
12433 /* Override any gcc2 internal prototype to avoid an error.  */
12434 /* We use char because int might match the return type of a gcc2
12435     builtin and then its argument prototype would still apply.  */
12436 char $ac_func();
12437
12438 int main() {
12439
12440 /* The GNU C library defines this for functions which it implements
12441     to always fail with ENOSYS.  Some functions are actually named
12442     something starting with __ and the normal name is an alias.  */
12443 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12444 choke me
12445 #else
12446 $ac_func();
12447 #endif
12448
12449 ; return 0; }
12450 EOF
12451 if { (eval echo configure:12452: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12452   rm -rf conftest*
12453   eval "ac_cv_func_$ac_func=yes"
12454 else
12455   echo "configure: failed program was:" >&5
12456   cat conftest.$ac_ext >&5
12457   rm -rf conftest*
12458   eval "ac_cv_func_$ac_func=no"
12459 fi
12460 rm -f conftest*
12461 fi
12462
12463 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12464   echo "$ac_t""yes" 1>&6
12465     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12466   cat >> confdefs.h <<EOF
12467 #define $ac_tr_func 1
12468 EOF
12469
12470 else
12471   echo "$ac_t""no" 1>&6
12472 fi
12473 done
12474
12475   fi
12476
12477
12478
12479   ac_ext=C
12480 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12481 ac_cpp='$CXXCPP $CPPFLAGS'
12482 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12483 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12484 cross_compiling=$ac_cv_prog_cxx_cross
12485
12486   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12487 echo "configure:12488: checking for _frexpf declaration" >&5
12488   cat > conftest.$ac_ext <<EOF
12489 #line 12490 "configure"
12490 #include "confdefs.h"
12491 #include <math.h>
12492 int main() {
12493  _frexpf(0, 0);
12494 ; return 0; }
12495 EOF
12496 if { (eval echo configure:12497: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12497   rm -rf conftest*
12498   use__frexpf=yes
12499 else
12500   echo "configure: failed program was:" >&5
12501   cat conftest.$ac_ext >&5
12502   rm -rf conftest*
12503   use__frexpf=no
12504 fi
12505 rm -f conftest*
12506   echo "$ac_t""$use__frexpf" 1>&6
12507   ac_ext=c
12508 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12509 ac_cpp='$CPP $CPPFLAGS'
12510 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12511 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12512 cross_compiling=$ac_cv_prog_cc_cross
12513
12514   if test x$use__frexpf = x"yes"; then
12515     for ac_func in _frexpf
12516 do
12517 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12518 echo "configure:12519: checking for $ac_func" >&5
12519 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12520   echo $ac_n "(cached) $ac_c" 1>&6
12521 else
12522   cat > conftest.$ac_ext <<EOF
12523 #line 12524 "configure"
12524 #include "confdefs.h"
12525 /* System header to define __stub macros and hopefully few prototypes,
12526     which can conflict with char $ac_func(); below.  */
12527 #include <assert.h>
12528 /* Override any gcc2 internal prototype to avoid an error.  */
12529 /* We use char because int might match the return type of a gcc2
12530     builtin and then its argument prototype would still apply.  */
12531 char $ac_func();
12532
12533 int main() {
12534
12535 /* The GNU C library defines this for functions which it implements
12536     to always fail with ENOSYS.  Some functions are actually named
12537     something starting with __ and the normal name is an alias.  */
12538 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12539 choke me
12540 #else
12541 $ac_func();
12542 #endif
12543
12544 ; return 0; }
12545 EOF
12546 if { (eval echo configure:12547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12547   rm -rf conftest*
12548   eval "ac_cv_func_$ac_func=yes"
12549 else
12550   echo "configure: failed program was:" >&5
12551   cat conftest.$ac_ext >&5
12552   rm -rf conftest*
12553   eval "ac_cv_func_$ac_func=no"
12554 fi
12555 rm -f conftest*
12556 fi
12557
12558 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12559   echo "$ac_t""yes" 1>&6
12560     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12561   cat >> confdefs.h <<EOF
12562 #define $ac_tr_func 1
12563 EOF
12564
12565 else
12566   echo "$ac_t""no" 1>&6
12567 fi
12568 done
12569
12570   fi
12571
12572
12573
12574   ac_ext=C
12575 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12576 ac_cpp='$CXXCPP $CPPFLAGS'
12577 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12578 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12579 cross_compiling=$ac_cv_prog_cxx_cross
12580
12581   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
12582 echo "configure:12583: checking for _ldexpf declaration" >&5
12583   cat > conftest.$ac_ext <<EOF
12584 #line 12585 "configure"
12585 #include "confdefs.h"
12586 #include <math.h>
12587 int main() {
12588  _ldexpf(0, 0);
12589 ; return 0; }
12590 EOF
12591 if { (eval echo configure:12592: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12592   rm -rf conftest*
12593   use__ldexpf=yes
12594 else
12595   echo "configure: failed program was:" >&5
12596   cat conftest.$ac_ext >&5
12597   rm -rf conftest*
12598   use__ldexpf=no
12599 fi
12600 rm -f conftest*
12601   echo "$ac_t""$use__ldexpf" 1>&6
12602   ac_ext=c
12603 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12604 ac_cpp='$CPP $CPPFLAGS'
12605 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12606 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12607 cross_compiling=$ac_cv_prog_cc_cross
12608
12609   if test x$use__ldexpf = x"yes"; then
12610     for ac_func in _ldexpf
12611 do
12612 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12613 echo "configure:12614: checking for $ac_func" >&5
12614 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12615   echo $ac_n "(cached) $ac_c" 1>&6
12616 else
12617   cat > conftest.$ac_ext <<EOF
12618 #line 12619 "configure"
12619 #include "confdefs.h"
12620 /* System header to define __stub macros and hopefully few prototypes,
12621     which can conflict with char $ac_func(); below.  */
12622 #include <assert.h>
12623 /* Override any gcc2 internal prototype to avoid an error.  */
12624 /* We use char because int might match the return type of a gcc2
12625     builtin and then its argument prototype would still apply.  */
12626 char $ac_func();
12627
12628 int main() {
12629
12630 /* The GNU C library defines this for functions which it implements
12631     to always fail with ENOSYS.  Some functions are actually named
12632     something starting with __ and the normal name is an alias.  */
12633 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12634 choke me
12635 #else
12636 $ac_func();
12637 #endif
12638
12639 ; return 0; }
12640 EOF
12641 if { (eval echo configure:12642: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12642   rm -rf conftest*
12643   eval "ac_cv_func_$ac_func=yes"
12644 else
12645   echo "configure: failed program was:" >&5
12646   cat conftest.$ac_ext >&5
12647   rm -rf conftest*
12648   eval "ac_cv_func_$ac_func=no"
12649 fi
12650 rm -f conftest*
12651 fi
12652
12653 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12654   echo "$ac_t""yes" 1>&6
12655     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12656   cat >> confdefs.h <<EOF
12657 #define $ac_tr_func 1
12658 EOF
12659
12660 else
12661   echo "$ac_t""no" 1>&6
12662 fi
12663 done
12664
12665   fi
12666
12667
12668
12669   ac_ext=C
12670 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12671 ac_cpp='$CXXCPP $CPPFLAGS'
12672 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12673 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12674 cross_compiling=$ac_cv_prog_cxx_cross
12675
12676   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
12677 echo "configure:12678: checking for _logf declaration" >&5
12678   cat > conftest.$ac_ext <<EOF
12679 #line 12680 "configure"
12680 #include "confdefs.h"
12681 #include <math.h>
12682 int main() {
12683  _logf(0);
12684 ; return 0; }
12685 EOF
12686 if { (eval echo configure:12687: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12687   rm -rf conftest*
12688   use__logf=yes
12689 else
12690   echo "configure: failed program was:" >&5
12691   cat conftest.$ac_ext >&5
12692   rm -rf conftest*
12693   use__logf=no
12694 fi
12695 rm -f conftest*
12696   echo "$ac_t""$use__logf" 1>&6
12697   ac_ext=c
12698 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12699 ac_cpp='$CPP $CPPFLAGS'
12700 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12701 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12702 cross_compiling=$ac_cv_prog_cc_cross
12703
12704   if test x$use__logf = x"yes"; then
12705     for ac_func in _logf
12706 do
12707 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12708 echo "configure:12709: checking for $ac_func" >&5
12709 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12710   echo $ac_n "(cached) $ac_c" 1>&6
12711 else
12712   cat > conftest.$ac_ext <<EOF
12713 #line 12714 "configure"
12714 #include "confdefs.h"
12715 /* System header to define __stub macros and hopefully few prototypes,
12716     which can conflict with char $ac_func(); below.  */
12717 #include <assert.h>
12718 /* Override any gcc2 internal prototype to avoid an error.  */
12719 /* We use char because int might match the return type of a gcc2
12720     builtin and then its argument prototype would still apply.  */
12721 char $ac_func();
12722
12723 int main() {
12724
12725 /* The GNU C library defines this for functions which it implements
12726     to always fail with ENOSYS.  Some functions are actually named
12727     something starting with __ and the normal name is an alias.  */
12728 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12729 choke me
12730 #else
12731 $ac_func();
12732 #endif
12733
12734 ; return 0; }
12735 EOF
12736 if { (eval echo configure:12737: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12737   rm -rf conftest*
12738   eval "ac_cv_func_$ac_func=yes"
12739 else
12740   echo "configure: failed program was:" >&5
12741   cat conftest.$ac_ext >&5
12742   rm -rf conftest*
12743   eval "ac_cv_func_$ac_func=no"
12744 fi
12745 rm -f conftest*
12746 fi
12747
12748 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12749   echo "$ac_t""yes" 1>&6
12750     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12751   cat >> confdefs.h <<EOF
12752 #define $ac_tr_func 1
12753 EOF
12754
12755 else
12756   echo "$ac_t""no" 1>&6
12757 fi
12758 done
12759
12760   fi
12761
12762
12763
12764   ac_ext=C
12765 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12766 ac_cpp='$CXXCPP $CPPFLAGS'
12767 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12768 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12769 cross_compiling=$ac_cv_prog_cxx_cross
12770
12771   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
12772 echo "configure:12773: checking for _log10f declaration" >&5
12773   cat > conftest.$ac_ext <<EOF
12774 #line 12775 "configure"
12775 #include "confdefs.h"
12776 #include <math.h>
12777 int main() {
12778  _log10f(0);
12779 ; return 0; }
12780 EOF
12781 if { (eval echo configure:12782: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12782   rm -rf conftest*
12783   use__log10f=yes
12784 else
12785   echo "configure: failed program was:" >&5
12786   cat conftest.$ac_ext >&5
12787   rm -rf conftest*
12788   use__log10f=no
12789 fi
12790 rm -f conftest*
12791   echo "$ac_t""$use__log10f" 1>&6
12792   ac_ext=c
12793 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12794 ac_cpp='$CPP $CPPFLAGS'
12795 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12796 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12797 cross_compiling=$ac_cv_prog_cc_cross
12798
12799   if test x$use__log10f = x"yes"; then
12800     for ac_func in _log10f
12801 do
12802 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12803 echo "configure:12804: checking for $ac_func" >&5
12804 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12805   echo $ac_n "(cached) $ac_c" 1>&6
12806 else
12807   cat > conftest.$ac_ext <<EOF
12808 #line 12809 "configure"
12809 #include "confdefs.h"
12810 /* System header to define __stub macros and hopefully few prototypes,
12811     which can conflict with char $ac_func(); below.  */
12812 #include <assert.h>
12813 /* Override any gcc2 internal prototype to avoid an error.  */
12814 /* We use char because int might match the return type of a gcc2
12815     builtin and then its argument prototype would still apply.  */
12816 char $ac_func();
12817
12818 int main() {
12819
12820 /* The GNU C library defines this for functions which it implements
12821     to always fail with ENOSYS.  Some functions are actually named
12822     something starting with __ and the normal name is an alias.  */
12823 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12824 choke me
12825 #else
12826 $ac_func();
12827 #endif
12828
12829 ; return 0; }
12830 EOF
12831 if { (eval echo configure:12832: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12832   rm -rf conftest*
12833   eval "ac_cv_func_$ac_func=yes"
12834 else
12835   echo "configure: failed program was:" >&5
12836   cat conftest.$ac_ext >&5
12837   rm -rf conftest*
12838   eval "ac_cv_func_$ac_func=no"
12839 fi
12840 rm -f conftest*
12841 fi
12842
12843 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12844   echo "$ac_t""yes" 1>&6
12845     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12846   cat >> confdefs.h <<EOF
12847 #define $ac_tr_func 1
12848 EOF
12849
12850 else
12851   echo "$ac_t""no" 1>&6
12852 fi
12853 done
12854
12855   fi
12856
12857
12858
12859   ac_ext=C
12860 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12861 ac_cpp='$CXXCPP $CPPFLAGS'
12862 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12863 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12864 cross_compiling=$ac_cv_prog_cxx_cross
12865
12866   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
12867 echo "configure:12868: checking for _modff declaration" >&5
12868   cat > conftest.$ac_ext <<EOF
12869 #line 12870 "configure"
12870 #include "confdefs.h"
12871 #include <math.h>
12872 int main() {
12873  _modff(0, 0);
12874 ; return 0; }
12875 EOF
12876 if { (eval echo configure:12877: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12877   rm -rf conftest*
12878   use__modff=yes
12879 else
12880   echo "configure: failed program was:" >&5
12881   cat conftest.$ac_ext >&5
12882   rm -rf conftest*
12883   use__modff=no
12884 fi
12885 rm -f conftest*
12886   echo "$ac_t""$use__modff" 1>&6
12887   ac_ext=c
12888 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12889 ac_cpp='$CPP $CPPFLAGS'
12890 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12891 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12892 cross_compiling=$ac_cv_prog_cc_cross
12893
12894   if test x$use__modff = x"yes"; then
12895     for ac_func in _modff
12896 do
12897 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12898 echo "configure:12899: checking for $ac_func" >&5
12899 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12900   echo $ac_n "(cached) $ac_c" 1>&6
12901 else
12902   cat > conftest.$ac_ext <<EOF
12903 #line 12904 "configure"
12904 #include "confdefs.h"
12905 /* System header to define __stub macros and hopefully few prototypes,
12906     which can conflict with char $ac_func(); below.  */
12907 #include <assert.h>
12908 /* Override any gcc2 internal prototype to avoid an error.  */
12909 /* We use char because int might match the return type of a gcc2
12910     builtin and then its argument prototype would still apply.  */
12911 char $ac_func();
12912
12913 int main() {
12914
12915 /* The GNU C library defines this for functions which it implements
12916     to always fail with ENOSYS.  Some functions are actually named
12917     something starting with __ and the normal name is an alias.  */
12918 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12919 choke me
12920 #else
12921 $ac_func();
12922 #endif
12923
12924 ; return 0; }
12925 EOF
12926 if { (eval echo configure:12927: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12927   rm -rf conftest*
12928   eval "ac_cv_func_$ac_func=yes"
12929 else
12930   echo "configure: failed program was:" >&5
12931   cat conftest.$ac_ext >&5
12932   rm -rf conftest*
12933   eval "ac_cv_func_$ac_func=no"
12934 fi
12935 rm -f conftest*
12936 fi
12937
12938 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12939   echo "$ac_t""yes" 1>&6
12940     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12941   cat >> confdefs.h <<EOF
12942 #define $ac_tr_func 1
12943 EOF
12944
12945 else
12946   echo "$ac_t""no" 1>&6
12947 fi
12948 done
12949
12950   fi
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 _powf declaration""... $ac_c" 1>&6
12962 echo "configure:12963: checking for _powf declaration" >&5
12963   cat > conftest.$ac_ext <<EOF
12964 #line 12965 "configure"
12965 #include "confdefs.h"
12966 #include <math.h>
12967 int main() {
12968  _powf(0, 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__powf=yes
12974 else
12975   echo "configure: failed program was:" >&5
12976   cat conftest.$ac_ext >&5
12977   rm -rf conftest*
12978   use__powf=no
12979 fi
12980 rm -f conftest*
12981   echo "$ac_t""$use__powf" 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__powf = x"yes"; then
12990     for ac_func in _powf
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 _sinf declaration""... $ac_c" 1>&6
13057 echo "configure:13058: checking for _sinf declaration" >&5
13058   cat > conftest.$ac_ext <<EOF
13059 #line 13060 "configure"
13060 #include "confdefs.h"
13061 #include <math.h>
13062 int main() {
13063  _sinf(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__sinf=yes
13069 else
13070   echo "configure: failed program was:" >&5
13071   cat conftest.$ac_ext >&5
13072   rm -rf conftest*
13073   use__sinf=no
13074 fi
13075 rm -f conftest*
13076   echo "$ac_t""$use__sinf" 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__sinf = x"yes"; then
13085     for ac_func in _sinf
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 _sinhf declaration""... $ac_c" 1>&6
13152 echo "configure:13153: checking for _sinhf declaration" >&5
13153   cat > conftest.$ac_ext <<EOF
13154 #line 13155 "configure"
13155 #include "confdefs.h"
13156 #include <math.h>
13157 int main() {
13158  _sinhf(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__sinhf=yes
13164 else
13165   echo "configure: failed program was:" >&5
13166   cat conftest.$ac_ext >&5
13167   rm -rf conftest*
13168   use__sinhf=no
13169 fi
13170 rm -f conftest*
13171   echo "$ac_t""$use__sinhf" 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__sinhf = x"yes"; then
13180     for ac_func in _sinhf
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 _sqrtf declaration""... $ac_c" 1>&6
13247 echo "configure:13248: checking for _sqrtf declaration" >&5
13248   cat > conftest.$ac_ext <<EOF
13249 #line 13250 "configure"
13250 #include "confdefs.h"
13251 #include <math.h>
13252 int main() {
13253  _sqrtf(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__sqrtf=yes
13259 else
13260   echo "configure: failed program was:" >&5
13261   cat conftest.$ac_ext >&5
13262   rm -rf conftest*
13263   use__sqrtf=no
13264 fi
13265 rm -f conftest*
13266   echo "$ac_t""$use__sqrtf" 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__sqrtf = x"yes"; then
13275     for ac_func in _sqrtf
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 _tanf declaration""... $ac_c" 1>&6
13342 echo "configure:13343: checking for _tanf declaration" >&5
13343   cat > conftest.$ac_ext <<EOF
13344 #line 13345 "configure"
13345 #include "confdefs.h"
13346 #include <math.h>
13347 int main() {
13348  _tanf(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__tanf=yes
13354 else
13355   echo "configure: failed program was:" >&5
13356   cat conftest.$ac_ext >&5
13357   rm -rf conftest*
13358   use__tanf=no
13359 fi
13360 rm -f conftest*
13361   echo "$ac_t""$use__tanf" 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__tanf = x"yes"; then
13370     for ac_func in _tanf
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 _tanhf declaration""... $ac_c" 1>&6
13437 echo "configure:13438: checking for _tanhf declaration" >&5
13438   cat > conftest.$ac_ext <<EOF
13439 #line 13440 "configure"
13440 #include "confdefs.h"
13441 #include <math.h>
13442 int main() {
13443  _tanhf(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__tanhf=yes
13449 else
13450   echo "configure: failed program was:" >&5
13451   cat conftest.$ac_ext >&5
13452   rm -rf conftest*
13453   use__tanhf=no
13454 fi
13455 rm -f conftest*
13456   echo "$ac_t""$use__tanhf" 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__tanhf = x"yes"; then
13465     for ac_func in _tanhf
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 _sincosf declaration""... $ac_c" 1>&6
13532 echo "configure:13533: checking for _sincosf declaration" >&5
13533   cat > conftest.$ac_ext <<EOF
13534 #line 13535 "configure"
13535 #include "confdefs.h"
13536 #include <math.h>
13537 int main() {
13538  _sincosf(0, 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__sincosf=yes
13544 else
13545   echo "configure: failed program was:" >&5
13546   cat conftest.$ac_ext >&5
13547   rm -rf conftest*
13548   use__sincosf=no
13549 fi
13550 rm -f conftest*
13551   echo "$ac_t""$use__sincosf" 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__sincosf = x"yes"; then
13560     for ac_func in _sincosf
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 _finitef declaration""... $ac_c" 1>&6
13627 echo "configure:13628: checking for _finitef declaration" >&5
13628   cat > conftest.$ac_ext <<EOF
13629 #line 13630 "configure"
13630 #include "confdefs.h"
13631 #include <math.h>
13632 int main() {
13633  _finitef(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__finitef=yes
13639 else
13640   echo "configure: failed program was:" >&5
13641   cat conftest.$ac_ext >&5
13642   rm -rf conftest*
13643   use__finitef=no
13644 fi
13645 rm -f conftest*
13646   echo "$ac_t""$use__finitef" 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__finitef = x"yes"; then
13655     for ac_func in _finitef
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
13715   ac_ext=C
13716 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13717 ac_cpp='$CXXCPP $CPPFLAGS'
13718 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13719 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13720 cross_compiling=$ac_cv_prog_cxx_cross
13721
13722   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
13723 echo "configure:13724: checking for _isnanl declaration" >&5
13724   cat > conftest.$ac_ext <<EOF
13725 #line 13726 "configure"
13726 #include "confdefs.h"
13727 #include <math.h>
13728 int main() {
13729  _isnanl(0);
13730 ; return 0; }
13731 EOF
13732 if { (eval echo configure:13733: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13733   rm -rf conftest*
13734   use__isnanl=yes
13735 else
13736   echo "configure: failed program was:" >&5
13737   cat conftest.$ac_ext >&5
13738   rm -rf conftest*
13739   use__isnanl=no
13740 fi
13741 rm -f conftest*
13742   echo "$ac_t""$use__isnanl" 1>&6
13743   ac_ext=c
13744 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13745 ac_cpp='$CPP $CPPFLAGS'
13746 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13747 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13748 cross_compiling=$ac_cv_prog_cc_cross
13749
13750   if test x$use__isnanl = x"yes"; then
13751     for ac_func in _isnanl
13752 do
13753 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13754 echo "configure:13755: checking for $ac_func" >&5
13755 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13756   echo $ac_n "(cached) $ac_c" 1>&6
13757 else
13758   cat > conftest.$ac_ext <<EOF
13759 #line 13760 "configure"
13760 #include "confdefs.h"
13761 /* System header to define __stub macros and hopefully few prototypes,
13762     which can conflict with char $ac_func(); below.  */
13763 #include <assert.h>
13764 /* Override any gcc2 internal prototype to avoid an error.  */
13765 /* We use char because int might match the return type of a gcc2
13766     builtin and then its argument prototype would still apply.  */
13767 char $ac_func();
13768
13769 int main() {
13770
13771 /* The GNU C library defines this for functions which it implements
13772     to always fail with ENOSYS.  Some functions are actually named
13773     something starting with __ and the normal name is an alias.  */
13774 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13775 choke me
13776 #else
13777 $ac_func();
13778 #endif
13779
13780 ; return 0; }
13781 EOF
13782 if { (eval echo configure:13783: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13783   rm -rf conftest*
13784   eval "ac_cv_func_$ac_func=yes"
13785 else
13786   echo "configure: failed program was:" >&5
13787   cat conftest.$ac_ext >&5
13788   rm -rf conftest*
13789   eval "ac_cv_func_$ac_func=no"
13790 fi
13791 rm -f conftest*
13792 fi
13793
13794 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13795   echo "$ac_t""yes" 1>&6
13796     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13797   cat >> confdefs.h <<EOF
13798 #define $ac_tr_func 1
13799 EOF
13800
13801 else
13802   echo "$ac_t""no" 1>&6
13803 fi
13804 done
13805
13806   fi
13807
13808
13809
13810   ac_ext=C
13811 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13812 ac_cpp='$CXXCPP $CPPFLAGS'
13813 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13814 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13815 cross_compiling=$ac_cv_prog_cxx_cross
13816
13817   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
13818 echo "configure:13819: checking for _isinfl declaration" >&5
13819   cat > conftest.$ac_ext <<EOF
13820 #line 13821 "configure"
13821 #include "confdefs.h"
13822 #include <math.h>
13823 int main() {
13824  _isinfl(0);
13825 ; return 0; }
13826 EOF
13827 if { (eval echo configure:13828: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13828   rm -rf conftest*
13829   use__isinfl=yes
13830 else
13831   echo "configure: failed program was:" >&5
13832   cat conftest.$ac_ext >&5
13833   rm -rf conftest*
13834   use__isinfl=no
13835 fi
13836 rm -f conftest*
13837   echo "$ac_t""$use__isinfl" 1>&6
13838   ac_ext=c
13839 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13840 ac_cpp='$CPP $CPPFLAGS'
13841 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13842 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13843 cross_compiling=$ac_cv_prog_cc_cross
13844
13845   if test x$use__isinfl = x"yes"; then
13846     for ac_func in _isinfl
13847 do
13848 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13849 echo "configure:13850: checking for $ac_func" >&5
13850 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13851   echo $ac_n "(cached) $ac_c" 1>&6
13852 else
13853   cat > conftest.$ac_ext <<EOF
13854 #line 13855 "configure"
13855 #include "confdefs.h"
13856 /* System header to define __stub macros and hopefully few prototypes,
13857     which can conflict with char $ac_func(); below.  */
13858 #include <assert.h>
13859 /* Override any gcc2 internal prototype to avoid an error.  */
13860 /* We use char because int might match the return type of a gcc2
13861     builtin and then its argument prototype would still apply.  */
13862 char $ac_func();
13863
13864 int main() {
13865
13866 /* The GNU C library defines this for functions which it implements
13867     to always fail with ENOSYS.  Some functions are actually named
13868     something starting with __ and the normal name is an alias.  */
13869 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13870 choke me
13871 #else
13872 $ac_func();
13873 #endif
13874
13875 ; return 0; }
13876 EOF
13877 if { (eval echo configure:13878: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13878   rm -rf conftest*
13879   eval "ac_cv_func_$ac_func=yes"
13880 else
13881   echo "configure: failed program was:" >&5
13882   cat conftest.$ac_ext >&5
13883   rm -rf conftest*
13884   eval "ac_cv_func_$ac_func=no"
13885 fi
13886 rm -f conftest*
13887 fi
13888
13889 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13890   echo "$ac_t""yes" 1>&6
13891     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13892   cat >> confdefs.h <<EOF
13893 #define $ac_tr_func 1
13894 EOF
13895
13896 else
13897   echo "$ac_t""no" 1>&6
13898 fi
13899 done
13900
13901   fi
13902
13903
13904
13905   ac_ext=C
13906 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13907 ac_cpp='$CXXCPP $CPPFLAGS'
13908 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13909 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13910 cross_compiling=$ac_cv_prog_cxx_cross
13911
13912   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
13913 echo "configure:13914: checking for _copysignl declaration" >&5
13914   cat > conftest.$ac_ext <<EOF
13915 #line 13916 "configure"
13916 #include "confdefs.h"
13917 #include <math.h>
13918 int main() {
13919  _copysignl(0);
13920 ; return 0; }
13921 EOF
13922 if { (eval echo configure:13923: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13923   rm -rf conftest*
13924   use__copysignl=yes
13925 else
13926   echo "configure: failed program was:" >&5
13927   cat conftest.$ac_ext >&5
13928   rm -rf conftest*
13929   use__copysignl=no
13930 fi
13931 rm -f conftest*
13932   echo "$ac_t""$use__copysignl" 1>&6
13933   ac_ext=c
13934 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13935 ac_cpp='$CPP $CPPFLAGS'
13936 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13937 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13938 cross_compiling=$ac_cv_prog_cc_cross
13939
13940   if test x$use__copysignl = x"yes"; then
13941     for ac_func in _copysignl
13942 do
13943 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13944 echo "configure:13945: checking for $ac_func" >&5
13945 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13946   echo $ac_n "(cached) $ac_c" 1>&6
13947 else
13948   cat > conftest.$ac_ext <<EOF
13949 #line 13950 "configure"
13950 #include "confdefs.h"
13951 /* System header to define __stub macros and hopefully few prototypes,
13952     which can conflict with char $ac_func(); below.  */
13953 #include <assert.h>
13954 /* Override any gcc2 internal prototype to avoid an error.  */
13955 /* We use char because int might match the return type of a gcc2
13956     builtin and then its argument prototype would still apply.  */
13957 char $ac_func();
13958
13959 int main() {
13960
13961 /* The GNU C library defines this for functions which it implements
13962     to always fail with ENOSYS.  Some functions are actually named
13963     something starting with __ and the normal name is an alias.  */
13964 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13965 choke me
13966 #else
13967 $ac_func();
13968 #endif
13969
13970 ; return 0; }
13971 EOF
13972 if { (eval echo configure:13973: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13973   rm -rf conftest*
13974   eval "ac_cv_func_$ac_func=yes"
13975 else
13976   echo "configure: failed program was:" >&5
13977   cat conftest.$ac_ext >&5
13978   rm -rf conftest*
13979   eval "ac_cv_func_$ac_func=no"
13980 fi
13981 rm -f conftest*
13982 fi
13983
13984 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13985   echo "$ac_t""yes" 1>&6
13986     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13987   cat >> confdefs.h <<EOF
13988 #define $ac_tr_func 1
13989 EOF
13990
13991 else
13992   echo "$ac_t""no" 1>&6
13993 fi
13994 done
13995
13996   fi
13997
13998
13999
14000   ac_ext=C
14001 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14002 ac_cpp='$CXXCPP $CPPFLAGS'
14003 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14004 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14005 cross_compiling=$ac_cv_prog_cxx_cross
14006
14007   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14008 echo "configure:14009: checking for _acosl declaration" >&5
14009   cat > conftest.$ac_ext <<EOF
14010 #line 14011 "configure"
14011 #include "confdefs.h"
14012 #include <math.h>
14013 int main() {
14014  _acosl(0);
14015 ; return 0; }
14016 EOF
14017 if { (eval echo configure:14018: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14018   rm -rf conftest*
14019   use__acosl=yes
14020 else
14021   echo "configure: failed program was:" >&5
14022   cat conftest.$ac_ext >&5
14023   rm -rf conftest*
14024   use__acosl=no
14025 fi
14026 rm -f conftest*
14027   echo "$ac_t""$use__acosl" 1>&6
14028   ac_ext=c
14029 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14030 ac_cpp='$CPP $CPPFLAGS'
14031 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14032 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14033 cross_compiling=$ac_cv_prog_cc_cross
14034
14035   if test x$use__acosl = x"yes"; then
14036     for ac_func in _acosl
14037 do
14038 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14039 echo "configure:14040: checking for $ac_func" >&5
14040 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14041   echo $ac_n "(cached) $ac_c" 1>&6
14042 else
14043   cat > conftest.$ac_ext <<EOF
14044 #line 14045 "configure"
14045 #include "confdefs.h"
14046 /* System header to define __stub macros and hopefully few prototypes,
14047     which can conflict with char $ac_func(); below.  */
14048 #include <assert.h>
14049 /* Override any gcc2 internal prototype to avoid an error.  */
14050 /* We use char because int might match the return type of a gcc2
14051     builtin and then its argument prototype would still apply.  */
14052 char $ac_func();
14053
14054 int main() {
14055
14056 /* The GNU C library defines this for functions which it implements
14057     to always fail with ENOSYS.  Some functions are actually named
14058     something starting with __ and the normal name is an alias.  */
14059 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14060 choke me
14061 #else
14062 $ac_func();
14063 #endif
14064
14065 ; return 0; }
14066 EOF
14067 if { (eval echo configure:14068: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14068   rm -rf conftest*
14069   eval "ac_cv_func_$ac_func=yes"
14070 else
14071   echo "configure: failed program was:" >&5
14072   cat conftest.$ac_ext >&5
14073   rm -rf conftest*
14074   eval "ac_cv_func_$ac_func=no"
14075 fi
14076 rm -f conftest*
14077 fi
14078
14079 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14080   echo "$ac_t""yes" 1>&6
14081     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14082   cat >> confdefs.h <<EOF
14083 #define $ac_tr_func 1
14084 EOF
14085
14086 else
14087   echo "$ac_t""no" 1>&6
14088 fi
14089 done
14090
14091   fi
14092
14093
14094
14095   ac_ext=C
14096 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14097 ac_cpp='$CXXCPP $CPPFLAGS'
14098 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14099 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14100 cross_compiling=$ac_cv_prog_cxx_cross
14101
14102   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14103 echo "configure:14104: checking for _asinl declaration" >&5
14104   cat > conftest.$ac_ext <<EOF
14105 #line 14106 "configure"
14106 #include "confdefs.h"
14107 #include <math.h>
14108 int main() {
14109  _asinl(0);
14110 ; return 0; }
14111 EOF
14112 if { (eval echo configure:14113: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14113   rm -rf conftest*
14114   use__asinl=yes
14115 else
14116   echo "configure: failed program was:" >&5
14117   cat conftest.$ac_ext >&5
14118   rm -rf conftest*
14119   use__asinl=no
14120 fi
14121 rm -f conftest*
14122   echo "$ac_t""$use__asinl" 1>&6
14123   ac_ext=c
14124 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14125 ac_cpp='$CPP $CPPFLAGS'
14126 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14127 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14128 cross_compiling=$ac_cv_prog_cc_cross
14129
14130   if test x$use__asinl = x"yes"; then
14131     for ac_func in _asinl
14132 do
14133 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14134 echo "configure:14135: checking for $ac_func" >&5
14135 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14136   echo $ac_n "(cached) $ac_c" 1>&6
14137 else
14138   cat > conftest.$ac_ext <<EOF
14139 #line 14140 "configure"
14140 #include "confdefs.h"
14141 /* System header to define __stub macros and hopefully few prototypes,
14142     which can conflict with char $ac_func(); below.  */
14143 #include <assert.h>
14144 /* Override any gcc2 internal prototype to avoid an error.  */
14145 /* We use char because int might match the return type of a gcc2
14146     builtin and then its argument prototype would still apply.  */
14147 char $ac_func();
14148
14149 int main() {
14150
14151 /* The GNU C library defines this for functions which it implements
14152     to always fail with ENOSYS.  Some functions are actually named
14153     something starting with __ and the normal name is an alias.  */
14154 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14155 choke me
14156 #else
14157 $ac_func();
14158 #endif
14159
14160 ; return 0; }
14161 EOF
14162 if { (eval echo configure:14163: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14163   rm -rf conftest*
14164   eval "ac_cv_func_$ac_func=yes"
14165 else
14166   echo "configure: failed program was:" >&5
14167   cat conftest.$ac_ext >&5
14168   rm -rf conftest*
14169   eval "ac_cv_func_$ac_func=no"
14170 fi
14171 rm -f conftest*
14172 fi
14173
14174 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14175   echo "$ac_t""yes" 1>&6
14176     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14177   cat >> confdefs.h <<EOF
14178 #define $ac_tr_func 1
14179 EOF
14180
14181 else
14182   echo "$ac_t""no" 1>&6
14183 fi
14184 done
14185
14186   fi
14187
14188
14189
14190   ac_ext=C
14191 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14192 ac_cpp='$CXXCPP $CPPFLAGS'
14193 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14194 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14195 cross_compiling=$ac_cv_prog_cxx_cross
14196
14197   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14198 echo "configure:14199: checking for _atanl declaration" >&5
14199   cat > conftest.$ac_ext <<EOF
14200 #line 14201 "configure"
14201 #include "confdefs.h"
14202 #include <math.h>
14203 int main() {
14204  _atanl(0);
14205 ; return 0; }
14206 EOF
14207 if { (eval echo configure:14208: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14208   rm -rf conftest*
14209   use__atanl=yes
14210 else
14211   echo "configure: failed program was:" >&5
14212   cat conftest.$ac_ext >&5
14213   rm -rf conftest*
14214   use__atanl=no
14215 fi
14216 rm -f conftest*
14217   echo "$ac_t""$use__atanl" 1>&6
14218   ac_ext=c
14219 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14220 ac_cpp='$CPP $CPPFLAGS'
14221 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14222 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14223 cross_compiling=$ac_cv_prog_cc_cross
14224
14225   if test x$use__atanl = x"yes"; then
14226     for ac_func in _atanl
14227 do
14228 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14229 echo "configure:14230: checking for $ac_func" >&5
14230 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14231   echo $ac_n "(cached) $ac_c" 1>&6
14232 else
14233   cat > conftest.$ac_ext <<EOF
14234 #line 14235 "configure"
14235 #include "confdefs.h"
14236 /* System header to define __stub macros and hopefully few prototypes,
14237     which can conflict with char $ac_func(); below.  */
14238 #include <assert.h>
14239 /* Override any gcc2 internal prototype to avoid an error.  */
14240 /* We use char because int might match the return type of a gcc2
14241     builtin and then its argument prototype would still apply.  */
14242 char $ac_func();
14243
14244 int main() {
14245
14246 /* The GNU C library defines this for functions which it implements
14247     to always fail with ENOSYS.  Some functions are actually named
14248     something starting with __ and the normal name is an alias.  */
14249 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14250 choke me
14251 #else
14252 $ac_func();
14253 #endif
14254
14255 ; return 0; }
14256 EOF
14257 if { (eval echo configure:14258: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14258   rm -rf conftest*
14259   eval "ac_cv_func_$ac_func=yes"
14260 else
14261   echo "configure: failed program was:" >&5
14262   cat conftest.$ac_ext >&5
14263   rm -rf conftest*
14264   eval "ac_cv_func_$ac_func=no"
14265 fi
14266 rm -f conftest*
14267 fi
14268
14269 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14270   echo "$ac_t""yes" 1>&6
14271     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14272   cat >> confdefs.h <<EOF
14273 #define $ac_tr_func 1
14274 EOF
14275
14276 else
14277   echo "$ac_t""no" 1>&6
14278 fi
14279 done
14280
14281   fi
14282
14283
14284
14285   ac_ext=C
14286 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14287 ac_cpp='$CXXCPP $CPPFLAGS'
14288 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14289 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14290 cross_compiling=$ac_cv_prog_cxx_cross
14291
14292   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14293 echo "configure:14294: checking for _atan2l declaration" >&5
14294   cat > conftest.$ac_ext <<EOF
14295 #line 14296 "configure"
14296 #include "confdefs.h"
14297 #include <math.h>
14298 int main() {
14299  _atan2l(0, 0);
14300 ; return 0; }
14301 EOF
14302 if { (eval echo configure:14303: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14303   rm -rf conftest*
14304   use__atan2l=yes
14305 else
14306   echo "configure: failed program was:" >&5
14307   cat conftest.$ac_ext >&5
14308   rm -rf conftest*
14309   use__atan2l=no
14310 fi
14311 rm -f conftest*
14312   echo "$ac_t""$use__atan2l" 1>&6
14313   ac_ext=c
14314 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14315 ac_cpp='$CPP $CPPFLAGS'
14316 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14317 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14318 cross_compiling=$ac_cv_prog_cc_cross
14319
14320   if test x$use__atan2l = x"yes"; then
14321     for ac_func in _atan2l
14322 do
14323 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14324 echo "configure:14325: checking for $ac_func" >&5
14325 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14326   echo $ac_n "(cached) $ac_c" 1>&6
14327 else
14328   cat > conftest.$ac_ext <<EOF
14329 #line 14330 "configure"
14330 #include "confdefs.h"
14331 /* System header to define __stub macros and hopefully few prototypes,
14332     which can conflict with char $ac_func(); below.  */
14333 #include <assert.h>
14334 /* Override any gcc2 internal prototype to avoid an error.  */
14335 /* We use char because int might match the return type of a gcc2
14336     builtin and then its argument prototype would still apply.  */
14337 char $ac_func();
14338
14339 int main() {
14340
14341 /* The GNU C library defines this for functions which it implements
14342     to always fail with ENOSYS.  Some functions are actually named
14343     something starting with __ and the normal name is an alias.  */
14344 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14345 choke me
14346 #else
14347 $ac_func();
14348 #endif
14349
14350 ; return 0; }
14351 EOF
14352 if { (eval echo configure:14353: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14353   rm -rf conftest*
14354   eval "ac_cv_func_$ac_func=yes"
14355 else
14356   echo "configure: failed program was:" >&5
14357   cat conftest.$ac_ext >&5
14358   rm -rf conftest*
14359   eval "ac_cv_func_$ac_func=no"
14360 fi
14361 rm -f conftest*
14362 fi
14363
14364 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14365   echo "$ac_t""yes" 1>&6
14366     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14367   cat >> confdefs.h <<EOF
14368 #define $ac_tr_func 1
14369 EOF
14370
14371 else
14372   echo "$ac_t""no" 1>&6
14373 fi
14374 done
14375
14376   fi
14377
14378
14379
14380   ac_ext=C
14381 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14382 ac_cpp='$CXXCPP $CPPFLAGS'
14383 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14384 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14385 cross_compiling=$ac_cv_prog_cxx_cross
14386
14387   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
14388 echo "configure:14389: checking for _ceill declaration" >&5
14389   cat > conftest.$ac_ext <<EOF
14390 #line 14391 "configure"
14391 #include "confdefs.h"
14392 #include <math.h>
14393 int main() {
14394  _ceill(0);
14395 ; return 0; }
14396 EOF
14397 if { (eval echo configure:14398: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14398   rm -rf conftest*
14399   use__ceill=yes
14400 else
14401   echo "configure: failed program was:" >&5
14402   cat conftest.$ac_ext >&5
14403   rm -rf conftest*
14404   use__ceill=no
14405 fi
14406 rm -f conftest*
14407   echo "$ac_t""$use__ceill" 1>&6
14408   ac_ext=c
14409 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14410 ac_cpp='$CPP $CPPFLAGS'
14411 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14412 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14413 cross_compiling=$ac_cv_prog_cc_cross
14414
14415   if test x$use__ceill = x"yes"; then
14416     for ac_func in _ceill
14417 do
14418 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14419 echo "configure:14420: checking for $ac_func" >&5
14420 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14421   echo $ac_n "(cached) $ac_c" 1>&6
14422 else
14423   cat > conftest.$ac_ext <<EOF
14424 #line 14425 "configure"
14425 #include "confdefs.h"
14426 /* System header to define __stub macros and hopefully few prototypes,
14427     which can conflict with char $ac_func(); below.  */
14428 #include <assert.h>
14429 /* Override any gcc2 internal prototype to avoid an error.  */
14430 /* We use char because int might match the return type of a gcc2
14431     builtin and then its argument prototype would still apply.  */
14432 char $ac_func();
14433
14434 int main() {
14435
14436 /* The GNU C library defines this for functions which it implements
14437     to always fail with ENOSYS.  Some functions are actually named
14438     something starting with __ and the normal name is an alias.  */
14439 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14440 choke me
14441 #else
14442 $ac_func();
14443 #endif
14444
14445 ; return 0; }
14446 EOF
14447 if { (eval echo configure:14448: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14448   rm -rf conftest*
14449   eval "ac_cv_func_$ac_func=yes"
14450 else
14451   echo "configure: failed program was:" >&5
14452   cat conftest.$ac_ext >&5
14453   rm -rf conftest*
14454   eval "ac_cv_func_$ac_func=no"
14455 fi
14456 rm -f conftest*
14457 fi
14458
14459 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14460   echo "$ac_t""yes" 1>&6
14461     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14462   cat >> confdefs.h <<EOF
14463 #define $ac_tr_func 1
14464 EOF
14465
14466 else
14467   echo "$ac_t""no" 1>&6
14468 fi
14469 done
14470
14471   fi
14472
14473
14474
14475   ac_ext=C
14476 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14477 ac_cpp='$CXXCPP $CPPFLAGS'
14478 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14479 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14480 cross_compiling=$ac_cv_prog_cxx_cross
14481
14482   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
14483 echo "configure:14484: checking for _cosl declaration" >&5
14484   cat > conftest.$ac_ext <<EOF
14485 #line 14486 "configure"
14486 #include "confdefs.h"
14487 #include <math.h>
14488 int main() {
14489  _cosl(0);
14490 ; return 0; }
14491 EOF
14492 if { (eval echo configure:14493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14493   rm -rf conftest*
14494   use__cosl=yes
14495 else
14496   echo "configure: failed program was:" >&5
14497   cat conftest.$ac_ext >&5
14498   rm -rf conftest*
14499   use__cosl=no
14500 fi
14501 rm -f conftest*
14502   echo "$ac_t""$use__cosl" 1>&6
14503   ac_ext=c
14504 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14505 ac_cpp='$CPP $CPPFLAGS'
14506 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14507 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14508 cross_compiling=$ac_cv_prog_cc_cross
14509
14510   if test x$use__cosl = x"yes"; then
14511     for ac_func in _cosl
14512 do
14513 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14514 echo "configure:14515: checking for $ac_func" >&5
14515 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14516   echo $ac_n "(cached) $ac_c" 1>&6
14517 else
14518   cat > conftest.$ac_ext <<EOF
14519 #line 14520 "configure"
14520 #include "confdefs.h"
14521 /* System header to define __stub macros and hopefully few prototypes,
14522     which can conflict with char $ac_func(); below.  */
14523 #include <assert.h>
14524 /* Override any gcc2 internal prototype to avoid an error.  */
14525 /* We use char because int might match the return type of a gcc2
14526     builtin and then its argument prototype would still apply.  */
14527 char $ac_func();
14528
14529 int main() {
14530
14531 /* The GNU C library defines this for functions which it implements
14532     to always fail with ENOSYS.  Some functions are actually named
14533     something starting with __ and the normal name is an alias.  */
14534 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14535 choke me
14536 #else
14537 $ac_func();
14538 #endif
14539
14540 ; return 0; }
14541 EOF
14542 if { (eval echo configure:14543: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14543   rm -rf conftest*
14544   eval "ac_cv_func_$ac_func=yes"
14545 else
14546   echo "configure: failed program was:" >&5
14547   cat conftest.$ac_ext >&5
14548   rm -rf conftest*
14549   eval "ac_cv_func_$ac_func=no"
14550 fi
14551 rm -f conftest*
14552 fi
14553
14554 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14555   echo "$ac_t""yes" 1>&6
14556     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14557   cat >> confdefs.h <<EOF
14558 #define $ac_tr_func 1
14559 EOF
14560
14561 else
14562   echo "$ac_t""no" 1>&6
14563 fi
14564 done
14565
14566   fi
14567
14568
14569
14570   ac_ext=C
14571 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14572 ac_cpp='$CXXCPP $CPPFLAGS'
14573 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14574 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14575 cross_compiling=$ac_cv_prog_cxx_cross
14576
14577   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
14578 echo "configure:14579: checking for _coshl declaration" >&5
14579   cat > conftest.$ac_ext <<EOF
14580 #line 14581 "configure"
14581 #include "confdefs.h"
14582 #include <math.h>
14583 int main() {
14584  _coshl(0);
14585 ; return 0; }
14586 EOF
14587 if { (eval echo configure:14588: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14588   rm -rf conftest*
14589   use__coshl=yes
14590 else
14591   echo "configure: failed program was:" >&5
14592   cat conftest.$ac_ext >&5
14593   rm -rf conftest*
14594   use__coshl=no
14595 fi
14596 rm -f conftest*
14597   echo "$ac_t""$use__coshl" 1>&6
14598   ac_ext=c
14599 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14600 ac_cpp='$CPP $CPPFLAGS'
14601 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14602 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14603 cross_compiling=$ac_cv_prog_cc_cross
14604
14605   if test x$use__coshl = x"yes"; then
14606     for ac_func in _coshl
14607 do
14608 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14609 echo "configure:14610: checking for $ac_func" >&5
14610 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14611   echo $ac_n "(cached) $ac_c" 1>&6
14612 else
14613   cat > conftest.$ac_ext <<EOF
14614 #line 14615 "configure"
14615 #include "confdefs.h"
14616 /* System header to define __stub macros and hopefully few prototypes,
14617     which can conflict with char $ac_func(); below.  */
14618 #include <assert.h>
14619 /* Override any gcc2 internal prototype to avoid an error.  */
14620 /* We use char because int might match the return type of a gcc2
14621     builtin and then its argument prototype would still apply.  */
14622 char $ac_func();
14623
14624 int main() {
14625
14626 /* The GNU C library defines this for functions which it implements
14627     to always fail with ENOSYS.  Some functions are actually named
14628     something starting with __ and the normal name is an alias.  */
14629 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14630 choke me
14631 #else
14632 $ac_func();
14633 #endif
14634
14635 ; return 0; }
14636 EOF
14637 if { (eval echo configure:14638: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14638   rm -rf conftest*
14639   eval "ac_cv_func_$ac_func=yes"
14640 else
14641   echo "configure: failed program was:" >&5
14642   cat conftest.$ac_ext >&5
14643   rm -rf conftest*
14644   eval "ac_cv_func_$ac_func=no"
14645 fi
14646 rm -f conftest*
14647 fi
14648
14649 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14650   echo "$ac_t""yes" 1>&6
14651     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14652   cat >> confdefs.h <<EOF
14653 #define $ac_tr_func 1
14654 EOF
14655
14656 else
14657   echo "$ac_t""no" 1>&6
14658 fi
14659 done
14660
14661   fi
14662
14663
14664
14665   ac_ext=C
14666 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14667 ac_cpp='$CXXCPP $CPPFLAGS'
14668 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14669 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14670 cross_compiling=$ac_cv_prog_cxx_cross
14671
14672   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
14673 echo "configure:14674: checking for _expl declaration" >&5
14674   cat > conftest.$ac_ext <<EOF
14675 #line 14676 "configure"
14676 #include "confdefs.h"
14677 #include <math.h>
14678 int main() {
14679  _expl(0);
14680 ; return 0; }
14681 EOF
14682 if { (eval echo configure:14683: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14683   rm -rf conftest*
14684   use__expl=yes
14685 else
14686   echo "configure: failed program was:" >&5
14687   cat conftest.$ac_ext >&5
14688   rm -rf conftest*
14689   use__expl=no
14690 fi
14691 rm -f conftest*
14692   echo "$ac_t""$use__expl" 1>&6
14693   ac_ext=c
14694 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14695 ac_cpp='$CPP $CPPFLAGS'
14696 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14697 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14698 cross_compiling=$ac_cv_prog_cc_cross
14699
14700   if test x$use__expl = x"yes"; then
14701     for ac_func in _expl
14702 do
14703 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14704 echo "configure:14705: checking for $ac_func" >&5
14705 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14706   echo $ac_n "(cached) $ac_c" 1>&6
14707 else
14708   cat > conftest.$ac_ext <<EOF
14709 #line 14710 "configure"
14710 #include "confdefs.h"
14711 /* System header to define __stub macros and hopefully few prototypes,
14712     which can conflict with char $ac_func(); below.  */
14713 #include <assert.h>
14714 /* Override any gcc2 internal prototype to avoid an error.  */
14715 /* We use char because int might match the return type of a gcc2
14716     builtin and then its argument prototype would still apply.  */
14717 char $ac_func();
14718
14719 int main() {
14720
14721 /* The GNU C library defines this for functions which it implements
14722     to always fail with ENOSYS.  Some functions are actually named
14723     something starting with __ and the normal name is an alias.  */
14724 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14725 choke me
14726 #else
14727 $ac_func();
14728 #endif
14729
14730 ; return 0; }
14731 EOF
14732 if { (eval echo configure:14733: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14733   rm -rf conftest*
14734   eval "ac_cv_func_$ac_func=yes"
14735 else
14736   echo "configure: failed program was:" >&5
14737   cat conftest.$ac_ext >&5
14738   rm -rf conftest*
14739   eval "ac_cv_func_$ac_func=no"
14740 fi
14741 rm -f conftest*
14742 fi
14743
14744 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14745   echo "$ac_t""yes" 1>&6
14746     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14747   cat >> confdefs.h <<EOF
14748 #define $ac_tr_func 1
14749 EOF
14750
14751 else
14752   echo "$ac_t""no" 1>&6
14753 fi
14754 done
14755
14756   fi
14757
14758
14759
14760   ac_ext=C
14761 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14762 ac_cpp='$CXXCPP $CPPFLAGS'
14763 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14764 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14765 cross_compiling=$ac_cv_prog_cxx_cross
14766
14767   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
14768 echo "configure:14769: checking for _fabsl declaration" >&5
14769   cat > conftest.$ac_ext <<EOF
14770 #line 14771 "configure"
14771 #include "confdefs.h"
14772 #include <math.h>
14773 int main() {
14774  _fabsl(0);
14775 ; return 0; }
14776 EOF
14777 if { (eval echo configure:14778: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14778   rm -rf conftest*
14779   use__fabsl=yes
14780 else
14781   echo "configure: failed program was:" >&5
14782   cat conftest.$ac_ext >&5
14783   rm -rf conftest*
14784   use__fabsl=no
14785 fi
14786 rm -f conftest*
14787   echo "$ac_t""$use__fabsl" 1>&6
14788   ac_ext=c
14789 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14790 ac_cpp='$CPP $CPPFLAGS'
14791 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14792 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14793 cross_compiling=$ac_cv_prog_cc_cross
14794
14795   if test x$use__fabsl = x"yes"; then
14796     for ac_func in _fabsl
14797 do
14798 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14799 echo "configure:14800: checking for $ac_func" >&5
14800 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14801   echo $ac_n "(cached) $ac_c" 1>&6
14802 else
14803   cat > conftest.$ac_ext <<EOF
14804 #line 14805 "configure"
14805 #include "confdefs.h"
14806 /* System header to define __stub macros and hopefully few prototypes,
14807     which can conflict with char $ac_func(); below.  */
14808 #include <assert.h>
14809 /* Override any gcc2 internal prototype to avoid an error.  */
14810 /* We use char because int might match the return type of a gcc2
14811     builtin and then its argument prototype would still apply.  */
14812 char $ac_func();
14813
14814 int main() {
14815
14816 /* The GNU C library defines this for functions which it implements
14817     to always fail with ENOSYS.  Some functions are actually named
14818     something starting with __ and the normal name is an alias.  */
14819 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14820 choke me
14821 #else
14822 $ac_func();
14823 #endif
14824
14825 ; return 0; }
14826 EOF
14827 if { (eval echo configure:14828: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14828   rm -rf conftest*
14829   eval "ac_cv_func_$ac_func=yes"
14830 else
14831   echo "configure: failed program was:" >&5
14832   cat conftest.$ac_ext >&5
14833   rm -rf conftest*
14834   eval "ac_cv_func_$ac_func=no"
14835 fi
14836 rm -f conftest*
14837 fi
14838
14839 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14840   echo "$ac_t""yes" 1>&6
14841     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14842   cat >> confdefs.h <<EOF
14843 #define $ac_tr_func 1
14844 EOF
14845
14846 else
14847   echo "$ac_t""no" 1>&6
14848 fi
14849 done
14850
14851   fi
14852
14853
14854
14855   ac_ext=C
14856 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14857 ac_cpp='$CXXCPP $CPPFLAGS'
14858 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14859 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14860 cross_compiling=$ac_cv_prog_cxx_cross
14861
14862   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
14863 echo "configure:14864: checking for _floorl declaration" >&5
14864   cat > conftest.$ac_ext <<EOF
14865 #line 14866 "configure"
14866 #include "confdefs.h"
14867 #include <math.h>
14868 int main() {
14869  _floorl(0);
14870 ; return 0; }
14871 EOF
14872 if { (eval echo configure:14873: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14873   rm -rf conftest*
14874   use__floorl=yes
14875 else
14876   echo "configure: failed program was:" >&5
14877   cat conftest.$ac_ext >&5
14878   rm -rf conftest*
14879   use__floorl=no
14880 fi
14881 rm -f conftest*
14882   echo "$ac_t""$use__floorl" 1>&6
14883   ac_ext=c
14884 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14885 ac_cpp='$CPP $CPPFLAGS'
14886 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14887 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14888 cross_compiling=$ac_cv_prog_cc_cross
14889
14890   if test x$use__floorl = x"yes"; then
14891     for ac_func in _floorl
14892 do
14893 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14894 echo "configure:14895: checking for $ac_func" >&5
14895 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14896   echo $ac_n "(cached) $ac_c" 1>&6
14897 else
14898   cat > conftest.$ac_ext <<EOF
14899 #line 14900 "configure"
14900 #include "confdefs.h"
14901 /* System header to define __stub macros and hopefully few prototypes,
14902     which can conflict with char $ac_func(); below.  */
14903 #include <assert.h>
14904 /* Override any gcc2 internal prototype to avoid an error.  */
14905 /* We use char because int might match the return type of a gcc2
14906     builtin and then its argument prototype would still apply.  */
14907 char $ac_func();
14908
14909 int main() {
14910
14911 /* The GNU C library defines this for functions which it implements
14912     to always fail with ENOSYS.  Some functions are actually named
14913     something starting with __ and the normal name is an alias.  */
14914 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14915 choke me
14916 #else
14917 $ac_func();
14918 #endif
14919
14920 ; return 0; }
14921 EOF
14922 if { (eval echo configure:14923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14923   rm -rf conftest*
14924   eval "ac_cv_func_$ac_func=yes"
14925 else
14926   echo "configure: failed program was:" >&5
14927   cat conftest.$ac_ext >&5
14928   rm -rf conftest*
14929   eval "ac_cv_func_$ac_func=no"
14930 fi
14931 rm -f conftest*
14932 fi
14933
14934 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14935   echo "$ac_t""yes" 1>&6
14936     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14937   cat >> confdefs.h <<EOF
14938 #define $ac_tr_func 1
14939 EOF
14940
14941 else
14942   echo "$ac_t""no" 1>&6
14943 fi
14944 done
14945
14946   fi
14947
14948
14949
14950   ac_ext=C
14951 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14952 ac_cpp='$CXXCPP $CPPFLAGS'
14953 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14954 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14955 cross_compiling=$ac_cv_prog_cxx_cross
14956
14957   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
14958 echo "configure:14959: checking for _fmodl declaration" >&5
14959   cat > conftest.$ac_ext <<EOF
14960 #line 14961 "configure"
14961 #include "confdefs.h"
14962 #include <math.h>
14963 int main() {
14964  _fmodl(0, 0);
14965 ; return 0; }
14966 EOF
14967 if { (eval echo configure:14968: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14968   rm -rf conftest*
14969   use__fmodl=yes
14970 else
14971   echo "configure: failed program was:" >&5
14972   cat conftest.$ac_ext >&5
14973   rm -rf conftest*
14974   use__fmodl=no
14975 fi
14976 rm -f conftest*
14977   echo "$ac_t""$use__fmodl" 1>&6
14978   ac_ext=c
14979 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14980 ac_cpp='$CPP $CPPFLAGS'
14981 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14982 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14983 cross_compiling=$ac_cv_prog_cc_cross
14984
14985   if test x$use__fmodl = x"yes"; then
14986     for ac_func in _fmodl
14987 do
14988 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14989 echo "configure:14990: checking for $ac_func" >&5
14990 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14991   echo $ac_n "(cached) $ac_c" 1>&6
14992 else
14993   cat > conftest.$ac_ext <<EOF
14994 #line 14995 "configure"
14995 #include "confdefs.h"
14996 /* System header to define __stub macros and hopefully few prototypes,
14997     which can conflict with char $ac_func(); below.  */
14998 #include <assert.h>
14999 /* Override any gcc2 internal prototype to avoid an error.  */
15000 /* We use char because int might match the return type of a gcc2
15001     builtin and then its argument prototype would still apply.  */
15002 char $ac_func();
15003
15004 int main() {
15005
15006 /* The GNU C library defines this for functions which it implements
15007     to always fail with ENOSYS.  Some functions are actually named
15008     something starting with __ and the normal name is an alias.  */
15009 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15010 choke me
15011 #else
15012 $ac_func();
15013 #endif
15014
15015 ; return 0; }
15016 EOF
15017 if { (eval echo configure:15018: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15018   rm -rf conftest*
15019   eval "ac_cv_func_$ac_func=yes"
15020 else
15021   echo "configure: failed program was:" >&5
15022   cat conftest.$ac_ext >&5
15023   rm -rf conftest*
15024   eval "ac_cv_func_$ac_func=no"
15025 fi
15026 rm -f conftest*
15027 fi
15028
15029 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15030   echo "$ac_t""yes" 1>&6
15031     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15032   cat >> confdefs.h <<EOF
15033 #define $ac_tr_func 1
15034 EOF
15035
15036 else
15037   echo "$ac_t""no" 1>&6
15038 fi
15039 done
15040
15041   fi
15042
15043
15044
15045   ac_ext=C
15046 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15047 ac_cpp='$CXXCPP $CPPFLAGS'
15048 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15049 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15050 cross_compiling=$ac_cv_prog_cxx_cross
15051
15052   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15053 echo "configure:15054: checking for _frexpl declaration" >&5
15054   cat > conftest.$ac_ext <<EOF
15055 #line 15056 "configure"
15056 #include "confdefs.h"
15057 #include <math.h>
15058 int main() {
15059  _frexpl(0, 0);
15060 ; return 0; }
15061 EOF
15062 if { (eval echo configure:15063: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15063   rm -rf conftest*
15064   use__frexpl=yes
15065 else
15066   echo "configure: failed program was:" >&5
15067   cat conftest.$ac_ext >&5
15068   rm -rf conftest*
15069   use__frexpl=no
15070 fi
15071 rm -f conftest*
15072   echo "$ac_t""$use__frexpl" 1>&6
15073   ac_ext=c
15074 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15075 ac_cpp='$CPP $CPPFLAGS'
15076 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15077 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15078 cross_compiling=$ac_cv_prog_cc_cross
15079
15080   if test x$use__frexpl = x"yes"; then
15081     for ac_func in _frexpl
15082 do
15083 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15084 echo "configure:15085: checking for $ac_func" >&5
15085 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15086   echo $ac_n "(cached) $ac_c" 1>&6
15087 else
15088   cat > conftest.$ac_ext <<EOF
15089 #line 15090 "configure"
15090 #include "confdefs.h"
15091 /* System header to define __stub macros and hopefully few prototypes,
15092     which can conflict with char $ac_func(); below.  */
15093 #include <assert.h>
15094 /* Override any gcc2 internal prototype to avoid an error.  */
15095 /* We use char because int might match the return type of a gcc2
15096     builtin and then its argument prototype would still apply.  */
15097 char $ac_func();
15098
15099 int main() {
15100
15101 /* The GNU C library defines this for functions which it implements
15102     to always fail with ENOSYS.  Some functions are actually named
15103     something starting with __ and the normal name is an alias.  */
15104 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15105 choke me
15106 #else
15107 $ac_func();
15108 #endif
15109
15110 ; return 0; }
15111 EOF
15112 if { (eval echo configure:15113: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15113   rm -rf conftest*
15114   eval "ac_cv_func_$ac_func=yes"
15115 else
15116   echo "configure: failed program was:" >&5
15117   cat conftest.$ac_ext >&5
15118   rm -rf conftest*
15119   eval "ac_cv_func_$ac_func=no"
15120 fi
15121 rm -f conftest*
15122 fi
15123
15124 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15125   echo "$ac_t""yes" 1>&6
15126     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15127   cat >> confdefs.h <<EOF
15128 #define $ac_tr_func 1
15129 EOF
15130
15131 else
15132   echo "$ac_t""no" 1>&6
15133 fi
15134 done
15135
15136   fi
15137
15138
15139
15140   ac_ext=C
15141 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15142 ac_cpp='$CXXCPP $CPPFLAGS'
15143 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15144 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15145 cross_compiling=$ac_cv_prog_cxx_cross
15146
15147   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15148 echo "configure:15149: checking for _ldexpl declaration" >&5
15149   cat > conftest.$ac_ext <<EOF
15150 #line 15151 "configure"
15151 #include "confdefs.h"
15152 #include <math.h>
15153 int main() {
15154  _ldexpl(0, 0);
15155 ; return 0; }
15156 EOF
15157 if { (eval echo configure:15158: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15158   rm -rf conftest*
15159   use__ldexpl=yes
15160 else
15161   echo "configure: failed program was:" >&5
15162   cat conftest.$ac_ext >&5
15163   rm -rf conftest*
15164   use__ldexpl=no
15165 fi
15166 rm -f conftest*
15167   echo "$ac_t""$use__ldexpl" 1>&6
15168   ac_ext=c
15169 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15170 ac_cpp='$CPP $CPPFLAGS'
15171 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15172 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15173 cross_compiling=$ac_cv_prog_cc_cross
15174
15175   if test x$use__ldexpl = x"yes"; then
15176     for ac_func in _ldexpl
15177 do
15178 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15179 echo "configure:15180: checking for $ac_func" >&5
15180 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15181   echo $ac_n "(cached) $ac_c" 1>&6
15182 else
15183   cat > conftest.$ac_ext <<EOF
15184 #line 15185 "configure"
15185 #include "confdefs.h"
15186 /* System header to define __stub macros and hopefully few prototypes,
15187     which can conflict with char $ac_func(); below.  */
15188 #include <assert.h>
15189 /* Override any gcc2 internal prototype to avoid an error.  */
15190 /* We use char because int might match the return type of a gcc2
15191     builtin and then its argument prototype would still apply.  */
15192 char $ac_func();
15193
15194 int main() {
15195
15196 /* The GNU C library defines this for functions which it implements
15197     to always fail with ENOSYS.  Some functions are actually named
15198     something starting with __ and the normal name is an alias.  */
15199 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15200 choke me
15201 #else
15202 $ac_func();
15203 #endif
15204
15205 ; return 0; }
15206 EOF
15207 if { (eval echo configure:15208: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15208   rm -rf conftest*
15209   eval "ac_cv_func_$ac_func=yes"
15210 else
15211   echo "configure: failed program was:" >&5
15212   cat conftest.$ac_ext >&5
15213   rm -rf conftest*
15214   eval "ac_cv_func_$ac_func=no"
15215 fi
15216 rm -f conftest*
15217 fi
15218
15219 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15220   echo "$ac_t""yes" 1>&6
15221     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15222   cat >> confdefs.h <<EOF
15223 #define $ac_tr_func 1
15224 EOF
15225
15226 else
15227   echo "$ac_t""no" 1>&6
15228 fi
15229 done
15230
15231   fi
15232
15233
15234
15235   ac_ext=C
15236 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15237 ac_cpp='$CXXCPP $CPPFLAGS'
15238 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15239 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15240 cross_compiling=$ac_cv_prog_cxx_cross
15241
15242   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15243 echo "configure:15244: checking for _logl declaration" >&5
15244   cat > conftest.$ac_ext <<EOF
15245 #line 15246 "configure"
15246 #include "confdefs.h"
15247 #include <math.h>
15248 int main() {
15249  _logl(0);
15250 ; return 0; }
15251 EOF
15252 if { (eval echo configure:15253: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15253   rm -rf conftest*
15254   use__logl=yes
15255 else
15256   echo "configure: failed program was:" >&5
15257   cat conftest.$ac_ext >&5
15258   rm -rf conftest*
15259   use__logl=no
15260 fi
15261 rm -f conftest*
15262   echo "$ac_t""$use__logl" 1>&6
15263   ac_ext=c
15264 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15265 ac_cpp='$CPP $CPPFLAGS'
15266 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15267 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15268 cross_compiling=$ac_cv_prog_cc_cross
15269
15270   if test x$use__logl = x"yes"; then
15271     for ac_func in _logl
15272 do
15273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15274 echo "configure:15275: checking for $ac_func" >&5
15275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15276   echo $ac_n "(cached) $ac_c" 1>&6
15277 else
15278   cat > conftest.$ac_ext <<EOF
15279 #line 15280 "configure"
15280 #include "confdefs.h"
15281 /* System header to define __stub macros and hopefully few prototypes,
15282     which can conflict with char $ac_func(); below.  */
15283 #include <assert.h>
15284 /* Override any gcc2 internal prototype to avoid an error.  */
15285 /* We use char because int might match the return type of a gcc2
15286     builtin and then its argument prototype would still apply.  */
15287 char $ac_func();
15288
15289 int main() {
15290
15291 /* The GNU C library defines this for functions which it implements
15292     to always fail with ENOSYS.  Some functions are actually named
15293     something starting with __ and the normal name is an alias.  */
15294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15295 choke me
15296 #else
15297 $ac_func();
15298 #endif
15299
15300 ; return 0; }
15301 EOF
15302 if { (eval echo configure:15303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15303   rm -rf conftest*
15304   eval "ac_cv_func_$ac_func=yes"
15305 else
15306   echo "configure: failed program was:" >&5
15307   cat conftest.$ac_ext >&5
15308   rm -rf conftest*
15309   eval "ac_cv_func_$ac_func=no"
15310 fi
15311 rm -f conftest*
15312 fi
15313
15314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15315   echo "$ac_t""yes" 1>&6
15316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15317   cat >> confdefs.h <<EOF
15318 #define $ac_tr_func 1
15319 EOF
15320
15321 else
15322   echo "$ac_t""no" 1>&6
15323 fi
15324 done
15325
15326   fi
15327
15328
15329
15330   ac_ext=C
15331 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15332 ac_cpp='$CXXCPP $CPPFLAGS'
15333 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15334 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15335 cross_compiling=$ac_cv_prog_cxx_cross
15336
15337   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
15338 echo "configure:15339: checking for _log10l declaration" >&5
15339   cat > conftest.$ac_ext <<EOF
15340 #line 15341 "configure"
15341 #include "confdefs.h"
15342 #include <math.h>
15343 int main() {
15344  _log10l(0);
15345 ; return 0; }
15346 EOF
15347 if { (eval echo configure:15348: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15348   rm -rf conftest*
15349   use__log10l=yes
15350 else
15351   echo "configure: failed program was:" >&5
15352   cat conftest.$ac_ext >&5
15353   rm -rf conftest*
15354   use__log10l=no
15355 fi
15356 rm -f conftest*
15357   echo "$ac_t""$use__log10l" 1>&6
15358   ac_ext=c
15359 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15360 ac_cpp='$CPP $CPPFLAGS'
15361 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15362 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15363 cross_compiling=$ac_cv_prog_cc_cross
15364
15365   if test x$use__log10l = x"yes"; then
15366     for ac_func in _log10l
15367 do
15368 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15369 echo "configure:15370: checking for $ac_func" >&5
15370 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15371   echo $ac_n "(cached) $ac_c" 1>&6
15372 else
15373   cat > conftest.$ac_ext <<EOF
15374 #line 15375 "configure"
15375 #include "confdefs.h"
15376 /* System header to define __stub macros and hopefully few prototypes,
15377     which can conflict with char $ac_func(); below.  */
15378 #include <assert.h>
15379 /* Override any gcc2 internal prototype to avoid an error.  */
15380 /* We use char because int might match the return type of a gcc2
15381     builtin and then its argument prototype would still apply.  */
15382 char $ac_func();
15383
15384 int main() {
15385
15386 /* The GNU C library defines this for functions which it implements
15387     to always fail with ENOSYS.  Some functions are actually named
15388     something starting with __ and the normal name is an alias.  */
15389 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15390 choke me
15391 #else
15392 $ac_func();
15393 #endif
15394
15395 ; return 0; }
15396 EOF
15397 if { (eval echo configure:15398: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15398   rm -rf conftest*
15399   eval "ac_cv_func_$ac_func=yes"
15400 else
15401   echo "configure: failed program was:" >&5
15402   cat conftest.$ac_ext >&5
15403   rm -rf conftest*
15404   eval "ac_cv_func_$ac_func=no"
15405 fi
15406 rm -f conftest*
15407 fi
15408
15409 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15410   echo "$ac_t""yes" 1>&6
15411     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15412   cat >> confdefs.h <<EOF
15413 #define $ac_tr_func 1
15414 EOF
15415
15416 else
15417   echo "$ac_t""no" 1>&6
15418 fi
15419 done
15420
15421   fi
15422
15423
15424
15425   ac_ext=C
15426 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15427 ac_cpp='$CXXCPP $CPPFLAGS'
15428 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15429 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15430 cross_compiling=$ac_cv_prog_cxx_cross
15431
15432   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
15433 echo "configure:15434: checking for _modfl declaration" >&5
15434   cat > conftest.$ac_ext <<EOF
15435 #line 15436 "configure"
15436 #include "confdefs.h"
15437 #include <math.h>
15438 int main() {
15439  _modfl(0, 0);
15440 ; return 0; }
15441 EOF
15442 if { (eval echo configure:15443: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15443   rm -rf conftest*
15444   use__modfl=yes
15445 else
15446   echo "configure: failed program was:" >&5
15447   cat conftest.$ac_ext >&5
15448   rm -rf conftest*
15449   use__modfl=no
15450 fi
15451 rm -f conftest*
15452   echo "$ac_t""$use__modfl" 1>&6
15453   ac_ext=c
15454 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15455 ac_cpp='$CPP $CPPFLAGS'
15456 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15457 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15458 cross_compiling=$ac_cv_prog_cc_cross
15459
15460   if test x$use__modfl = x"yes"; then
15461     for ac_func in _modfl
15462 do
15463 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15464 echo "configure:15465: checking for $ac_func" >&5
15465 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15466   echo $ac_n "(cached) $ac_c" 1>&6
15467 else
15468   cat > conftest.$ac_ext <<EOF
15469 #line 15470 "configure"
15470 #include "confdefs.h"
15471 /* System header to define __stub macros and hopefully few prototypes,
15472     which can conflict with char $ac_func(); below.  */
15473 #include <assert.h>
15474 /* Override any gcc2 internal prototype to avoid an error.  */
15475 /* We use char because int might match the return type of a gcc2
15476     builtin and then its argument prototype would still apply.  */
15477 char $ac_func();
15478
15479 int main() {
15480
15481 /* The GNU C library defines this for functions which it implements
15482     to always fail with ENOSYS.  Some functions are actually named
15483     something starting with __ and the normal name is an alias.  */
15484 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15485 choke me
15486 #else
15487 $ac_func();
15488 #endif
15489
15490 ; return 0; }
15491 EOF
15492 if { (eval echo configure:15493: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15493   rm -rf conftest*
15494   eval "ac_cv_func_$ac_func=yes"
15495 else
15496   echo "configure: failed program was:" >&5
15497   cat conftest.$ac_ext >&5
15498   rm -rf conftest*
15499   eval "ac_cv_func_$ac_func=no"
15500 fi
15501 rm -f conftest*
15502 fi
15503
15504 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15505   echo "$ac_t""yes" 1>&6
15506     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15507   cat >> confdefs.h <<EOF
15508 #define $ac_tr_func 1
15509 EOF
15510
15511 else
15512   echo "$ac_t""no" 1>&6
15513 fi
15514 done
15515
15516   fi
15517
15518
15519
15520   ac_ext=C
15521 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15522 ac_cpp='$CXXCPP $CPPFLAGS'
15523 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15524 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15525 cross_compiling=$ac_cv_prog_cxx_cross
15526
15527   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
15528 echo "configure:15529: checking for _powl declaration" >&5
15529   cat > conftest.$ac_ext <<EOF
15530 #line 15531 "configure"
15531 #include "confdefs.h"
15532 #include <math.h>
15533 int main() {
15534  _powl(0, 0);
15535 ; return 0; }
15536 EOF
15537 if { (eval echo configure:15538: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15538   rm -rf conftest*
15539   use__powl=yes
15540 else
15541   echo "configure: failed program was:" >&5
15542   cat conftest.$ac_ext >&5
15543   rm -rf conftest*
15544   use__powl=no
15545 fi
15546 rm -f conftest*
15547   echo "$ac_t""$use__powl" 1>&6
15548   ac_ext=c
15549 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15550 ac_cpp='$CPP $CPPFLAGS'
15551 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15552 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15553 cross_compiling=$ac_cv_prog_cc_cross
15554
15555   if test x$use__powl = x"yes"; then
15556     for ac_func in _powl
15557 do
15558 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15559 echo "configure:15560: checking for $ac_func" >&5
15560 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15561   echo $ac_n "(cached) $ac_c" 1>&6
15562 else
15563   cat > conftest.$ac_ext <<EOF
15564 #line 15565 "configure"
15565 #include "confdefs.h"
15566 /* System header to define __stub macros and hopefully few prototypes,
15567     which can conflict with char $ac_func(); below.  */
15568 #include <assert.h>
15569 /* Override any gcc2 internal prototype to avoid an error.  */
15570 /* We use char because int might match the return type of a gcc2
15571     builtin and then its argument prototype would still apply.  */
15572 char $ac_func();
15573
15574 int main() {
15575
15576 /* The GNU C library defines this for functions which it implements
15577     to always fail with ENOSYS.  Some functions are actually named
15578     something starting with __ and the normal name is an alias.  */
15579 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15580 choke me
15581 #else
15582 $ac_func();
15583 #endif
15584
15585 ; return 0; }
15586 EOF
15587 if { (eval echo configure:15588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15588   rm -rf conftest*
15589   eval "ac_cv_func_$ac_func=yes"
15590 else
15591   echo "configure: failed program was:" >&5
15592   cat conftest.$ac_ext >&5
15593   rm -rf conftest*
15594   eval "ac_cv_func_$ac_func=no"
15595 fi
15596 rm -f conftest*
15597 fi
15598
15599 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15600   echo "$ac_t""yes" 1>&6
15601     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15602   cat >> confdefs.h <<EOF
15603 #define $ac_tr_func 1
15604 EOF
15605
15606 else
15607   echo "$ac_t""no" 1>&6
15608 fi
15609 done
15610
15611   fi
15612
15613
15614
15615   ac_ext=C
15616 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15617 ac_cpp='$CXXCPP $CPPFLAGS'
15618 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15619 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15620 cross_compiling=$ac_cv_prog_cxx_cross
15621
15622   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
15623 echo "configure:15624: checking for _sinl declaration" >&5
15624   cat > conftest.$ac_ext <<EOF
15625 #line 15626 "configure"
15626 #include "confdefs.h"
15627 #include <math.h>
15628 int main() {
15629  _sinl(0, 0);
15630 ; return 0; }
15631 EOF
15632 if { (eval echo configure:15633: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15633   rm -rf conftest*
15634   use__sinl=yes
15635 else
15636   echo "configure: failed program was:" >&5
15637   cat conftest.$ac_ext >&5
15638   rm -rf conftest*
15639   use__sinl=no
15640 fi
15641 rm -f conftest*
15642   echo "$ac_t""$use__sinl" 1>&6
15643   ac_ext=c
15644 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15645 ac_cpp='$CPP $CPPFLAGS'
15646 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15647 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15648 cross_compiling=$ac_cv_prog_cc_cross
15649
15650   if test x$use__sinl = x"yes"; then
15651     for ac_func in _sinl
15652 do
15653 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15654 echo "configure:15655: checking for $ac_func" >&5
15655 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15656   echo $ac_n "(cached) $ac_c" 1>&6
15657 else
15658   cat > conftest.$ac_ext <<EOF
15659 #line 15660 "configure"
15660 #include "confdefs.h"
15661 /* System header to define __stub macros and hopefully few prototypes,
15662     which can conflict with char $ac_func(); below.  */
15663 #include <assert.h>
15664 /* Override any gcc2 internal prototype to avoid an error.  */
15665 /* We use char because int might match the return type of a gcc2
15666     builtin and then its argument prototype would still apply.  */
15667 char $ac_func();
15668
15669 int main() {
15670
15671 /* The GNU C library defines this for functions which it implements
15672     to always fail with ENOSYS.  Some functions are actually named
15673     something starting with __ and the normal name is an alias.  */
15674 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15675 choke me
15676 #else
15677 $ac_func();
15678 #endif
15679
15680 ; return 0; }
15681 EOF
15682 if { (eval echo configure:15683: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15683   rm -rf conftest*
15684   eval "ac_cv_func_$ac_func=yes"
15685 else
15686   echo "configure: failed program was:" >&5
15687   cat conftest.$ac_ext >&5
15688   rm -rf conftest*
15689   eval "ac_cv_func_$ac_func=no"
15690 fi
15691 rm -f conftest*
15692 fi
15693
15694 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15695   echo "$ac_t""yes" 1>&6
15696     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15697   cat >> confdefs.h <<EOF
15698 #define $ac_tr_func 1
15699 EOF
15700
15701 else
15702   echo "$ac_t""no" 1>&6
15703 fi
15704 done
15705
15706   fi
15707
15708
15709
15710   ac_ext=C
15711 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15712 ac_cpp='$CXXCPP $CPPFLAGS'
15713 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15714 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15715 cross_compiling=$ac_cv_prog_cxx_cross
15716
15717   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
15718 echo "configure:15719: checking for _sinhl declaration" >&5
15719   cat > conftest.$ac_ext <<EOF
15720 #line 15721 "configure"
15721 #include "confdefs.h"
15722 #include <math.h>
15723 int main() {
15724  _sinhl(0);
15725 ; return 0; }
15726 EOF
15727 if { (eval echo configure:15728: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15728   rm -rf conftest*
15729   use__sinhl=yes
15730 else
15731   echo "configure: failed program was:" >&5
15732   cat conftest.$ac_ext >&5
15733   rm -rf conftest*
15734   use__sinhl=no
15735 fi
15736 rm -f conftest*
15737   echo "$ac_t""$use__sinhl" 1>&6
15738   ac_ext=c
15739 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15740 ac_cpp='$CPP $CPPFLAGS'
15741 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15742 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15743 cross_compiling=$ac_cv_prog_cc_cross
15744
15745   if test x$use__sinhl = x"yes"; then
15746     for ac_func in _sinhl
15747 do
15748 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15749 echo "configure:15750: checking for $ac_func" >&5
15750 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15751   echo $ac_n "(cached) $ac_c" 1>&6
15752 else
15753   cat > conftest.$ac_ext <<EOF
15754 #line 15755 "configure"
15755 #include "confdefs.h"
15756 /* System header to define __stub macros and hopefully few prototypes,
15757     which can conflict with char $ac_func(); below.  */
15758 #include <assert.h>
15759 /* Override any gcc2 internal prototype to avoid an error.  */
15760 /* We use char because int might match the return type of a gcc2
15761     builtin and then its argument prototype would still apply.  */
15762 char $ac_func();
15763
15764 int main() {
15765
15766 /* The GNU C library defines this for functions which it implements
15767     to always fail with ENOSYS.  Some functions are actually named
15768     something starting with __ and the normal name is an alias.  */
15769 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15770 choke me
15771 #else
15772 $ac_func();
15773 #endif
15774
15775 ; return 0; }
15776 EOF
15777 if { (eval echo configure:15778: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15778   rm -rf conftest*
15779   eval "ac_cv_func_$ac_func=yes"
15780 else
15781   echo "configure: failed program was:" >&5
15782   cat conftest.$ac_ext >&5
15783   rm -rf conftest*
15784   eval "ac_cv_func_$ac_func=no"
15785 fi
15786 rm -f conftest*
15787 fi
15788
15789 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15790   echo "$ac_t""yes" 1>&6
15791     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15792   cat >> confdefs.h <<EOF
15793 #define $ac_tr_func 1
15794 EOF
15795
15796 else
15797   echo "$ac_t""no" 1>&6
15798 fi
15799 done
15800
15801   fi
15802
15803
15804
15805   ac_ext=C
15806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15807 ac_cpp='$CXXCPP $CPPFLAGS'
15808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15810 cross_compiling=$ac_cv_prog_cxx_cross
15811
15812   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
15813 echo "configure:15814: checking for _sqrtl declaration" >&5
15814   cat > conftest.$ac_ext <<EOF
15815 #line 15816 "configure"
15816 #include "confdefs.h"
15817 #include <math.h>
15818 int main() {
15819  _sqrtl(0);
15820 ; return 0; }
15821 EOF
15822 if { (eval echo configure:15823: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15823   rm -rf conftest*
15824   use__sqrtl=yes
15825 else
15826   echo "configure: failed program was:" >&5
15827   cat conftest.$ac_ext >&5
15828   rm -rf conftest*
15829   use__sqrtl=no
15830 fi
15831 rm -f conftest*
15832   echo "$ac_t""$use__sqrtl" 1>&6
15833   ac_ext=c
15834 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15835 ac_cpp='$CPP $CPPFLAGS'
15836 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15837 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15838 cross_compiling=$ac_cv_prog_cc_cross
15839
15840   if test x$use__sqrtl = x"yes"; then
15841     for ac_func in _sqrtl
15842 do
15843 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15844 echo "configure:15845: checking for $ac_func" >&5
15845 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15846   echo $ac_n "(cached) $ac_c" 1>&6
15847 else
15848   cat > conftest.$ac_ext <<EOF
15849 #line 15850 "configure"
15850 #include "confdefs.h"
15851 /* System header to define __stub macros and hopefully few prototypes,
15852     which can conflict with char $ac_func(); below.  */
15853 #include <assert.h>
15854 /* Override any gcc2 internal prototype to avoid an error.  */
15855 /* We use char because int might match the return type of a gcc2
15856     builtin and then its argument prototype would still apply.  */
15857 char $ac_func();
15858
15859 int main() {
15860
15861 /* The GNU C library defines this for functions which it implements
15862     to always fail with ENOSYS.  Some functions are actually named
15863     something starting with __ and the normal name is an alias.  */
15864 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15865 choke me
15866 #else
15867 $ac_func();
15868 #endif
15869
15870 ; return 0; }
15871 EOF
15872 if { (eval echo configure:15873: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15873   rm -rf conftest*
15874   eval "ac_cv_func_$ac_func=yes"
15875 else
15876   echo "configure: failed program was:" >&5
15877   cat conftest.$ac_ext >&5
15878   rm -rf conftest*
15879   eval "ac_cv_func_$ac_func=no"
15880 fi
15881 rm -f conftest*
15882 fi
15883
15884 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15885   echo "$ac_t""yes" 1>&6
15886     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15887   cat >> confdefs.h <<EOF
15888 #define $ac_tr_func 1
15889 EOF
15890
15891 else
15892   echo "$ac_t""no" 1>&6
15893 fi
15894 done
15895
15896   fi
15897
15898
15899
15900   ac_ext=C
15901 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15902 ac_cpp='$CXXCPP $CPPFLAGS'
15903 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15904 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15905 cross_compiling=$ac_cv_prog_cxx_cross
15906
15907   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
15908 echo "configure:15909: checking for _tanl declaration" >&5
15909   cat > conftest.$ac_ext <<EOF
15910 #line 15911 "configure"
15911 #include "confdefs.h"
15912 #include <math.h>
15913 int main() {
15914  _tanl(0);
15915 ; return 0; }
15916 EOF
15917 if { (eval echo configure:15918: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15918   rm -rf conftest*
15919   use__tanl=yes
15920 else
15921   echo "configure: failed program was:" >&5
15922   cat conftest.$ac_ext >&5
15923   rm -rf conftest*
15924   use__tanl=no
15925 fi
15926 rm -f conftest*
15927   echo "$ac_t""$use__tanl" 1>&6
15928   ac_ext=c
15929 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15930 ac_cpp='$CPP $CPPFLAGS'
15931 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15932 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15933 cross_compiling=$ac_cv_prog_cc_cross
15934
15935   if test x$use__tanl = x"yes"; then
15936     for ac_func in _tanl
15937 do
15938 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15939 echo "configure:15940: checking for $ac_func" >&5
15940 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15941   echo $ac_n "(cached) $ac_c" 1>&6
15942 else
15943   cat > conftest.$ac_ext <<EOF
15944 #line 15945 "configure"
15945 #include "confdefs.h"
15946 /* System header to define __stub macros and hopefully few prototypes,
15947     which can conflict with char $ac_func(); below.  */
15948 #include <assert.h>
15949 /* Override any gcc2 internal prototype to avoid an error.  */
15950 /* We use char because int might match the return type of a gcc2
15951     builtin and then its argument prototype would still apply.  */
15952 char $ac_func();
15953
15954 int main() {
15955
15956 /* The GNU C library defines this for functions which it implements
15957     to always fail with ENOSYS.  Some functions are actually named
15958     something starting with __ and the normal name is an alias.  */
15959 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15960 choke me
15961 #else
15962 $ac_func();
15963 #endif
15964
15965 ; return 0; }
15966 EOF
15967 if { (eval echo configure:15968: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15968   rm -rf conftest*
15969   eval "ac_cv_func_$ac_func=yes"
15970 else
15971   echo "configure: failed program was:" >&5
15972   cat conftest.$ac_ext >&5
15973   rm -rf conftest*
15974   eval "ac_cv_func_$ac_func=no"
15975 fi
15976 rm -f conftest*
15977 fi
15978
15979 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15980   echo "$ac_t""yes" 1>&6
15981     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15982   cat >> confdefs.h <<EOF
15983 #define $ac_tr_func 1
15984 EOF
15985
15986 else
15987   echo "$ac_t""no" 1>&6
15988 fi
15989 done
15990
15991   fi
15992
15993
15994
15995   ac_ext=C
15996 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15997 ac_cpp='$CXXCPP $CPPFLAGS'
15998 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15999 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16000 cross_compiling=$ac_cv_prog_cxx_cross
16001
16002   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16003 echo "configure:16004: checking for _tanhl declaration" >&5
16004   cat > conftest.$ac_ext <<EOF
16005 #line 16006 "configure"
16006 #include "confdefs.h"
16007 #include <math.h>
16008 int main() {
16009  _tanhl(0);
16010 ; return 0; }
16011 EOF
16012 if { (eval echo configure:16013: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16013   rm -rf conftest*
16014   use__tanhl=yes
16015 else
16016   echo "configure: failed program was:" >&5
16017   cat conftest.$ac_ext >&5
16018   rm -rf conftest*
16019   use__tanhl=no
16020 fi
16021 rm -f conftest*
16022   echo "$ac_t""$use__tanhl" 1>&6
16023   ac_ext=c
16024 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16025 ac_cpp='$CPP $CPPFLAGS'
16026 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16027 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16028 cross_compiling=$ac_cv_prog_cc_cross
16029
16030   if test x$use__tanhl = x"yes"; then
16031     for ac_func in _tanhl
16032 do
16033 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16034 echo "configure:16035: checking for $ac_func" >&5
16035 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16036   echo $ac_n "(cached) $ac_c" 1>&6
16037 else
16038   cat > conftest.$ac_ext <<EOF
16039 #line 16040 "configure"
16040 #include "confdefs.h"
16041 /* System header to define __stub macros and hopefully few prototypes,
16042     which can conflict with char $ac_func(); below.  */
16043 #include <assert.h>
16044 /* Override any gcc2 internal prototype to avoid an error.  */
16045 /* We use char because int might match the return type of a gcc2
16046     builtin and then its argument prototype would still apply.  */
16047 char $ac_func();
16048
16049 int main() {
16050
16051 /* The GNU C library defines this for functions which it implements
16052     to always fail with ENOSYS.  Some functions are actually named
16053     something starting with __ and the normal name is an alias.  */
16054 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16055 choke me
16056 #else
16057 $ac_func();
16058 #endif
16059
16060 ; return 0; }
16061 EOF
16062 if { (eval echo configure:16063: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16063   rm -rf conftest*
16064   eval "ac_cv_func_$ac_func=yes"
16065 else
16066   echo "configure: failed program was:" >&5
16067   cat conftest.$ac_ext >&5
16068   rm -rf conftest*
16069   eval "ac_cv_func_$ac_func=no"
16070 fi
16071 rm -f conftest*
16072 fi
16073
16074 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16075   echo "$ac_t""yes" 1>&6
16076     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16077   cat >> confdefs.h <<EOF
16078 #define $ac_tr_func 1
16079 EOF
16080
16081 else
16082   echo "$ac_t""no" 1>&6
16083 fi
16084 done
16085
16086   fi
16087
16088
16089
16090   ac_ext=C
16091 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16092 ac_cpp='$CXXCPP $CPPFLAGS'
16093 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16094 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16095 cross_compiling=$ac_cv_prog_cxx_cross
16096
16097   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16098 echo "configure:16099: checking for _sincosl declaration" >&5
16099   cat > conftest.$ac_ext <<EOF
16100 #line 16101 "configure"
16101 #include "confdefs.h"
16102 #include <math.h>
16103 int main() {
16104  _sincosl(0, 0, 0);
16105 ; return 0; }
16106 EOF
16107 if { (eval echo configure:16108: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16108   rm -rf conftest*
16109   use__sincosl=yes
16110 else
16111   echo "configure: failed program was:" >&5
16112   cat conftest.$ac_ext >&5
16113   rm -rf conftest*
16114   use__sincosl=no
16115 fi
16116 rm -f conftest*
16117   echo "$ac_t""$use__sincosl" 1>&6
16118   ac_ext=c
16119 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16120 ac_cpp='$CPP $CPPFLAGS'
16121 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16122 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16123 cross_compiling=$ac_cv_prog_cc_cross
16124
16125   if test x$use__sincosl = x"yes"; then
16126     for ac_func in _sincosl
16127 do
16128 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16129 echo "configure:16130: checking for $ac_func" >&5
16130 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16131   echo $ac_n "(cached) $ac_c" 1>&6
16132 else
16133   cat > conftest.$ac_ext <<EOF
16134 #line 16135 "configure"
16135 #include "confdefs.h"
16136 /* System header to define __stub macros and hopefully few prototypes,
16137     which can conflict with char $ac_func(); below.  */
16138 #include <assert.h>
16139 /* Override any gcc2 internal prototype to avoid an error.  */
16140 /* We use char because int might match the return type of a gcc2
16141     builtin and then its argument prototype would still apply.  */
16142 char $ac_func();
16143
16144 int main() {
16145
16146 /* The GNU C library defines this for functions which it implements
16147     to always fail with ENOSYS.  Some functions are actually named
16148     something starting with __ and the normal name is an alias.  */
16149 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16150 choke me
16151 #else
16152 $ac_func();
16153 #endif
16154
16155 ; return 0; }
16156 EOF
16157 if { (eval echo configure:16158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16158   rm -rf conftest*
16159   eval "ac_cv_func_$ac_func=yes"
16160 else
16161   echo "configure: failed program was:" >&5
16162   cat conftest.$ac_ext >&5
16163   rm -rf conftest*
16164   eval "ac_cv_func_$ac_func=no"
16165 fi
16166 rm -f conftest*
16167 fi
16168
16169 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16170   echo "$ac_t""yes" 1>&6
16171     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16172   cat >> confdefs.h <<EOF
16173 #define $ac_tr_func 1
16174 EOF
16175
16176 else
16177   echo "$ac_t""no" 1>&6
16178 fi
16179 done
16180
16181   fi
16182
16183
16184
16185   ac_ext=C
16186 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16187 ac_cpp='$CXXCPP $CPPFLAGS'
16188 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16189 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16190 cross_compiling=$ac_cv_prog_cxx_cross
16191
16192   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16193 echo "configure:16194: checking for _finitel declaration" >&5
16194   cat > conftest.$ac_ext <<EOF
16195 #line 16196 "configure"
16196 #include "confdefs.h"
16197 #include <math.h>
16198 int main() {
16199  _finitel(0);
16200 ; return 0; }
16201 EOF
16202 if { (eval echo configure:16203: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16203   rm -rf conftest*
16204   use__finitel=yes
16205 else
16206   echo "configure: failed program was:" >&5
16207   cat conftest.$ac_ext >&5
16208   rm -rf conftest*
16209   use__finitel=no
16210 fi
16211 rm -f conftest*
16212   echo "$ac_t""$use__finitel" 1>&6
16213   ac_ext=c
16214 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16215 ac_cpp='$CPP $CPPFLAGS'
16216 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16217 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16218 cross_compiling=$ac_cv_prog_cc_cross
16219
16220   if test x$use__finitel = x"yes"; then
16221     for ac_func in _finitel
16222 do
16223 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16224 echo "configure:16225: checking for $ac_func" >&5
16225 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16226   echo $ac_n "(cached) $ac_c" 1>&6
16227 else
16228   cat > conftest.$ac_ext <<EOF
16229 #line 16230 "configure"
16230 #include "confdefs.h"
16231 /* System header to define __stub macros and hopefully few prototypes,
16232     which can conflict with char $ac_func(); below.  */
16233 #include <assert.h>
16234 /* Override any gcc2 internal prototype to avoid an error.  */
16235 /* We use char because int might match the return type of a gcc2
16236     builtin and then its argument prototype would still apply.  */
16237 char $ac_func();
16238
16239 int main() {
16240
16241 /* The GNU C library defines this for functions which it implements
16242     to always fail with ENOSYS.  Some functions are actually named
16243     something starting with __ and the normal name is an alias.  */
16244 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16245 choke me
16246 #else
16247 $ac_func();
16248 #endif
16249
16250 ; return 0; }
16251 EOF
16252 if { (eval echo configure:16253: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16253   rm -rf conftest*
16254   eval "ac_cv_func_$ac_func=yes"
16255 else
16256   echo "configure: failed program was:" >&5
16257   cat conftest.$ac_ext >&5
16258   rm -rf conftest*
16259   eval "ac_cv_func_$ac_func=no"
16260 fi
16261 rm -f conftest*
16262 fi
16263
16264 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16265   echo "$ac_t""yes" 1>&6
16266     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16267   cat >> confdefs.h <<EOF
16268 #define $ac_tr_func 1
16269 EOF
16270
16271 else
16272   echo "$ac_t""no" 1>&6
16273 fi
16274 done
16275
16276   fi
16277
16278
16279   LIBS="$ac_save_LIBS"
16280   CXXFLAGS="$ac_save_CXXFLAGS"
16281
16282
16283     for ac_hdr in complex.h
16284 do
16285 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16286 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16287 echo "configure:16288: checking for $ac_hdr" >&5
16288 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16289   echo $ac_n "(cached) $ac_c" 1>&6
16290 else
16291   cat > conftest.$ac_ext <<EOF
16292 #line 16293 "configure"
16293 #include "confdefs.h"
16294 #include <$ac_hdr>
16295 EOF
16296 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16297 { (eval echo configure:16298: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16298 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16299 if test -z "$ac_err"; then
16300   rm -rf conftest*
16301   eval "ac_cv_header_$ac_safe=yes"
16302 else
16303   echo "$ac_err" >&5
16304   echo "configure: failed program was:" >&5
16305   cat conftest.$ac_ext >&5
16306   rm -rf conftest*
16307   eval "ac_cv_header_$ac_safe=no"
16308 fi
16309 rm -f conftest*
16310 fi
16311 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16312   echo "$ac_t""yes" 1>&6
16313     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
16314   cat >> confdefs.h <<EOF
16315 #define $ac_tr_hdr 1
16316 EOF
16317
16318 else
16319   echo "$ac_t""no" 1>&6
16320 fi
16321 done
16322
16323   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
16324   clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
16325   ctan ctanf ctanh ctanhf \
16326   carg cargf nan hypot hypotf atan2f expf copysignf
16327 do
16328 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16329 echo "configure:16330: checking for $ac_func" >&5
16330 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16331   echo $ac_n "(cached) $ac_c" 1>&6
16332 else
16333   cat > conftest.$ac_ext <<EOF
16334 #line 16335 "configure"
16335 #include "confdefs.h"
16336 /* System header to define __stub macros and hopefully few prototypes,
16337     which can conflict with char $ac_func(); below.  */
16338 #include <assert.h>
16339 /* Override any gcc2 internal prototype to avoid an error.  */
16340 /* We use char because int might match the return type of a gcc2
16341     builtin and then its argument prototype would still apply.  */
16342 char $ac_func();
16343
16344 int main() {
16345
16346 /* The GNU C library defines this for functions which it implements
16347     to always fail with ENOSYS.  Some functions are actually named
16348     something starting with __ and the normal name is an alias.  */
16349 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16350 choke me
16351 #else
16352 $ac_func();
16353 #endif
16354
16355 ; return 0; }
16356 EOF
16357 if { (eval echo configure:16358: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16358   rm -rf conftest*
16359   eval "ac_cv_func_$ac_func=yes"
16360 else
16361   echo "configure: failed program was:" >&5
16362   cat conftest.$ac_ext >&5
16363   rm -rf conftest*
16364   eval "ac_cv_func_$ac_func=no"
16365 fi
16366 rm -f conftest*
16367 fi
16368
16369 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16370   echo "$ac_t""yes" 1>&6
16371     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16372   cat >> confdefs.h <<EOF
16373 #define $ac_tr_func 1
16374 EOF
16375
16376 else
16377   echo "$ac_t""no" 1>&6
16378 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
16379 fi
16380 done
16381
16382
16383
16384       USE_LONG_DOUBLE=no
16385   echo $ac_n "checking for copysignl""... $ac_c" 1>&6
16386 echo "configure:16387: checking for copysignl" >&5
16387 if eval "test \"`echo '$''{'ac_cv_func_copysignl'+set}'`\" = set"; then
16388   echo $ac_n "(cached) $ac_c" 1>&6
16389 else
16390   cat > conftest.$ac_ext <<EOF
16391 #line 16392 "configure"
16392 #include "confdefs.h"
16393 /* System header to define __stub macros and hopefully few prototypes,
16394     which can conflict with char copysignl(); below.  */
16395 #include <assert.h>
16396 /* Override any gcc2 internal prototype to avoid an error.  */
16397 /* We use char because int might match the return type of a gcc2
16398     builtin and then its argument prototype would still apply.  */
16399 char copysignl();
16400
16401 int main() {
16402
16403 /* The GNU C library defines this for functions which it implements
16404     to always fail with ENOSYS.  Some functions are actually named
16405     something starting with __ and the normal name is an alias.  */
16406 #if defined (__stub_copysignl) || defined (__stub___copysignl)
16407 choke me
16408 #else
16409 copysignl();
16410 #endif
16411
16412 ; return 0; }
16413 EOF
16414 if { (eval echo configure:16415: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16415   rm -rf conftest*
16416   eval "ac_cv_func_copysignl=yes"
16417 else
16418   echo "configure: failed program was:" >&5
16419   cat conftest.$ac_ext >&5
16420   rm -rf conftest*
16421   eval "ac_cv_func_copysignl=no"
16422 fi
16423 rm -f conftest*
16424 fi
16425
16426 if eval "test \"`echo '$ac_cv_func_'copysignl`\" = yes"; then
16427   echo "$ac_t""yes" 1>&6
16428   USE_LONG_DOUBLE=yes
16429   for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
16430   csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
16431 do
16432 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16433 echo "configure:16434: checking for $ac_func" >&5
16434 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16435   echo $ac_n "(cached) $ac_c" 1>&6
16436 else
16437   cat > conftest.$ac_ext <<EOF
16438 #line 16439 "configure"
16439 #include "confdefs.h"
16440 /* System header to define __stub macros and hopefully few prototypes,
16441     which can conflict with char $ac_func(); below.  */
16442 #include <assert.h>
16443 /* Override any gcc2 internal prototype to avoid an error.  */
16444 /* We use char because int might match the return type of a gcc2
16445     builtin and then its argument prototype would still apply.  */
16446 char $ac_func();
16447
16448 int main() {
16449
16450 /* The GNU C library defines this for functions which it implements
16451     to always fail with ENOSYS.  Some functions are actually named
16452     something starting with __ and the normal name is an alias.  */
16453 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16454 choke me
16455 #else
16456 $ac_func();
16457 #endif
16458
16459 ; return 0; }
16460 EOF
16461 if { (eval echo configure:16462: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16462   rm -rf conftest*
16463   eval "ac_cv_func_$ac_func=yes"
16464 else
16465   echo "configure: failed program was:" >&5
16466   cat conftest.$ac_ext >&5
16467   rm -rf conftest*
16468   eval "ac_cv_func_$ac_func=no"
16469 fi
16470 rm -f conftest*
16471 fi
16472
16473 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16474   echo "$ac_t""yes" 1>&6
16475     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16476   cat >> confdefs.h <<EOF
16477 #define $ac_tr_func 1
16478 EOF
16479
16480 else
16481   echo "$ac_t""no" 1>&6
16482 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
16483 fi
16484 done
16485
16486
16487 else
16488   echo "$ac_t""no" 1>&6
16489 fi
16490
16491
16492
16493
16494
16495
16496   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
16497 echo "configure:16498: checking for GNU C++ __complex__ support" >&5
16498   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
16499   echo $ac_n "(cached) $ac_c" 1>&6
16500 else
16501
16502
16503     ac_ext=C
16504 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16505 ac_cpp='$CXXCPP $CPPFLAGS'
16506 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16507 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16508 cross_compiling=$ac_cv_prog_cxx_cross
16509
16510     cat > conftest.$ac_ext <<EOF
16511 #line 16512 "configure"
16512 #include "confdefs.h"
16513 struct dcomplex { __complex__ double x; }; \
16514                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
16515 int main() {
16516 \
16517                      dcomplex x; f(x);
16518 ; return 0; }
16519 EOF
16520 if { (eval echo configure:16521: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16521   rm -rf conftest*
16522   glibcpp_cv_complex=ok
16523 else
16524   echo "configure: failed program was:" >&5
16525   cat conftest.$ac_ext >&5
16526   rm -rf conftest*
16527   glibcpp_cv_complex=buggy
16528
16529 fi
16530 rm -f conftest*
16531     ac_ext=c
16532 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16533 ac_cpp='$CPP $CPPFLAGS'
16534 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16535 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16536 cross_compiling=$ac_cv_prog_cc_cross
16537
16538
16539 fi
16540
16541   echo "$ac_t""$glibcpp_cv_complex" 1>&6
16542   if test $glibcpp_cv_complex = buggy; then
16543     cat >> confdefs.h <<\EOF
16544 #define _GLIBCPP_BUGGY_COMPLEX 1
16545 EOF
16546
16547   fi
16548
16549   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
16550 echo "configure:16551: checking for GNU C++ __complex__ float support" >&5
16551   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
16552   echo $ac_n "(cached) $ac_c" 1>&6
16553 else
16554
16555
16556     ac_ext=C
16557 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16558 ac_cpp='$CXXCPP $CPPFLAGS'
16559 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16560 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16561 cross_compiling=$ac_cv_prog_cxx_cross
16562
16563     rm -f conftest.h
16564     cat > conftest.h <<EOB
16565       //
16566       // Check for buggy __complex__ that causes ICE in most versions of egcs
16567       // and gcc-2.95.x on certain platforms (eg., x86-win32).
16568       //
16569       // See http://egcs.cygnus.com/ml/gcc-bugs/1999-07/msg00845.html for
16570       // more info on the bug itself.
16571       //
16572       struct
16573       float_complex
16574       {
16575        __complex__ float m_value;
16576        float_complex (float = 0.0f, float = 0.0f);
16577        float_complex (__complex__ float val) : m_value (val) {}
16578        float_complex foo (const float_complex &val)
16579          { return float_complex (~val.m_value); }
16580       };
16581 EOB
16582     cat > conftest.$ac_ext <<EOF
16583 #line 16584 "configure"
16584 #include "confdefs.h"
16585 #include "conftest.h"
16586 int main() {
16587
16588 ; return 0; }
16589 EOF
16590 if { (eval echo configure:16591: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16591   rm -rf conftest*
16592   glibcpp_cv_float_complex=ok
16593 else
16594   echo "configure: failed program was:" >&5
16595   cat conftest.$ac_ext >&5
16596   rm -rf conftest*
16597   glibcpp_cv_float_complex=buggy
16598
16599 fi
16600 rm -f conftest*
16601     ac_ext=c
16602 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16603 ac_cpp='$CPP $CPPFLAGS'
16604 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16605 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16606 cross_compiling=$ac_cv_prog_cc_cross
16607
16608
16609 fi
16610
16611   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
16612   if test $glibcpp_cv_float_complex = buggy; then
16613     cat >> confdefs.h <<\EOF
16614 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
16615 EOF
16616
16617   fi
16618
16619
16620
16621     ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
16622 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
16623 echo "configure:16624: checking for wchar.h" >&5
16624 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16625   echo $ac_n "(cached) $ac_c" 1>&6
16626 else
16627   cat > conftest.$ac_ext <<EOF
16628 #line 16629 "configure"
16629 #include "confdefs.h"
16630 #include <wchar.h>
16631 EOF
16632 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16633 { (eval echo configure:16634: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16634 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16635 if test -z "$ac_err"; then
16636   rm -rf conftest*
16637   eval "ac_cv_header_$ac_safe=yes"
16638 else
16639   echo "$ac_err" >&5
16640   echo "configure: failed program was:" >&5
16641   cat conftest.$ac_ext >&5
16642   rm -rf conftest*
16643   eval "ac_cv_header_$ac_safe=no"
16644 fi
16645 rm -f conftest*
16646 fi
16647 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16648   echo "$ac_t""yes" 1>&6
16649   ac_has_wchar_h=yes
16650 else
16651   echo "$ac_t""no" 1>&6
16652 ac_has_wchar_h=no
16653 fi
16654
16655   ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
16656 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
16657 echo "configure:16658: checking for wctype.h" >&5
16658 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16659   echo $ac_n "(cached) $ac_c" 1>&6
16660 else
16661   cat > conftest.$ac_ext <<EOF
16662 #line 16663 "configure"
16663 #include "confdefs.h"
16664 #include <wctype.h>
16665 EOF
16666 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16667 { (eval echo configure:16668: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16668 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16669 if test -z "$ac_err"; then
16670   rm -rf conftest*
16671   eval "ac_cv_header_$ac_safe=yes"
16672 else
16673   echo "$ac_err" >&5
16674   echo "configure: failed program was:" >&5
16675   cat conftest.$ac_ext >&5
16676   rm -rf conftest*
16677   eval "ac_cv_header_$ac_safe=no"
16678 fi
16679 rm -f conftest*
16680 fi
16681 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16682   echo "$ac_t""yes" 1>&6
16683   ac_has_wctype_h=yes
16684 else
16685   echo "$ac_t""no" 1>&6
16686 ac_has_wctype_h=no
16687 fi
16688
16689
16690     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
16691
16692         echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
16693 echo "configure:16694: checking for mbstate_t" >&5
16694     cat > conftest.$ac_ext <<EOF
16695 #line 16696 "configure"
16696 #include "confdefs.h"
16697 #include <wchar.h>
16698 int main() {
16699 mbstate_t teststate;
16700 ; return 0; }
16701 EOF
16702 if { (eval echo configure:16703: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16703   rm -rf conftest*
16704   use_native_mbstatet=yes
16705 else
16706   echo "configure: failed program was:" >&5
16707   cat conftest.$ac_ext >&5
16708   rm -rf conftest*
16709   use_native_mbstatet=no
16710 fi
16711 rm -f conftest*
16712     echo "$ac_t""$use_native_mbstatet" 1>&6
16713     if test x"$use_native_mbstatet" = xno; then
16714       cat >> confdefs.h <<\EOF
16715 #define _GLIBCPP_NEED_MBSTATE_T 1
16716 EOF
16717
16718     fi
16719
16720             echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
16721 echo "configure:16722: checking for WCHAR_MIN and WCHAR_MAX" >&5
16722     cat > conftest.$ac_ext <<EOF
16723 #line 16724 "configure"
16724 #include "confdefs.h"
16725 #include <wchar.h>
16726 int main() {
16727 int i = WCHAR_MIN; int j = WCHAR_MAX;
16728 ; return 0; }
16729 EOF
16730 if { (eval echo configure:16731: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16731   rm -rf conftest*
16732   has_wchar_minmax=yes
16733 else
16734   echo "configure: failed program was:" >&5
16735   cat conftest.$ac_ext >&5
16736   rm -rf conftest*
16737   has_wchar_minmax=no
16738 fi
16739 rm -f conftest*
16740     echo "$ac_t""$has_wchar_minmax" 1>&6
16741
16742             echo $ac_n "checking for WEOF""... $ac_c" 1>&6
16743 echo "configure:16744: checking for WEOF" >&5
16744     cat > conftest.$ac_ext <<EOF
16745 #line 16746 "configure"
16746 #include "confdefs.h"
16747
16748       #include <wchar.h>
16749       #include <stddef.h>
16750 int main() {
16751 wint_t i = WEOF;
16752 ; return 0; }
16753 EOF
16754 if { (eval echo configure:16755: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16755   rm -rf conftest*
16756   has_weof=yes
16757 else
16758   echo "configure: failed program was:" >&5
16759   cat conftest.$ac_ext >&5
16760   rm -rf conftest*
16761   has_weof=no
16762 fi
16763 rm -f conftest*
16764     echo "$ac_t""$has_weof" 1>&6
16765
16766         for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset
16767 do
16768 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16769 echo "configure:16770: checking for $ac_func" >&5
16770 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16771   echo $ac_n "(cached) $ac_c" 1>&6
16772 else
16773   cat > conftest.$ac_ext <<EOF
16774 #line 16775 "configure"
16775 #include "confdefs.h"
16776 /* System header to define __stub macros and hopefully few prototypes,
16777     which can conflict with char $ac_func(); below.  */
16778 #include <assert.h>
16779 /* Override any gcc2 internal prototype to avoid an error.  */
16780 /* We use char because int might match the return type of a gcc2
16781     builtin and then its argument prototype would still apply.  */
16782 char $ac_func();
16783
16784 int main() {
16785
16786 /* The GNU C library defines this for functions which it implements
16787     to always fail with ENOSYS.  Some functions are actually named
16788     something starting with __ and the normal name is an alias.  */
16789 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16790 choke me
16791 #else
16792 $ac_func();
16793 #endif
16794
16795 ; return 0; }
16796 EOF
16797 if { (eval echo configure:16798: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16798   rm -rf conftest*
16799   eval "ac_cv_func_$ac_func=yes"
16800 else
16801   echo "configure: failed program was:" >&5
16802   cat conftest.$ac_ext >&5
16803   rm -rf conftest*
16804   eval "ac_cv_func_$ac_func=no"
16805 fi
16806 rm -f conftest*
16807 fi
16808
16809 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16810   echo "$ac_t""yes" 1>&6
16811     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16812   cat >> confdefs.h <<EOF
16813 #define $ac_tr_func 1
16814 EOF
16815  ac_wfuncs=yes
16816 else
16817   echo "$ac_t""no" 1>&6
16818 ac_wfuncs=no
16819 fi
16820 done
16821
16822
16823     echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
16824 echo "configure:16825: checking for ISO C9X wchar_t support" >&5
16825     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes && test x"$ac_wfuncs" = xyes; then
16826       ac_isoC9X_wchar_t=yes
16827     else
16828       ac_isoC9X_wchar_t=no
16829     fi
16830     echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
16831
16832             ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
16833 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
16834 echo "configure:16835: checking for iconv.h" >&5
16835 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16836   echo $ac_n "(cached) $ac_c" 1>&6
16837 else
16838   cat > conftest.$ac_ext <<EOF
16839 #line 16840 "configure"
16840 #include "confdefs.h"
16841 #include <iconv.h>
16842 EOF
16843 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16844 { (eval echo configure:16845: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16845 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16846 if test -z "$ac_err"; then
16847   rm -rf conftest*
16848   eval "ac_cv_header_$ac_safe=yes"
16849 else
16850   echo "$ac_err" >&5
16851   echo "configure: failed program was:" >&5
16852   cat conftest.$ac_ext >&5
16853   rm -rf conftest*
16854   eval "ac_cv_header_$ac_safe=no"
16855 fi
16856 rm -f conftest*
16857 fi
16858 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16859   echo "$ac_t""yes" 1>&6
16860   ac_has_iconv_h=yes
16861 else
16862   echo "$ac_t""no" 1>&6
16863 ac_has_iconv_h=no
16864 fi
16865
16866     for ac_func in iconv_open iconv_close iconv
16867 do
16868 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16869 echo "configure:16870: checking for $ac_func" >&5
16870 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16871   echo $ac_n "(cached) $ac_c" 1>&6
16872 else
16873   cat > conftest.$ac_ext <<EOF
16874 #line 16875 "configure"
16875 #include "confdefs.h"
16876 /* System header to define __stub macros and hopefully few prototypes,
16877     which can conflict with char $ac_func(); below.  */
16878 #include <assert.h>
16879 /* Override any gcc2 internal prototype to avoid an error.  */
16880 /* We use char because int might match the return type of a gcc2
16881     builtin and then its argument prototype would still apply.  */
16882 char $ac_func();
16883
16884 int main() {
16885
16886 /* The GNU C library defines this for functions which it implements
16887     to always fail with ENOSYS.  Some functions are actually named
16888     something starting with __ and the normal name is an alias.  */
16889 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16890 choke me
16891 #else
16892 $ac_func();
16893 #endif
16894
16895 ; return 0; }
16896 EOF
16897 if { (eval echo configure:16898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16898   rm -rf conftest*
16899   eval "ac_cv_func_$ac_func=yes"
16900 else
16901   echo "configure: failed program was:" >&5
16902   cat conftest.$ac_ext >&5
16903   rm -rf conftest*
16904   eval "ac_cv_func_$ac_func=no"
16905 fi
16906 rm -f conftest*
16907 fi
16908
16909 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16910   echo "$ac_t""yes" 1>&6
16911     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16912   cat >> confdefs.h <<EOF
16913 #define $ac_tr_func 1
16914 EOF
16915  ac_XPG2funcs=yes
16916 else
16917   echo "$ac_t""no" 1>&6
16918 ac_XPG2funcs=no
16919 fi
16920 done
16921
16922
16923     echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
16924 echo "configure:16925: checking for XPG2 wchar_t support" >&5
16925     if test x"$ac_has_iconv_h" = xyes && test x"$ac_XPG2funcs" = xyes; then
16926       ac_XPG2_wchar_t=yes
16927     else
16928       ac_XPG2_wchar_t=no
16929     fi
16930     echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
16931
16932             echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
16933 echo "configure:16934: checking for enabled wchar_t specializations" >&5
16934     if test x"$ac_isoC9X_wchar_t" = xyes && test x"$ac_XPG2_wchar_t" = xyes; then
16935       libinst_wstring_la="libinst-wstring.la"
16936       cat >> confdefs.h <<\EOF
16937 #define _GLIBCPP_USE_WCHAR_T 1
16938 EOF
16939
16940       echo "$ac_t"""yes"" 1>&6
16941     else
16942       libinst_wstring_la=""
16943       echo "$ac_t"""no"" 1>&6
16944     fi
16945
16946
16947   else
16948     echo "configure: warning: <wchar.h> not found" 1>&2
16949     cat >> confdefs.h <<\EOF
16950 #define _GLIBCPP_NEED_MBSTATE_T 1
16951 EOF
16952
16953   fi
16954
16955
16956   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
16957 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
16958 echo "configure:16959: checking for ctype.h" >&5
16959 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16960   echo $ac_n "(cached) $ac_c" 1>&6
16961 else
16962   cat > conftest.$ac_ext <<EOF
16963 #line 16964 "configure"
16964 #include "confdefs.h"
16965 #include <ctype.h>
16966 EOF
16967 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16968 { (eval echo configure:16969: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16969 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16970 if test -z "$ac_err"; then
16971   rm -rf conftest*
16972   eval "ac_cv_header_$ac_safe=yes"
16973 else
16974   echo "$ac_err" >&5
16975   echo "configure: failed program was:" >&5
16976   cat conftest.$ac_ext >&5
16977   rm -rf conftest*
16978   eval "ac_cv_header_$ac_safe=no"
16979 fi
16980 rm -f conftest*
16981 fi
16982 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16983   echo "$ac_t""yes" 1>&6
16984
16985
16986         ctype_default=yes
16987
16988         echo $ac_n "checking <ctype> for gnu-linux ""... $ac_c" 1>&6
16989 echo "configure:16990: checking <ctype> for gnu-linux " >&5
16990     cat > conftest.$ac_ext <<EOF
16991 #line 16992 "configure"
16992 #include "confdefs.h"
16993 #include <ctype.h>
16994 int main() {
16995 int
16996     foo (int a)
16997     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
16998         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
16999         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17000 ; return 0; }
17001 EOF
17002 if { (eval echo configure:17003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17003   rm -rf conftest*
17004   \
17005     ctype_linux=yes
17006 else
17007   echo "configure: failed program was:" >&5
17008   cat conftest.$ac_ext >&5
17009   rm -rf conftest*
17010   ctype_linux=no
17011 fi
17012 rm -f conftest*
17013     echo "$ac_t""$ctype_linux" 1>&6
17014     if test $ctype_linux = "yes"; then
17015       ctype_include_dir="config/gnu-linux"
17016       ctype_default=no
17017     fi
17018
17019         if test $ctype_default = "yes"; then
17020     echo $ac_n "checking <ctype> for freebsd 4.0 ""... $ac_c" 1>&6
17021 echo "configure:17022: checking <ctype> for freebsd 4.0 " >&5
17022     cat > conftest.$ac_ext <<EOF
17023 #line 17024 "configure"
17024 #include "confdefs.h"
17025 #include <ctype.h>
17026 int main() {
17027 int
17028     foo (int a)
17029     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17030         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17031 ; return 0; }
17032 EOF
17033 if { (eval echo configure:17034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17034   rm -rf conftest*
17035   \
17036     ctype_bsd=yes
17037 else
17038   echo "configure: failed program was:" >&5
17039   cat conftest.$ac_ext >&5
17040   rm -rf conftest*
17041   ctype_bsd=no
17042 fi
17043 rm -f conftest*
17044     echo "$ac_t""$ctype_bsd" 1>&6
17045     if test $ctype_bsd = "yes"; then
17046       ctype_include_dir="config/bsd"
17047       ctype_default=no
17048     fi
17049     fi
17050
17051         if test $ctype_default = "yes"; then
17052     echo $ac_n "checking <ctype> for freebsd 3.4 ""... $ac_c" 1>&6
17053 echo "configure:17054: checking <ctype> for freebsd 3.4 " >&5
17054     cat > conftest.$ac_ext <<EOF
17055 #line 17056 "configure"
17056 #include "confdefs.h"
17057 #include <ctype.h>
17058 int main() {
17059 int
17060     foo (int a)
17061     { return _S + _R + _C + _U + _L + _A \
17062       + _D + _P + _X + _G + __istype (a, 0);}
17063 ; return 0; }
17064 EOF
17065 if { (eval echo configure:17066: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17066   rm -rf conftest*
17067   \
17068     ctype_freebsd34=yes
17069 else
17070   echo "configure: failed program was:" >&5
17071   cat conftest.$ac_ext >&5
17072   rm -rf conftest*
17073   ctype_freebsd34=no
17074 fi
17075 rm -f conftest*
17076     echo "$ac_t""$ctype_freebsd34" 1>&6
17077     if test $ctype_freebsd34 = "yes"; then
17078       ctype_include_dir="config/bsd"
17079       ctype_default=no
17080     fi
17081     fi
17082
17083         if test $ctype_default = "yes"; then
17084     echo $ac_n "checking <ctype> for solaris 2.6,7,8 ""... $ac_c" 1>&6
17085 echo "configure:17086: checking <ctype> for solaris 2.6,7,8 " >&5
17086     cat > conftest.$ac_ext <<EOF
17087 #line 17088 "configure"
17088 #include "confdefs.h"
17089 #include <ctype.h>
17090 int main() {
17091 int
17092     foo (int a)
17093     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17094         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17095         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17096 ; return 0; }
17097 EOF
17098 if { (eval echo configure:17099: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17099   rm -rf conftest*
17100   \
17101     ctype_solaris=yes
17102 else
17103   echo "configure: failed program was:" >&5
17104   cat conftest.$ac_ext >&5
17105   rm -rf conftest*
17106   ctype_solaris=no
17107 fi
17108 rm -f conftest*
17109     echo "$ac_t""$ctype_solaris" 1>&6
17110
17111     if test $ctype_solaris = "yes"; then
17112       echo $ac_n "checking   for version""... $ac_c" 1>&6
17113 echo "configure:17114: checking   for version" >&5
17114       ac_ext=C
17115 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17116 ac_cpp='$CXXCPP $CPPFLAGS'
17117 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17118 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17119 cross_compiling=$ac_cv_prog_cxx_cross
17120
17121       cat > conftest.$ac_ext <<EOF
17122 #line 17123 "configure"
17123 #include "confdefs.h"
17124 #include <ctype.h>
17125 int main() {
17126 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17127 ; return 0; }
17128 EOF
17129 if { (eval echo configure:17130: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17130   rm -rf conftest*
17131   \
17132       ctype_solaris26=yes
17133 else
17134   echo "configure: failed program was:" >&5
17135   cat conftest.$ac_ext >&5
17136   rm -rf conftest*
17137   ctype_solaris26=no
17138 fi
17139 rm -f conftest*
17140       ac_ext=c
17141 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17142 ac_cpp='$CPP $CPPFLAGS'
17143 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17144 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17145 cross_compiling=$ac_cv_prog_cc_cross
17146
17147       if test $ctype_solaris26 = "yes"; then
17148         ctype_include_dir="config/solaris/solaris2.6"
17149         echo "$ac_t"""solaris2.6"" 1>&6
17150         ctype_default=no
17151       else
17152         ctype_include_dir="config/solaris/solaris2.7"
17153         echo "$ac_t"""solaris2.7,8"" 1>&6
17154         ctype_default=no
17155       fi
17156     fi
17157     fi
17158
17159         if test $ctype_default = "yes"; then
17160     echo $ac_n "checking <ctype> for solaris 2.5.1 ""... $ac_c" 1>&6
17161 echo "configure:17162: checking <ctype> for solaris 2.5.1 " >&5
17162     cat > conftest.$ac_ext <<EOF
17163 #line 17164 "configure"
17164 #include "confdefs.h"
17165 #include <ctype.h>
17166 int main() {
17167 int
17168     foo (int a)
17169     { return _U + _L + _N + _S + _P + _C + _X + _B \
17170         + __ctype[a];}
17171 ; return 0; }
17172 EOF
17173 if { (eval echo configure:17174: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17174   rm -rf conftest*
17175   \
17176     ctype_solaris25=yes
17177 else
17178   echo "configure: failed program was:" >&5
17179   cat conftest.$ac_ext >&5
17180   rm -rf conftest*
17181   ctype_solaris25=no
17182 fi
17183 rm -f conftest*
17184     echo "$ac_t""$ctype_solaris25" 1>&6
17185     if test $ctype_solaris25 = "yes"; then
17186       ctype_include_dir="config/solaris/solaris2.5"
17187       ctype_default=no
17188     fi
17189     fi
17190
17191         if test $ctype_default = "yes"; then
17192     echo $ac_n "checking <ctype> for aix ""... $ac_c" 1>&6
17193 echo "configure:17194: checking <ctype> for aix " >&5
17194     cat > conftest.$ac_ext <<EOF
17195 #line 17196 "configure"
17196 #include "confdefs.h"
17197 #include <ctype.h>
17198 int main() {
17199 int
17200     foo (int a)
17201     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17202         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17203         + _VALC('a') + _IS('c', 0);}
17204 ; return 0; }
17205 EOF
17206 if { (eval echo configure:17207: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17207   rm -rf conftest*
17208   \
17209     ctype_aix=yes
17210 else
17211   echo "configure: failed program was:" >&5
17212   cat conftest.$ac_ext >&5
17213   rm -rf conftest*
17214   ctype_aix=no
17215 fi
17216 rm -f conftest*
17217     echo "$ac_t""$ctype_aix" 1>&6
17218     if test $ctype_aix = "yes"; then
17219       ctype_include_dir="config/aix"
17220       ctype_default=no
17221     fi
17222     fi
17223
17224         if test $ctype_default = "yes"; then
17225     echo $ac_n "checking <ctype> for newlib ""... $ac_c" 1>&6
17226 echo "configure:17227: checking <ctype> for newlib " >&5
17227     cat > conftest.$ac_ext <<EOF
17228 #line 17229 "configure"
17229 #include "confdefs.h"
17230 #include <ctype.h>
17231 int main() {
17232 int
17233     foo (int a)
17234     { return _U + _L + _N + _S + _P + _C + _X + _B \
17235         + _ctype_[a];}
17236 ; return 0; }
17237 EOF
17238 if { (eval echo configure:17239: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17239   rm -rf conftest*
17240   \
17241     ctype_newlib=yes
17242 else
17243   echo "configure: failed program was:" >&5
17244   cat conftest.$ac_ext >&5
17245   rm -rf conftest*
17246   ctype_newlib=no
17247 fi
17248 rm -f conftest*
17249     echo "$ac_t""$ctype_newlib" 1>&6
17250     if test $ctype_newlib = "yes"; then
17251       ctype_include_dir="config/newlib"
17252       ctype_default=no
17253     fi
17254     fi
17255
17256     if test $ctype_default = "yes"; then
17257       ctype_include_dir="config/generic"
17258       echo "configure: warning: "Using default ctype headers."" 1>&2
17259     fi
17260
17261
17262 else
17263   echo "$ac_t""no" 1>&6
17264 fi
17265
17266
17267
17268   for ac_hdr in unistd.h
17269 do
17270 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
17271 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
17272 echo "configure:17273: checking for $ac_hdr" >&5
17273 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17274   echo $ac_n "(cached) $ac_c" 1>&6
17275 else
17276   cat > conftest.$ac_ext <<EOF
17277 #line 17278 "configure"
17278 #include "confdefs.h"
17279 #include <$ac_hdr>
17280 EOF
17281 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17282 { (eval echo configure:17283: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17283 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17284 if test -z "$ac_err"; then
17285   rm -rf conftest*
17286   eval "ac_cv_header_$ac_safe=yes"
17287 else
17288   echo "$ac_err" >&5
17289   echo "configure: failed program was:" >&5
17290   cat conftest.$ac_ext >&5
17291   rm -rf conftest*
17292   eval "ac_cv_header_$ac_safe=no"
17293 fi
17294 rm -f conftest*
17295 fi
17296 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17297   echo "$ac_t""yes" 1>&6
17298     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17299   cat >> confdefs.h <<EOF
17300 #define $ac_tr_hdr 1
17301 EOF
17302
17303 else
17304   echo "$ac_t""no" 1>&6
17305 fi
17306 done
17307
17308 for ac_func in getpagesize
17309 do
17310 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17311 echo "configure:17312: checking for $ac_func" >&5
17312 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17313   echo $ac_n "(cached) $ac_c" 1>&6
17314 else
17315   cat > conftest.$ac_ext <<EOF
17316 #line 17317 "configure"
17317 #include "confdefs.h"
17318 /* System header to define __stub macros and hopefully few prototypes,
17319     which can conflict with char $ac_func(); below.  */
17320 #include <assert.h>
17321 /* Override any gcc2 internal prototype to avoid an error.  */
17322 /* We use char because int might match the return type of a gcc2
17323     builtin and then its argument prototype would still apply.  */
17324 char $ac_func();
17325
17326 int main() {
17327
17328 /* The GNU C library defines this for functions which it implements
17329     to always fail with ENOSYS.  Some functions are actually named
17330     something starting with __ and the normal name is an alias.  */
17331 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17332 choke me
17333 #else
17334 $ac_func();
17335 #endif
17336
17337 ; return 0; }
17338 EOF
17339 if { (eval echo configure:17340: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17340   rm -rf conftest*
17341   eval "ac_cv_func_$ac_func=yes"
17342 else
17343   echo "configure: failed program was:" >&5
17344   cat conftest.$ac_ext >&5
17345   rm -rf conftest*
17346   eval "ac_cv_func_$ac_func=no"
17347 fi
17348 rm -f conftest*
17349 fi
17350
17351 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17352   echo "$ac_t""yes" 1>&6
17353     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17354   cat >> confdefs.h <<EOF
17355 #define $ac_tr_func 1
17356 EOF
17357
17358 else
17359   echo "$ac_t""no" 1>&6
17360 fi
17361 done
17362
17363 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
17364 echo "configure:17365: checking for working mmap" >&5
17365 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
17366   echo $ac_n "(cached) $ac_c" 1>&6
17367 else
17368   if test "$cross_compiling" = yes; then
17369   ac_cv_func_mmap_fixed_mapped=no
17370 else
17371   cat > conftest.$ac_ext <<EOF
17372 #line 17373 "configure"
17373 #include "confdefs.h"
17374
17375 /* Thanks to Mike Haertel and Jim Avera for this test.
17376    Here is a matrix of mmap possibilities:
17377         mmap private not fixed
17378         mmap private fixed at somewhere currently unmapped
17379         mmap private fixed at somewhere already mapped
17380         mmap shared not fixed
17381         mmap shared fixed at somewhere currently unmapped
17382         mmap shared fixed at somewhere already mapped
17383    For private mappings, we should verify that changes cannot be read()
17384    back from the file, nor mmap's back from the file at a different
17385    address.  (There have been systems where private was not correctly
17386    implemented like the infamous i386 svr4.0, and systems where the
17387    VM page cache was not coherent with the filesystem buffer cache
17388    like early versions of FreeBSD and possibly contemporary NetBSD.)
17389    For shared mappings, we should conversely verify that changes get
17390    propogated back to all the places they're supposed to be.
17391
17392    Grep wants private fixed already mapped.
17393    The main things grep needs to know about mmap are:
17394    * does it exist and is it safe to write into the mmap'd area
17395    * how to use it (BSD variants)  */
17396 #include <sys/types.h>
17397 #include <fcntl.h>
17398 #include <sys/mman.h>
17399
17400 /* This mess was copied from the GNU getpagesize.h.  */
17401 #ifndef HAVE_GETPAGESIZE
17402 # ifdef HAVE_UNISTD_H
17403 #  include <unistd.h>
17404 # endif
17405
17406 /* Assume that all systems that can run configure have sys/param.h.  */
17407 # ifndef HAVE_SYS_PARAM_H
17408 #  define HAVE_SYS_PARAM_H 1
17409 # endif
17410
17411 # ifdef _SC_PAGESIZE
17412 #  define getpagesize() sysconf(_SC_PAGESIZE)
17413 # else /* no _SC_PAGESIZE */
17414 #  ifdef HAVE_SYS_PARAM_H
17415 #   include <sys/param.h>
17416 #   ifdef EXEC_PAGESIZE
17417 #    define getpagesize() EXEC_PAGESIZE
17418 #   else /* no EXEC_PAGESIZE */
17419 #    ifdef NBPG
17420 #     define getpagesize() NBPG * CLSIZE
17421 #     ifndef CLSIZE
17422 #      define CLSIZE 1
17423 #     endif /* no CLSIZE */
17424 #    else /* no NBPG */
17425 #     ifdef NBPC
17426 #      define getpagesize() NBPC
17427 #     else /* no NBPC */
17428 #      ifdef PAGESIZE
17429 #       define getpagesize() PAGESIZE
17430 #      endif /* PAGESIZE */
17431 #     endif /* no NBPC */
17432 #    endif /* no NBPG */
17433 #   endif /* no EXEC_PAGESIZE */
17434 #  else /* no HAVE_SYS_PARAM_H */
17435 #   define getpagesize() 8192   /* punt totally */
17436 #  endif /* no HAVE_SYS_PARAM_H */
17437 # endif /* no _SC_PAGESIZE */
17438
17439 #endif /* no HAVE_GETPAGESIZE */
17440
17441 #ifdef __cplusplus
17442 extern "C" { void *malloc(unsigned); }
17443 #else
17444 char *malloc();
17445 #endif
17446
17447 int
17448 main()
17449 {
17450         char *data, *data2, *data3;
17451         int i, pagesize;
17452         int fd;
17453
17454         pagesize = getpagesize();
17455
17456         /*
17457          * First, make a file with some known garbage in it.
17458          */
17459         data = malloc(pagesize);
17460         if (!data)
17461                 exit(1);
17462         for (i = 0; i < pagesize; ++i)
17463                 *(data + i) = rand();
17464         umask(0);
17465         fd = creat("conftestmmap", 0600);
17466         if (fd < 0)
17467                 exit(1);
17468         if (write(fd, data, pagesize) != pagesize)
17469                 exit(1);
17470         close(fd);
17471
17472         /*
17473          * Next, try to mmap the file at a fixed address which
17474          * already has something else allocated at it.  If we can,
17475          * also make sure that we see the same garbage.
17476          */
17477         fd = open("conftestmmap", O_RDWR);
17478         if (fd < 0)
17479                 exit(1);
17480         data2 = malloc(2 * pagesize);
17481         if (!data2)
17482                 exit(1);
17483         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
17484         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
17485             MAP_PRIVATE | MAP_FIXED, fd, 0L))
17486                 exit(1);
17487         for (i = 0; i < pagesize; ++i)
17488                 if (*(data + i) != *(data2 + i))
17489                         exit(1);
17490
17491         /*
17492          * Finally, make sure that changes to the mapped area
17493          * do not percolate back to the file as seen by read().
17494          * (This is a bug on some variants of i386 svr4.0.)
17495          */
17496         for (i = 0; i < pagesize; ++i)
17497                 *(data2 + i) = *(data2 + i) + 1;
17498         data3 = malloc(pagesize);
17499         if (!data3)
17500                 exit(1);
17501         if (read(fd, data3, pagesize) != pagesize)
17502                 exit(1);
17503         for (i = 0; i < pagesize; ++i)
17504                 if (*(data + i) != *(data3 + i))
17505                         exit(1);
17506         close(fd);
17507         unlink("conftestmmap");
17508         exit(0);
17509 }
17510
17511 EOF
17512 if { (eval echo configure:17513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
17513 then
17514   ac_cv_func_mmap_fixed_mapped=yes
17515 else
17516   echo "configure: failed program was:" >&5
17517   cat conftest.$ac_ext >&5
17518   rm -fr conftest*
17519   ac_cv_func_mmap_fixed_mapped=no
17520 fi
17521 rm -fr conftest*
17522 fi
17523
17524 fi
17525
17526 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
17527 if test $ac_cv_func_mmap_fixed_mapped = yes; then
17528   cat >> confdefs.h <<\EOF
17529 #define HAVE_MMAP 1
17530 EOF
17531
17532 fi
17533
17534 fi
17535
17536
17537
17538 if test "$CANADIAN" = yes; then
17539   CANADIAN_TRUE=
17540   CANADIAN_FALSE='#'
17541 else
17542   CANADIAN_TRUE='#'
17543   CANADIAN_FALSE=
17544 fi
17545
17546
17547 if test "$NULL_TARGET" = yes; then
17548   NULL_TARGET_TRUE=
17549   NULL_TARGET_FALSE='#'
17550 else
17551   NULL_TARGET_TRUE='#'
17552   NULL_TARGET_FALSE=
17553 fi
17554
17555
17556 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
17557   NATIVE_TRUE=
17558   NATIVE_FALSE='#'
17559 else
17560   NATIVE_TRUE='#'
17561   NATIVE_FALSE=
17562 fi
17563
17564
17565 if test -z "$with_cross_host"; then
17566   USE_LIBDIR_TRUE=
17567   USE_LIBDIR_FALSE='#'
17568 else
17569   USE_LIBDIR_TRUE='#'
17570   USE_LIBDIR_FALSE=
17571 fi
17572
17573 if test $ac_cv_header_locale_h = yes; then
17574     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
17575 echo "configure:17576: checking for LC_MESSAGES" >&5
17576 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
17577   echo $ac_n "(cached) $ac_c" 1>&6
17578 else
17579   cat > conftest.$ac_ext <<EOF
17580 #line 17581 "configure"
17581 #include "confdefs.h"
17582 #include <locale.h>
17583 int main() {
17584 return LC_MESSAGES
17585 ; return 0; }
17586 EOF
17587 if { (eval echo configure:17588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17588   rm -rf conftest*
17589   ac_cv_val_LC_MESSAGES=yes
17590 else
17591   echo "configure: failed program was:" >&5
17592   cat conftest.$ac_ext >&5
17593   rm -rf conftest*
17594   ac_cv_val_LC_MESSAGES=no
17595 fi
17596 rm -f conftest*
17597 fi
17598
17599 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
17600     if test $ac_cv_val_LC_MESSAGES = yes; then
17601       cat >> confdefs.h <<\EOF
17602 #define HAVE_LC_MESSAGES 1
17603 EOF
17604
17605     fi
17606   fi
17607
17608
17609 # Sanity checking & User-visible messages.
17610 # Checks down here, otherwise they get scrolled off before
17611 # the user will notice.
17612 if test "$enable_namespaces" = "yes" && test "$enable_libgcc_rebuild" = "no"
17613 then
17614   echo "configure: warning: libgcc.a will not match mangled symbols unless it is rebuilt" 1>&2
17615 fi
17616 if test "$enable_namespaces" = "no" && test "$enable_libgcc_rebuild" != "no"
17617 then
17618   # Other things besides namespaces can make this true as well, but none
17619   # of them are done automatically... yet
17620   echo "configure: warning: no point in rebuilding libgcc.a if namespaces aren't used" 1>&2
17621 fi
17622
17623
17624 if test "${multilib}" = "yes"; then
17625   multilib_arg="--enable-multilib"
17626 else
17627   multilib_arg=
17628 fi
17629
17630
17631 # Generate the various Makefiles, include files, and scripts.
17632
17633 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
17634 # so that multilib installs will end up installed in the correct
17635 # place. To work around this not being passed down from config-ml.in
17636 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
17637 # append it here.
17638
17639 trap '' 1 2 15
17640 cat > confcache <<\EOF
17641 # This file is a shell script that caches the results of configure
17642 # tests run on this system so they can be shared between configure
17643 # scripts and configure runs.  It is not useful on other systems.
17644 # If it contains results you don't want to keep, you may remove or edit it.
17645 #
17646 # By default, configure uses ./config.cache as the cache file,
17647 # creating it if it does not exist already.  You can give configure
17648 # the --cache-file=FILE option to use a different cache file; that is
17649 # what configure does when it calls configure scripts in
17650 # subdirectories, so they share the cache.
17651 # Giving --cache-file=/dev/null disables caching, for debugging configure.
17652 # config.status only pays attention to the cache file if you give it the
17653 # --recheck option to rerun configure.
17654 #
17655 EOF
17656 # The following way of writing the cache mishandles newlines in values,
17657 # but we know of no workaround that is simple, portable, and efficient.
17658 # So, don't put newlines in cache variables' values.
17659 # Ultrix sh set writes to stderr and can't be redirected directly,
17660 # and sets the high bit in the cache file unless we assign to the vars.
17661 (set) 2>&1 |
17662   case `(ac_space=' '; set | grep ac_space) 2>&1` in
17663   *ac_space=\ *)
17664     # `set' does not quote correctly, so add quotes (double-quote substitution
17665     # turns \\\\ into \\, and sed turns \\ into \).
17666     sed -n \
17667       -e "s/'/'\\\\''/g" \
17668       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
17669     ;;
17670   *)
17671     # `set' quotes correctly as required by POSIX, so do not add quotes.
17672     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
17673     ;;
17674   esac >> confcache
17675 if cmp -s $cache_file confcache; then
17676   :
17677 else
17678   if test -w $cache_file; then
17679     echo "updating cache $cache_file"
17680     cat confcache > $cache_file
17681   else
17682     echo "not updating unwritable cache $cache_file"
17683   fi
17684 fi
17685 rm -f confcache
17686
17687 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
17688
17689 test "x$prefix" = xNONE && prefix=$ac_default_prefix
17690 # Let make expand exec_prefix.
17691 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
17692
17693 # Any assignment to VPATH causes Sun make to only execute
17694 # the first set of double-colon rules, so remove it if not needed.
17695 # If there is a colon in the path, we need to keep it.
17696 if test "x$srcdir" = x.; then
17697   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
17698 fi
17699
17700 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
17701
17702 DEFS=-DHAVE_CONFIG_H
17703
17704 # Without the "./", some shells look in PATH for config.status.
17705 : ${CONFIG_STATUS=./config.status}
17706
17707 echo creating $CONFIG_STATUS
17708 rm -f $CONFIG_STATUS
17709 cat > $CONFIG_STATUS <<EOF
17710 #! /bin/sh
17711 # Generated automatically by configure.
17712 # Run this file to recreate the current configuration.
17713 # This directory was configured as follows,
17714 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
17715 #
17716 # $0 $ac_configure_args
17717 #
17718 # Compiler output produced by configure, useful for debugging
17719 # configure, is in ./config.log if it exists.
17720
17721 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
17722 for ac_option
17723 do
17724   case "\$ac_option" in
17725   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
17726     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
17727     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
17728   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
17729     echo "$CONFIG_STATUS generated by autoconf version 2.13"
17730     exit 0 ;;
17731   -help | --help | --hel | --he | --h)
17732     echo "\$ac_cs_usage"; exit 0 ;;
17733   *) echo "\$ac_cs_usage"; exit 1 ;;
17734   esac
17735 done
17736
17737 ac_given_srcdir=$srcdir
17738 ac_given_INSTALL="$INSTALL"
17739
17740 trap 'rm -fr `echo "mkcheck Makefile src/Makefile math/Makefile libio/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
17741 EOF
17742 cat >> $CONFIG_STATUS <<EOF
17743
17744 # Protect against being on the right side of a sed subst in config.status.
17745 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
17746  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
17747 $ac_vpsub
17748 $extrasub
17749 s%@SHELL@%$SHELL%g
17750 s%@CFLAGS@%$CFLAGS%g
17751 s%@CPPFLAGS@%$CPPFLAGS%g
17752 s%@CXXFLAGS@%$CXXFLAGS%g
17753 s%@FFLAGS@%$FFLAGS%g
17754 s%@DEFS@%$DEFS%g
17755 s%@LDFLAGS@%$LDFLAGS%g
17756 s%@LIBS@%$LIBS%g
17757 s%@exec_prefix@%$exec_prefix%g
17758 s%@prefix@%$prefix%g
17759 s%@program_transform_name@%$program_transform_name%g
17760 s%@bindir@%$bindir%g
17761 s%@sbindir@%$sbindir%g
17762 s%@libexecdir@%$libexecdir%g
17763 s%@datadir@%$datadir%g
17764 s%@sysconfdir@%$sysconfdir%g
17765 s%@sharedstatedir@%$sharedstatedir%g
17766 s%@localstatedir@%$localstatedir%g
17767 s%@libdir@%$libdir%g
17768 s%@includedir@%$includedir%g
17769 s%@oldincludedir@%$oldincludedir%g
17770 s%@infodir@%$infodir%g
17771 s%@mandir@%$mandir%g
17772 s%@host@%$host%g
17773 s%@host_alias@%$host_alias%g
17774 s%@host_cpu@%$host_cpu%g
17775 s%@host_vendor@%$host_vendor%g
17776 s%@host_os@%$host_os%g
17777 s%@target@%$target%g
17778 s%@target_alias@%$target_alias%g
17779 s%@target_cpu@%$target_cpu%g
17780 s%@target_vendor@%$target_vendor%g
17781 s%@target_os@%$target_os%g
17782 s%@build@%$build%g
17783 s%@build_alias@%$build_alias%g
17784 s%@build_cpu@%$build_cpu%g
17785 s%@build_vendor@%$build_vendor%g
17786 s%@build_os@%$build_os%g
17787 s%@glibcpp_basedir@%$glibcpp_basedir%g
17788 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
17789 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
17790 s%@INSTALL_DATA@%$INSTALL_DATA%g
17791 s%@PACKAGE@%$PACKAGE%g
17792 s%@VERSION@%$VERSION%g
17793 s%@ACLOCAL@%$ACLOCAL%g
17794 s%@AUTOCONF@%$AUTOCONF%g
17795 s%@AUTOMAKE@%$AUTOMAKE%g
17796 s%@AUTOHEADER@%$AUTOHEADER%g
17797 s%@MAKEINFO@%$MAKEINFO%g
17798 s%@SET_MAKE@%$SET_MAKE%g
17799 s%@CC@%$CC%g
17800 s%@CXX@%$CXX%g
17801 s%@AS@%$AS%g
17802 s%@AR@%$AR%g
17803 s%@RANLIB@%$RANLIB%g
17804 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
17805 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
17806 s%@MAINT@%$MAINT%g
17807 s%@EXEEXT@%$EXEEXT%g
17808 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
17809 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
17810 s%@LN_S@%$LN_S%g
17811 s%@LIBTOOL@%$LIBTOOL%g
17812 s%@CPP@%$CPP%g
17813 s%@cpu_include_dir@%$cpu_include_dir%g
17814 s%@CPU_FLAGS@%$CPU_FLAGS%g
17815 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
17816 s%@BUILD_LIBIO_INCLUDE@%$BUILD_LIBIO_INCLUDE%g
17817 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE%g
17818 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE%g
17819 s%@CSTDIO_H@%$CSTDIO_H%g
17820 s%@CSTDIO_CC@%$CSTDIO_CC%g
17821 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
17822 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
17823 s%@CSHADOWFLAGS@%$CSHADOWFLAGS%g
17824 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
17825 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
17826 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
17827 s%@THREADLIBS@%$THREADLIBS%g
17828 s%@THREADINCS@%$THREADINCS%g
17829 s%@THREADDEPS@%$THREADDEPS%g
17830 s%@THREADOBJS@%$THREADOBJS%g
17831 s%@THREADSPEC@%$THREADSPEC%g
17832 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
17833 s%@ctype_include_dir@%$ctype_include_dir%g
17834 s%@WERROR@%$WERROR%g
17835 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
17836 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
17837 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
17838 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
17839 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
17840 s%@libinst_wstring_la@%$libinst_wstring_la%g
17841 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
17842 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
17843 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
17844 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
17845 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
17846 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
17847 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
17848 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
17849
17850 CEOF
17851 EOF
17852
17853 cat >> $CONFIG_STATUS <<\EOF
17854
17855 # Split the substitutions into bite-sized pieces for seds with
17856 # small command number limits, like on Digital OSF/1 and HP-UX.
17857 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
17858 ac_file=1 # Number of current file.
17859 ac_beg=1 # First line for current file.
17860 ac_end=$ac_max_sed_cmds # Line after last line for current file.
17861 ac_more_lines=:
17862 ac_sed_cmds=""
17863 while $ac_more_lines; do
17864   if test $ac_beg -gt 1; then
17865     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
17866   else
17867     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
17868   fi
17869   if test ! -s conftest.s$ac_file; then
17870     ac_more_lines=false
17871     rm -f conftest.s$ac_file
17872   else
17873     if test -z "$ac_sed_cmds"; then
17874       ac_sed_cmds="sed -f conftest.s$ac_file"
17875     else
17876       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
17877     fi
17878     ac_file=`expr $ac_file + 1`
17879     ac_beg=$ac_end
17880     ac_end=`expr $ac_end + $ac_max_sed_cmds`
17881   fi
17882 done
17883 if test -z "$ac_sed_cmds"; then
17884   ac_sed_cmds=cat
17885 fi
17886 EOF
17887
17888 cat >> $CONFIG_STATUS <<EOF
17889
17890 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile math/Makefile libio/Makefile"}
17891 EOF
17892 cat >> $CONFIG_STATUS <<\EOF
17893 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
17894   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17895   case "$ac_file" in
17896   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17897        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17898   *) ac_file_in="${ac_file}.in" ;;
17899   esac
17900
17901   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
17902
17903   # Remove last slash and all that follows it.  Not all systems have dirname.
17904   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17905   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17906     # The file is in a subdirectory.
17907     test ! -d "$ac_dir" && mkdir "$ac_dir"
17908     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
17909     # A "../" for each directory in $ac_dir_suffix.
17910     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
17911   else
17912     ac_dir_suffix= ac_dots=
17913   fi
17914
17915   case "$ac_given_srcdir" in
17916   .)  srcdir=.
17917       if test -z "$ac_dots"; then top_srcdir=.
17918       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
17919   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
17920   *) # Relative path.
17921     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
17922     top_srcdir="$ac_dots$ac_given_srcdir" ;;
17923   esac
17924
17925   case "$ac_given_INSTALL" in
17926   [/$]*) INSTALL="$ac_given_INSTALL" ;;
17927   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
17928   esac
17929
17930   echo creating "$ac_file"
17931   rm -f "$ac_file"
17932   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
17933   case "$ac_file" in
17934   *Makefile*) ac_comsub="1i\\
17935 # $configure_input" ;;
17936   *) ac_comsub= ;;
17937   esac
17938
17939   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17940   sed -e "$ac_comsub
17941 s%@configure_input@%$configure_input%g
17942 s%@srcdir@%$srcdir%g
17943 s%@top_srcdir@%$top_srcdir%g
17944 s%@INSTALL@%$INSTALL%g
17945 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
17946 fi; done
17947 rm -f conftest.s*
17948
17949 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
17950 # NAME is the cpp macro being defined and VALUE is the value it is being given.
17951 #
17952 # ac_d sets the value in "#define NAME VALUE" lines.
17953 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
17954 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
17955 ac_dC='\3'
17956 ac_dD='%g'
17957 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
17958 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17959 ac_uB='\([      ]\)%\1#\2define\3'
17960 ac_uC=' '
17961 ac_uD='\4%g'
17962 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
17963 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17964 ac_eB='$%\1#\2define\3'
17965 ac_eC=' '
17966 ac_eD='%g'
17967
17968 if test "${CONFIG_HEADERS+set}" != set; then
17969 EOF
17970 cat >> $CONFIG_STATUS <<EOF
17971   CONFIG_HEADERS="config.h"
17972 EOF
17973 cat >> $CONFIG_STATUS <<\EOF
17974 fi
17975 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
17976   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17977   case "$ac_file" in
17978   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17979        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17980   *) ac_file_in="${ac_file}.in" ;;
17981   esac
17982
17983   echo creating $ac_file
17984
17985   rm -f conftest.frag conftest.in conftest.out
17986   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17987   cat $ac_file_inputs > conftest.in
17988
17989 EOF
17990
17991 # Transform confdefs.h into a sed script conftest.vals that substitutes
17992 # the proper values into config.h.in to produce config.h.  And first:
17993 # Protect against being on the right side of a sed subst in config.status.
17994 # Protect against being in an unquoted here document in config.status.
17995 rm -f conftest.vals
17996 cat > conftest.hdr <<\EOF
17997 s/[\\&%]/\\&/g
17998 s%[\\$`]%\\&%g
17999 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
18000 s%ac_d%ac_u%gp
18001 s%ac_u%ac_e%gp
18002 EOF
18003 sed -n -f conftest.hdr confdefs.h > conftest.vals
18004 rm -f conftest.hdr
18005
18006 # This sed command replaces #undef with comments.  This is necessary, for
18007 # example, in the case of _POSIX_SOURCE, which is predefined and required
18008 # on some systems where configure will not decide to define it.
18009 cat >> conftest.vals <<\EOF
18010 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
18011 EOF
18012
18013 # Break up conftest.vals because some shells have a limit on
18014 # the size of here documents, and old seds have small limits too.
18015
18016 rm -f conftest.tail
18017 while :
18018 do
18019   ac_lines=`grep -c . conftest.vals`
18020   # grep -c gives empty output for an empty file on some AIX systems.
18021   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
18022   # Write a limited-size here document to conftest.frag.
18023   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
18024   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
18025   echo 'CEOF
18026   sed -f conftest.frag conftest.in > conftest.out
18027   rm -f conftest.in
18028   mv conftest.out conftest.in
18029 ' >> $CONFIG_STATUS
18030   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
18031   rm -f conftest.vals
18032   mv conftest.tail conftest.vals
18033 done
18034 rm -f conftest.vals
18035
18036 cat >> $CONFIG_STATUS <<\EOF
18037   rm -f conftest.frag conftest.h
18038   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
18039   cat conftest.in >> conftest.h
18040   rm -f conftest.in
18041   if cmp -s $ac_file conftest.h 2>/dev/null; then
18042     echo "$ac_file is unchanged"
18043     rm -f conftest.h
18044   else
18045     # Remove last slash and all that follows it.  Not all systems have dirname.
18046       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
18047       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
18048       # The file is in a subdirectory.
18049       test ! -d "$ac_dir" && mkdir "$ac_dir"
18050     fi
18051     rm -f $ac_file
18052     mv conftest.h $ac_file
18053   fi
18054 fi; done
18055
18056 EOF
18057 cat >> $CONFIG_STATUS <<EOF
18058
18059 srcdir=${srcdir}
18060 host=${host}
18061 target=${target}
18062 with_multisubdir=${with_multisubdir}
18063 ac_configure_args="${multilib_arg} ${ac_configure_args}"
18064 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
18065 glibcpp_basedir=${glibcpp_basedir}
18066 CC="${CC}"
18067 CXX="${CXX}"
18068
18069 EOF
18070 cat >> $CONFIG_STATUS <<\EOF
18071 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
18072 if test -n "$CONFIG_FILES"; then
18073   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
18074   grep '^MULTISUBDIR =' Makefile >> src/Makefile
18075 fi
18076 exit 0
18077 EOF
18078 chmod +x $CONFIG_STATUS
18079 rm -fr confdefs* $ac_clean_files
18080 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
18081
18082
18083
18084 blddir=`pwd`
18085 # Generate mkcheck having execute privs
18086
18087
18088 # Generate bits/c++config.h
18089 # NB: This must be the first generated file as others include it. . .
18090
18091
18092 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
18093
18094
18095 # Generate bits/c++threads.h
18096
18097
18098 # Generate bits/c++io.h and src/c++io.cc
18099
18100
18101 chmod +x $blddir/mkcheck
18102 $srcdir/mkc++config $blddir $srcdir
18103 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
18104 cp $srcdir/config/$THREADH $blddir/bits/c++threads.h
18105 cp $srcdir/config/$CSTDIO_H $blddir/bits/c++io.h
18106 cp $srcdir/config/$CSTDIO_CC $blddir/src/c++io.cc
18107
18108
18109
18110
18111
18112