libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --enable-debug          extra debugging, turn off optimization [default=no]"
  36 ac_help="$ac_help
  37   --enable-cstdio         enable GNU libio for target io package. (default)
  38   --enable-cstdio=LIB     use LIB target-speific io package."
  39 ac_help="$ac_help
  40   --enable-long-long      turns on 'long long' [default=yes]"
  41 ac_help="$ac_help
  42   --enable-cshadow-headers construct "shadowed" C header files for
  43                            g++ [default=no]"
  44 ac_help="$ac_help
  45   --enable-threads        enable thread usage for target GCC.
  46   --enable-threads=LIB    use LIB thread package for target GCC."
  47 ac_help="$ac_help
  48   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  49                                 [default=none]"
  50
  51 # Initialize some variables set by options.
  52 # The variables have the same names as the options, with
  53 # dashes changed to underlines.
  54 build=NONE
  55 cache_file=./config.cache
  56 exec_prefix=NONE
  57 host=NONE
  58 no_create=
  59 nonopt=NONE
  60 no_recursion=
  61 prefix=NONE
  62 program_prefix=NONE
  63 program_suffix=NONE
  64 program_transform_name=s,x,x,
  65 silent=
  66 site=
  67 sitefile=
  68 srcdir=
  69 target=NONE
  70 verbose=
  71 x_includes=NONE
  72 x_libraries=NONE
  73 bindir='${exec_prefix}/bin'
  74 sbindir='${exec_prefix}/sbin'
  75 libexecdir='${exec_prefix}/libexec'
  76 datadir='${prefix}/share'
  77 sysconfdir='${prefix}/etc'
  78 sharedstatedir='${prefix}/com'
  79 localstatedir='${prefix}/var'
  80 libdir='${exec_prefix}/lib'
  81 includedir='${prefix}/include'
  82 oldincludedir='/usr/include'
  83 infodir='${prefix}/info'
  84 mandir='${prefix}/man'
  85
  86 # Initialize some other variables.
  87 subdirs=
  88 MFLAGS= MAKEFLAGS=
  89 SHELL=${CONFIG_SHELL-/bin/sh}
  90 # Maximum number of lines to put in a shell here document.
  91 ac_max_here_lines=12
  92
  93 ac_prev=
  94 for ac_option
  95 do
  96
  97   # If the previous option needs an argument, assign it.
  98   if test -n "$ac_prev"; then
  99     eval "$ac_prev=\$ac_option"
 100     ac_prev=
 101     continue
 102   fi
 103
 104   case "$ac_option" in
 105   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 106   *) ac_optarg= ;;
 107   esac
 108
 109   # Accept the important Cygnus configure options, so we can diagnose typos.
 110
 111   case "$ac_option" in
 112
 113   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 114     ac_prev=bindir ;;
 115   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 116     bindir="$ac_optarg" ;;
 117
 118   -build | --build | --buil | --bui | --bu)
 119     ac_prev=build ;;
 120   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 121     build="$ac_optarg" ;;
 122
 123   -cache-file | --cache-file | --cache-fil | --cache-fi \
 124   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 125     ac_prev=cache_file ;;
 126   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 127   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 128     cache_file="$ac_optarg" ;;
 129
 130   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 131     ac_prev=datadir ;;
 132   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 133   | --da=*)
 134     datadir="$ac_optarg" ;;
 135
 136   -disable-* | --disable-*)
 137     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 138     # Reject names that are not valid shell variable names.
 139     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 140       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 141     fi
 142     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 143     eval "enable_${ac_feature}=no" ;;
 144
 145   -enable-* | --enable-*)
 146     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 147     # Reject names that are not valid shell variable names.
 148     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 149       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 150     fi
 151     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 152     case "$ac_option" in
 153       *=*) ;;
 154       *) ac_optarg=yes ;;
 155     esac
 156     eval "enable_${ac_feature}='$ac_optarg'" ;;
 157
 158   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 159   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 160   | --exec | --exe | --ex)
 161     ac_prev=exec_prefix ;;
 162   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 163   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 164   | --exec=* | --exe=* | --ex=*)
 165     exec_prefix="$ac_optarg" ;;
 166
 167   -gas | --gas | --ga | --g)
 168     # Obsolete; use --with-gas.
 169     with_gas=yes ;;
 170
 171   -help | --help | --hel | --he)
 172     # Omit some internal or obsolete options to make the list less imposing.
 173     # This message is too long to be a string in the A/UX 3.1 sh.
 174     cat << EOF
 175 Usage: configure [options] [host]
 176 Options: [defaults in brackets after descriptions]
 177 Configuration:
 178   --cache-file=FILE       cache test results in FILE
 179   --help                  print this message
 180   --no-create             do not create output files
 181   --quiet, --silent       do not print \`checking...' messages
 182   --site-file=FILE        use FILE as the site file
 183   --version               print the version of autoconf that created configure
 184 Directory and file names:
 185   --prefix=PREFIX         install architecture-independent files in PREFIX
 186                           [$ac_default_prefix]
 187   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 188                           [same as prefix]
 189   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 190   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 191   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 192   --datadir=DIR           read-only architecture-independent data in DIR
 193                           [PREFIX/share]
 194   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 195   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 196                           [PREFIX/com]
 197   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 198   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 199   --includedir=DIR        C header files in DIR [PREFIX/include]
 200   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 201   --infodir=DIR           info documentation in DIR [PREFIX/info]
 202   --mandir=DIR            man documentation in DIR [PREFIX/man]
 203   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 204   --program-prefix=PREFIX prepend PREFIX to installed program names
 205   --program-suffix=SUFFIX append SUFFIX to installed program names
 206   --program-transform-name=PROGRAM
 207                           run sed PROGRAM on installed program names
 208 EOF
 209     cat << EOF
 210 Host type:
 211   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 212   --host=HOST             configure for HOST [guessed]
 213   --target=TARGET         configure for TARGET [TARGET=HOST]
 214 Features and packages:
 215   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 216   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 217   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 218   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 219   --x-includes=DIR        X include files are in DIR
 220   --x-libraries=DIR       X library files are in DIR
 221 EOF
 222     if test -n "$ac_help"; then
 223       echo "--enable and --with options recognized:$ac_help"
 224     fi
 225     exit 0 ;;
 226
 227   -host | --host | --hos | --ho)
 228     ac_prev=host ;;
 229   -host=* | --host=* | --hos=* | --ho=*)
 230     host="$ac_optarg" ;;
 231
 232   -includedir | --includedir | --includedi | --included | --include \
 233   | --includ | --inclu | --incl | --inc)
 234     ac_prev=includedir ;;
 235   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 236   | --includ=* | --inclu=* | --incl=* | --inc=*)
 237     includedir="$ac_optarg" ;;
 238
 239   -infodir | --infodir | --infodi | --infod | --info | --inf)
 240     ac_prev=infodir ;;
 241   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 242     infodir="$ac_optarg" ;;
 243
 244   -libdir | --libdir | --libdi | --libd)
 245     ac_prev=libdir ;;
 246   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 247     libdir="$ac_optarg" ;;
 248
 249   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 250   | --libexe | --libex | --libe)
 251     ac_prev=libexecdir ;;
 252   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 253   | --libexe=* | --libex=* | --libe=*)
 254     libexecdir="$ac_optarg" ;;
 255
 256   -localstatedir | --localstatedir | --localstatedi | --localstated \
 257   | --localstate | --localstat | --localsta | --localst \
 258   | --locals | --local | --loca | --loc | --lo)
 259     ac_prev=localstatedir ;;
 260   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 261   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 262   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 263     localstatedir="$ac_optarg" ;;
 264
 265   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 266     ac_prev=mandir ;;
 267   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 268     mandir="$ac_optarg" ;;
 269
 270   -nfp | --nfp | --nf)
 271     # Obsolete; use --without-fp.
 272     with_fp=no ;;
 273
 274   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 275   | --no-cr | --no-c)
 276     no_create=yes ;;
 277
 278   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 279   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 280     no_recursion=yes ;;
 281
 282   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 283   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 284   | --oldin | --oldi | --old | --ol | --o)
 285     ac_prev=oldincludedir ;;
 286   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 287   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 288   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 289     oldincludedir="$ac_optarg" ;;
 290
 291   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 292     ac_prev=prefix ;;
 293   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 294     prefix="$ac_optarg" ;;
 295
 296   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 297   | --program-pre | --program-pr | --program-p)
 298     ac_prev=program_prefix ;;
 299   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 300   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 301     program_prefix="$ac_optarg" ;;
 302
 303   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 304   | --program-suf | --program-su | --program-s)
 305     ac_prev=program_suffix ;;
 306   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 307   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 308     program_suffix="$ac_optarg" ;;
 309
 310   -program-transform-name | --program-transform-name \
 311   | --program-transform-nam | --program-transform-na \
 312   | --program-transform-n | --program-transform- \
 313   | --program-transform | --program-transfor \
 314   | --program-transfo | --program-transf \
 315   | --program-trans | --program-tran \
 316   | --progr-tra | --program-tr | --program-t)
 317     ac_prev=program_transform_name ;;
 318   -program-transform-name=* | --program-transform-name=* \
 319   | --program-transform-nam=* | --program-transform-na=* \
 320   | --program-transform-n=* | --program-transform-=* \
 321   | --program-transform=* | --program-transfor=* \
 322   | --program-transfo=* | --program-transf=* \
 323   | --program-trans=* | --program-tran=* \
 324   | --progr-tra=* | --program-tr=* | --program-t=*)
 325     program_transform_name="$ac_optarg" ;;
 326
 327   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 328   | -silent | --silent | --silen | --sile | --sil)
 329     silent=yes ;;
 330
 331   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 332     ac_prev=sbindir ;;
 333   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 334   | --sbi=* | --sb=*)
 335     sbindir="$ac_optarg" ;;
 336
 337   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 338   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 339   | --sharedst | --shareds | --shared | --share | --shar \
 340   | --sha | --sh)
 341     ac_prev=sharedstatedir ;;
 342   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 343   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 344   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 345   | --sha=* | --sh=*)
 346     sharedstatedir="$ac_optarg" ;;
 347
 348   -site | --site | --sit)
 349     ac_prev=site ;;
 350   -site=* | --site=* | --sit=*)
 351     site="$ac_optarg" ;;
 352
 353   -site-file | --site-file | --site-fil | --site-fi | --site-f)
 354     ac_prev=sitefile ;;
 355   -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
 356     sitefile="$ac_optarg" ;;
 357
 358   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 359     ac_prev=srcdir ;;
 360   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 361     srcdir="$ac_optarg" ;;
 362
 363   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 364   | --syscon | --sysco | --sysc | --sys | --sy)
 365     ac_prev=sysconfdir ;;
 366   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 367   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 368     sysconfdir="$ac_optarg" ;;
 369
 370   -target | --target | --targe | --targ | --tar | --ta | --t)
 371     ac_prev=target ;;
 372   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 373     target="$ac_optarg" ;;
 374
 375   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 376     verbose=yes ;;
 377
 378   -version | --version | --versio | --versi | --vers)
 379     echo "configure generated by autoconf version 2.13"
 380     exit 0 ;;
 381
 382   -with-* | --with-*)
 383     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 384     # Reject names that are not valid shell variable names.
 385     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 386       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 387     fi
 388     ac_package=`echo $ac_package| sed 's/-/_/g'`
 389     case "$ac_option" in
 390       *=*) ;;
 391       *) ac_optarg=yes ;;
 392     esac
 393     eval "with_${ac_package}='$ac_optarg'" ;;
 394
 395   -without-* | --without-*)
 396     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 397     # Reject names that are not valid shell variable names.
 398     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 399       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 400     fi
 401     ac_package=`echo $ac_package| sed 's/-/_/g'`
 402     eval "with_${ac_package}=no" ;;
 403
 404   --x)
 405     # Obsolete; use --with-x.
 406     with_x=yes ;;
 407
 408   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 409   | --x-incl | --x-inc | --x-in | --x-i)
 410     ac_prev=x_includes ;;
 411   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 412   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 413     x_includes="$ac_optarg" ;;
 414
 415   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 416   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 417     ac_prev=x_libraries ;;
 418   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 419   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 420     x_libraries="$ac_optarg" ;;
 421
 422   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 423     ;;
 424
 425   *)
 426     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 427       echo "configure: warning: $ac_option: invalid host type" 1>&2
 428     fi
 429     if test "x$nonopt" != xNONE; then
 430       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 431     fi
 432     nonopt="$ac_option"
 433     ;;
 434
 435   esac
 436 done
 437
 438 if test -n "$ac_prev"; then
 439   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 440 fi
 441
 442 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 443
 444 # File descriptor usage:
 445 # 0 standard input
 446 # 1 file creation
 447 # 2 errors and warnings
 448 # 3 some systems may open it to /dev/tty
 449 # 4 used on the Kubota Titan
 450 # 6 checking for... messages and results
 451 # 5 compiler messages saved in config.log
 452 if test "$silent" = yes; then
 453   exec 6>/dev/null
 454 else
 455   exec 6>&1
 456 fi
 457 exec 5>./config.log
 458
 459 echo "\
 460 This file contains any messages produced by compilers while
 461 running configure, to aid debugging if configure makes a mistake.
 462 " 1>&5
 463
 464 # Strip out --no-create and --no-recursion so they do not pile up.
 465 # Also quote any args containing shell metacharacters.
 466 ac_configure_args=
 467 for ac_arg
 468 do
 469   case "$ac_arg" in
 470   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 471   | --no-cr | --no-c) ;;
 472   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 473   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 474   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 475   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 476   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 477   esac
 478 done
 479
 480 # NLS nuisances.
 481 # Only set these to C if already set.  These must not be set unconditionally
 482 # because not all systems understand e.g. LANG=C (notably SCO).
 483 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 484 # Non-C LC_CTYPE values break the ctype check.
 485 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 486 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 487 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 488 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 489
 490 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 491 rm -rf conftest* confdefs.h
 492 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 493 echo > confdefs.h
 494
 495 # A filename unique to this package, relative to the directory that
 496 # configure is in, which we can look for to find out if srcdir is correct.
 497 ac_unique_file=src/complex.cc
 498
 499 # Find the source files, if location was not specified.
 500 if test -z "$srcdir"; then
 501   ac_srcdir_defaulted=yes
 502   # Try the directory containing this script, then its parent.
 503   ac_prog=$0
 504   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 505   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 506   srcdir=$ac_confdir
 507   if test ! -r $srcdir/$ac_unique_file; then
 508     srcdir=..
 509   fi
 510 else
 511   ac_srcdir_defaulted=no
 512 fi
 513 if test ! -r $srcdir/$ac_unique_file; then
 514   if test "$ac_srcdir_defaulted" = yes; then
 515     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 516   else
 517     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 518   fi
 519 fi
 520 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 521
 522 # Prefer explicitly selected file to automatically selected ones.
 523 if test -z "$sitefile"; then
 524   if test -z "$CONFIG_SITE"; then
 525     if test "x$prefix" != xNONE; then
 526       CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527     else
 528       CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529     fi
 530   fi
 531 else
 532   CONFIG_SITE="$sitefile"
 533 fi
 534 for ac_site_file in $CONFIG_SITE; do
 535   if test -r "$ac_site_file"; then
 536     echo "loading site script $ac_site_file"
 537     . "$ac_site_file"
 538   fi
 539 done
 540
 541 if test -r "$cache_file"; then
 542   echo "loading cache $cache_file"
 543   . $cache_file
 544 else
 545   echo "creating cache $cache_file"
 546   > $cache_file
 547 fi
 548
 549 ac_ext=c
 550 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 551 ac_cpp='$CPP $CPPFLAGS'
 552 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 553 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 554 cross_compiling=$ac_cv_prog_cc_cross
 555
 556 ac_exeext=
 557 ac_objext=o
 558 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 559   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 560   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 561     ac_n= ac_c='
 562 ' ac_t='        '
 563   else
 564     ac_n=-n ac_c= ac_t=
 565   fi
 566 else
 567   ac_n= ac_c='\c' ac_t=
 568 fi
 569
 570
 571 ac_aux_dir=
 572 for ac_dir in .. $srcdir/..; do
 573   if test -f $ac_dir/install-sh; then
 574     ac_aux_dir=$ac_dir
 575     ac_install_sh="$ac_aux_dir/install-sh -c"
 576     break
 577   elif test -f $ac_dir/install.sh; then
 578     ac_aux_dir=$ac_dir
 579     ac_install_sh="$ac_aux_dir/install.sh -c"
 580     break
 581   fi
 582 done
 583 if test -z "$ac_aux_dir"; then
 584   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 585 fi
 586 ac_config_guess=$ac_aux_dir/config.guess
 587 ac_config_sub=$ac_aux_dir/config.sub
 588 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 589
 590
 591 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 592
 593 # Do some error checking and defaulting for the host and target type.
 594 # The inputs are:
 595 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 596 #
 597 # The rules are:
 598 # 1. You are not allowed to specify --host, --target, and nonopt at the
 599 #    same time.
 600 # 2. Host defaults to nonopt.
 601 # 3. If nonopt is not specified, then host defaults to the current host,
 602 #    as determined by config.guess.
 603 # 4. Target and build default to nonopt.
 604 # 5. If nonopt is not specified, then target and build default to host.
 605
 606 # The aliases save the names the user supplied, while $host etc.
 607 # will get canonicalized.
 608 case $host---$target---$nonopt in
 609 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 610 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 611 esac
 612
 613
 614 # Make sure we can run config.sub.
 615 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 616 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 617 fi
 618
 619 echo $ac_n "checking host system type""... $ac_c" 1>&6
 620 echo "configure:621: checking host system type" >&5
 621
 622 host_alias=$host
 623 case "$host_alias" in
 624 NONE)
 625   case $nonopt in
 626   NONE)
 627     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 628     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 629     fi ;;
 630   *) host_alias=$nonopt ;;
 631   esac ;;
 632 esac
 633
 634 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 635 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 636 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 637 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 638 echo "$ac_t""$host" 1>&6
 639
 640 echo $ac_n "checking target system type""... $ac_c" 1>&6
 641 echo "configure:642: checking target system type" >&5
 642
 643 target_alias=$target
 644 case "$target_alias" in
 645 NONE)
 646   case $nonopt in
 647   NONE) target_alias=$host_alias ;;
 648   *) target_alias=$nonopt ;;
 649   esac ;;
 650 esac
 651
 652 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 653 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 654 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 655 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 656 echo "$ac_t""$target" 1>&6
 657
 658 echo $ac_n "checking build system type""... $ac_c" 1>&6
 659 echo "configure:660: checking build system type" >&5
 660
 661 build_alias=$build
 662 case "$build_alias" in
 663 NONE)
 664   case $nonopt in
 665   NONE) build_alias=$host_alias ;;
 666   *) build_alias=$nonopt ;;
 667   esac ;;
 668 esac
 669
 670 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 671 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 672 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 673 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 674 echo "$ac_t""$build" 1>&6
 675
 676 test "$host_alias" != "$target_alias" &&
 677   test "$program_prefix$program_suffix$program_transform_name" = \
 678     NONENONEs,x,x, &&
 679   program_prefix=${target_alias}-
 680
 681
 682 # We use these options to decide which functions to include.
 683 # Check whether --with-target-subdir or --without-target-subdir was given.
 684 if test "${with_target_subdir+set}" = set; then
 685   withval="$with_target_subdir"
 686   :
 687 fi
 688
 689 # Check whether --with-cross-host or --without-cross-host was given.
 690 if test "${with_cross_host+set}" = set; then
 691   withval="$with_cross_host"
 692   :
 693 fi
 694
 695
 696 # Find a good install program.  We prefer a C program (faster),
 697 # so one script is as good as another.  But avoid the broken or
 698 # incompatible versions:
 699 # SysV /etc/install, /usr/sbin/install
 700 # SunOS /usr/etc/install
 701 # IRIX /sbin/install
 702 # AIX /bin/install
 703 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 704 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 705 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 706 # ./install, which can be erroneously created by make from ./install.sh.
 707 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 708 echo "configure:709: checking for a BSD compatible install" >&5
 709 if test -z "$INSTALL"; then
 710 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 711   echo $ac_n "(cached) $ac_c" 1>&6
 712 else
 713     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 714   for ac_dir in $PATH; do
 715     # Account for people who put trailing slashes in PATH elements.
 716     case "$ac_dir/" in
 717     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 718     *)
 719       # OSF1 and SCO ODT 3.0 have their own names for install.
 720       # Don't use installbsd from OSF since it installs stuff as root
 721       # by default.
 722       for ac_prog in ginstall scoinst install; do
 723         if test -f $ac_dir/$ac_prog; then
 724           if test $ac_prog = install &&
 725             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 726             # AIX install.  It has an incompatible calling convention.
 727             :
 728           else
 729             ac_cv_path_install="$ac_dir/$ac_prog -c"
 730             break 2
 731           fi
 732         fi
 733       done
 734       ;;
 735     esac
 736   done
 737   IFS="$ac_save_IFS"
 738
 739 fi
 740   if test "${ac_cv_path_install+set}" = set; then
 741     INSTALL="$ac_cv_path_install"
 742   else
 743     # As a last resort, use the slow shell script.  We don't cache a
 744     # path for INSTALL within a source directory, because that will
 745     # break other packages using the cache if that directory is
 746     # removed, or if the path is relative.
 747     INSTALL="$ac_install_sh"
 748   fi
 749 fi
 750 echo "$ac_t""$INSTALL" 1>&6
 751
 752 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 753 # It thinks the first close brace ends the variable substitution.
 754 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 755
 756 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 757
 758 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 759
 760 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 761 echo "configure:762: checking whether build environment is sane" >&5
 762 # Just in case
 763 sleep 1
 764 echo timestamp > conftestfile
 765 # Do `set' in a subshell so we don't clobber the current shell's
 766 # arguments.  Must try -L first in case configure is actually a
 767 # symlink; some systems play weird games with the mod time of symlinks
 768 # (eg FreeBSD returns the mod time of the symlink's containing
 769 # directory).
 770 if (
 771    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 772    if test "$*" = "X"; then
 773       # -L didn't work.
 774       set X `ls -t $srcdir/configure conftestfile`
 775    fi
 776    if test "$*" != "X $srcdir/configure conftestfile" \
 777       && test "$*" != "X conftestfile $srcdir/configure"; then
 778
 779       # If neither matched, then we have a broken ls.  This can happen
 780       # if, for instance, CONFIG_SHELL is bash and it inherits a
 781       # broken ls alias from the environment.  This has actually
 782       # happened.  Such a system could not be considered "sane".
 783       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 784 alias in your environment" 1>&2; exit 1; }
 785    fi
 786
 787    test "$2" = conftestfile
 788    )
 789 then
 790    # Ok.
 791    :
 792 else
 793    { echo "configure: error: newly created file is older than distributed files!
 794 Check your system clock" 1>&2; exit 1; }
 795 fi
 796 rm -f conftest*
 797 echo "$ac_t""yes" 1>&6
 798 if test "$program_transform_name" = s,x,x,; then
 799   program_transform_name=
 800 else
 801   # Double any \ or $.  echo might interpret backslashes.
 802   cat <<\EOF_SED > conftestsed
 803 s,\\,\\\\,g; s,\$,$$,g
 804 EOF_SED
 805   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 806   rm -f conftestsed
 807 fi
 808 test "$program_prefix" != NONE &&
 809   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 810 # Use a double $ so make ignores it.
 811 test "$program_suffix" != NONE &&
 812   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 813
 814 # sed with no file args requires a program.
 815 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 816
 817 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 818 echo "configure:819: checking whether ${MAKE-make} sets \${MAKE}" >&5
 819 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 820 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 821   echo $ac_n "(cached) $ac_c" 1>&6
 822 else
 823   cat > conftestmake <<\EOF
 824 all:
 825         @echo 'ac_maketemp="${MAKE}"'
 826 EOF
 827 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 828 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 829 if test -n "$ac_maketemp"; then
 830   eval ac_cv_prog_make_${ac_make}_set=yes
 831 else
 832   eval ac_cv_prog_make_${ac_make}_set=no
 833 fi
 834 rm -f conftestmake
 835 fi
 836 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 837   echo "$ac_t""yes" 1>&6
 838   SET_MAKE=
 839 else
 840   echo "$ac_t""no" 1>&6
 841   SET_MAKE="MAKE=${MAKE-make}"
 842 fi
 843
 844 if test $host != $build; then
 845   ac_tool_prefix=${host_alias}-
 846 else
 847   ac_tool_prefix=
 848 fi
 849
 850 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 851 echo "configure:852: checking for Cygwin environment" >&5
 852 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 853   echo $ac_n "(cached) $ac_c" 1>&6
 854 else
 855   cat > conftest.$ac_ext <<EOF
 856 #line 857 "configure"
 857 #include "confdefs.h"
 858
 859 int main() {
 860
 861 #ifndef __CYGWIN__
 862 #define __CYGWIN__ __CYGWIN32__
 863 #endif
 864 return __CYGWIN__;
 865 ; return 0; }
 866 EOF
 867 if { (eval echo configure:868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 868   rm -rf conftest*
 869   ac_cv_cygwin=yes
 870 else
 871   echo "configure: failed program was:" >&5
 872   cat conftest.$ac_ext >&5
 873   rm -rf conftest*
 874   ac_cv_cygwin=no
 875 fi
 876 rm -f conftest*
 877 rm -f conftest*
 878 fi
 879
 880 echo "$ac_t""$ac_cv_cygwin" 1>&6
 881 CYGWIN=
 882 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 883 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 884 echo "configure:885: checking for mingw32 environment" >&5
 885 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 886   echo $ac_n "(cached) $ac_c" 1>&6
 887 else
 888   cat > conftest.$ac_ext <<EOF
 889 #line 890 "configure"
 890 #include "confdefs.h"
 891
 892 int main() {
 893 return __MINGW32__;
 894 ; return 0; }
 895 EOF
 896 if { (eval echo configure:897: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 897   rm -rf conftest*
 898   ac_cv_mingw32=yes
 899 else
 900   echo "configure: failed program was:" >&5
 901   cat conftest.$ac_ext >&5
 902   rm -rf conftest*
 903   ac_cv_mingw32=no
 904 fi
 905 rm -f conftest*
 906 rm -f conftest*
 907 fi
 908
 909 echo "$ac_t""$ac_cv_mingw32" 1>&6
 910 MINGW32=
 911 test "$ac_cv_mingw32" = yes && MINGW32=yes
 912
 913     # Check whether --enable-multilib or --disable-multilib was given.
 914 if test "${enable_multilib+set}" = set; then
 915   enableval="$enable_multilib"
 916   case "${enableval}" in
 917     yes) multilib=yes ;;
 918     no)  multilib=no ;;
 919     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 920    esac
 921 else
 922   multilib=yes
 923 fi
 924
 925       if test "${srcdir}" = "."; then
 926     if test "${with_target_subdir}" != "."; then
 927       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 928     else
 929       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 930     fi
 931   else
 932     glibcpp_basedir="${srcdir}/."
 933   fi
 934
 935
 936
 937 # Make sure we can run config.sub.
 938 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 939 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 940 fi
 941
 942 echo $ac_n "checking host system type""... $ac_c" 1>&6
 943 echo "configure:944: checking host system type" >&5
 944
 945 host_alias=$host
 946 case "$host_alias" in
 947 NONE)
 948   case $nonopt in
 949   NONE)
 950     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 951     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 952     fi ;;
 953   *) host_alias=$nonopt ;;
 954   esac ;;
 955 esac
 956
 957 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 958 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 959 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 960 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 961 echo "$ac_t""$host" 1>&6
 962
 963
 964
 965 PACKAGE=libstdc++
 966
 967 VERSION=2.90.8
 968
 969 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 970   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 971 fi
 972 cat >> confdefs.h <<EOF
 973 #define PACKAGE "$PACKAGE"
 974 EOF
 975
 976 cat >> confdefs.h <<EOF
 977 #define VERSION "$VERSION"
 978 EOF
 979
 980
 981
 982 missing_dir=`cd $ac_aux_dir && pwd`
 983 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 984 echo "configure:985: checking for working aclocal" >&5
 985 # Run test in a subshell; some versions of sh will print an error if
 986 # an executable is not found, even if stderr is redirected.
 987 # Redirect stdin to placate older versions of autoconf.  Sigh.
 988 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 989    ACLOCAL=aclocal
 990    echo "$ac_t""found" 1>&6
 991 else
 992    ACLOCAL="$missing_dir/missing aclocal"
 993    echo "$ac_t""missing" 1>&6
 994 fi
 995
 996 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 997 echo "configure:998: checking for working autoconf" >&5
 998 # Run test in a subshell; some versions of sh will print an error if
 999 # an executable is not found, even if stderr is redirected.
1000 # Redirect stdin to placate older versions of autoconf.  Sigh.
1001 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
1002    AUTOCONF=autoconf
1003    echo "$ac_t""found" 1>&6
1004 else
1005    AUTOCONF="$missing_dir/missing autoconf"
1006    echo "$ac_t""missing" 1>&6
1007 fi
1008
1009 echo $ac_n "checking for working automake""... $ac_c" 1>&6
1010 echo "configure:1011: checking for working automake" >&5
1011 # Run test in a subshell; some versions of sh will print an error if
1012 # an executable is not found, even if stderr is redirected.
1013 # Redirect stdin to placate older versions of autoconf.  Sigh.
1014 if (automake --version) < /dev/null > /dev/null 2>&1; then
1015    AUTOMAKE=automake
1016    echo "$ac_t""found" 1>&6
1017 else
1018    AUTOMAKE="$missing_dir/missing automake"
1019    echo "$ac_t""missing" 1>&6
1020 fi
1021
1022 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
1023 echo "configure:1024: checking for working autoheader" >&5
1024 # Run test in a subshell; some versions of sh will print an error if
1025 # an executable is not found, even if stderr is redirected.
1026 # Redirect stdin to placate older versions of autoconf.  Sigh.
1027 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
1028    AUTOHEADER=autoheader
1029    echo "$ac_t""found" 1>&6
1030 else
1031    AUTOHEADER="$missing_dir/missing autoheader"
1032    echo "$ac_t""missing" 1>&6
1033 fi
1034
1035 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1036 echo "configure:1037: checking for working makeinfo" >&5
1037 # Run test in a subshell; some versions of sh will print an error if
1038 # an executable is not found, even if stderr is redirected.
1039 # Redirect stdin to placate older versions of autoconf.  Sigh.
1040 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1041    MAKEINFO=makeinfo
1042    echo "$ac_t""found" 1>&6
1043 else
1044    MAKEINFO="$missing_dir/missing makeinfo"
1045    echo "$ac_t""missing" 1>&6
1046 fi
1047
1048
1049
1050 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1051 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1052 # are probably using a cross compiler, which will not be able to fully
1053 # link an executable.  This should really be fixed in autoconf
1054 # itself.
1055
1056
1057
1058
1059 # Extract the first word of "gcc", so it can be a program name with args.
1060 set dummy gcc; ac_word=$2
1061 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1062 echo "configure:1063: checking for $ac_word" >&5
1063 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1064   echo $ac_n "(cached) $ac_c" 1>&6
1065 else
1066   if test -n "$CC"; then
1067   ac_cv_prog_CC="$CC" # Let the user override the test.
1068 else
1069   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1070   ac_dummy="$PATH"
1071   for ac_dir in $ac_dummy; do
1072     test -z "$ac_dir" && ac_dir=.
1073     if test -f $ac_dir/$ac_word; then
1074       ac_cv_prog_CC="gcc"
1075       break
1076     fi
1077   done
1078   IFS="$ac_save_ifs"
1079 fi
1080 fi
1081 CC="$ac_cv_prog_CC"
1082 if test -n "$CC"; then
1083   echo "$ac_t""$CC" 1>&6
1084 else
1085   echo "$ac_t""no" 1>&6
1086 fi
1087
1088 if test -z "$CC"; then
1089   # Extract the first word of "cc", so it can be a program name with args.
1090 set dummy cc; ac_word=$2
1091 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1092 echo "configure:1093: checking for $ac_word" >&5
1093 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1094   echo $ac_n "(cached) $ac_c" 1>&6
1095 else
1096   if test -n "$CC"; then
1097   ac_cv_prog_CC="$CC" # Let the user override the test.
1098 else
1099   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1100   ac_prog_rejected=no
1101   ac_dummy="$PATH"
1102   for ac_dir in $ac_dummy; do
1103     test -z "$ac_dir" && ac_dir=.
1104     if test -f $ac_dir/$ac_word; then
1105       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1106         ac_prog_rejected=yes
1107         continue
1108       fi
1109       ac_cv_prog_CC="cc"
1110       break
1111     fi
1112   done
1113   IFS="$ac_save_ifs"
1114 if test $ac_prog_rejected = yes; then
1115   # We found a bogon in the path, so make sure we never use it.
1116   set dummy $ac_cv_prog_CC
1117   shift
1118   if test $# -gt 0; then
1119     # We chose a different compiler from the bogus one.
1120     # However, it has the same basename, so the bogon will be chosen
1121     # first if we set CC to just the basename; use the full file name.
1122     shift
1123     set dummy "$ac_dir/$ac_word" "$@"
1124     shift
1125     ac_cv_prog_CC="$@"
1126   fi
1127 fi
1128 fi
1129 fi
1130 CC="$ac_cv_prog_CC"
1131 if test -n "$CC"; then
1132   echo "$ac_t""$CC" 1>&6
1133 else
1134   echo "$ac_t""no" 1>&6
1135 fi
1136
1137   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1138 fi
1139
1140 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1141 echo "configure:1142: checking whether we are using GNU C" >&5
1142 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1143   echo $ac_n "(cached) $ac_c" 1>&6
1144 else
1145   cat > conftest.c <<EOF
1146 #ifdef __GNUC__
1147   yes;
1148 #endif
1149 EOF
1150 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1151: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1151   ac_cv_prog_gcc=yes
1152 else
1153   ac_cv_prog_gcc=no
1154 fi
1155 fi
1156
1157 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1158
1159 if test $ac_cv_prog_gcc = yes; then
1160   GCC=yes
1161   ac_test_CFLAGS="${CFLAGS+set}"
1162   ac_save_CFLAGS="$CFLAGS"
1163   CFLAGS=
1164   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1165 echo "configure:1166: checking whether ${CC-cc} accepts -g" >&5
1166 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1167   echo $ac_n "(cached) $ac_c" 1>&6
1168 else
1169   echo 'void f(){}' > conftest.c
1170 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1171   ac_cv_prog_cc_g=yes
1172 else
1173   ac_cv_prog_cc_g=no
1174 fi
1175 rm -f conftest*
1176
1177 fi
1178
1179 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1180   if test "$ac_test_CFLAGS" = set; then
1181     CFLAGS="$ac_save_CFLAGS"
1182   elif test $ac_cv_prog_cc_g = yes; then
1183     CFLAGS="-g -O2"
1184   else
1185     CFLAGS="-O2"
1186   fi
1187 else
1188   GCC=
1189   test "${CFLAGS+set}" = set || CFLAGS="-g"
1190 fi
1191
1192
1193 # Likewise for AC_PROG_CXX.
1194
1195
1196
1197 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1198 do
1199 # Extract the first word of "$ac_prog", so it can be a program name with args.
1200 set dummy $ac_prog; ac_word=$2
1201 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1202 echo "configure:1203: checking for $ac_word" >&5
1203 if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
1204   echo $ac_n "(cached) $ac_c" 1>&6
1205 else
1206   if test -n "$CXX"; then
1207   ac_cv_prog_CXX="$CXX" # Let the user override the test.
1208 else
1209   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1210   ac_dummy="$PATH"
1211   for ac_dir in $ac_dummy; do
1212     test -z "$ac_dir" && ac_dir=.
1213     if test -f $ac_dir/$ac_word; then
1214       ac_cv_prog_CXX="$ac_prog"
1215       break
1216     fi
1217   done
1218   IFS="$ac_save_ifs"
1219 fi
1220 fi
1221 CXX="$ac_cv_prog_CXX"
1222 if test -n "$CXX"; then
1223   echo "$ac_t""$CXX" 1>&6
1224 else
1225   echo "$ac_t""no" 1>&6
1226 fi
1227
1228 test -n "$CXX" && break
1229 done
1230 test -n "$CXX" || CXX="gcc"
1231
1232 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1233
1234 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1235 echo "configure:1236: checking whether we are using GNU C++" >&5
1236 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1237   echo $ac_n "(cached) $ac_c" 1>&6
1238 else
1239   cat > conftest.C <<EOF
1240 #ifdef __GNUC__
1241   yes;
1242 #endif
1243 EOF
1244 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1245: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1245   ac_cv_prog_gxx=yes
1246 else
1247   ac_cv_prog_gxx=no
1248 fi
1249 fi
1250
1251 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1252
1253 if test $ac_cv_prog_gxx = yes; then
1254   GXX=yes
1255   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1256   ac_save_CXXFLAGS="$CXXFLAGS"
1257   CXXFLAGS=
1258   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1259 echo "configure:1260: checking whether ${CXX-g++} accepts -g" >&5
1260 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1261   echo $ac_n "(cached) $ac_c" 1>&6
1262 else
1263   echo 'void f(){}' > conftest.cc
1264 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1265   ac_cv_prog_cxx_g=yes
1266 else
1267   ac_cv_prog_cxx_g=no
1268 fi
1269 rm -f conftest*
1270
1271 fi
1272
1273 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1274   if test "$ac_test_CXXFLAGS" = set; then
1275     CXXFLAGS="$ac_save_CXXFLAGS"
1276   elif test $ac_cv_prog_cxx_g = yes; then
1277     CXXFLAGS="-g -O2"
1278   else
1279     CXXFLAGS="-O2"
1280   fi
1281 else
1282   GXX=
1283   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1284 fi
1285
1286
1287 # AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD).  If we dont
1288 # run it explicitly here, it will be run implicitly before
1289 # LIBGCJ_CONFIGURE, which doesn't work because that means that it will
1290 # be run before AC_CANONICAL_HOST.
1291 echo $ac_n "checking build system type""... $ac_c" 1>&6
1292 echo "configure:1293: checking build system type" >&5
1293
1294 build_alias=$build
1295 case "$build_alias" in
1296 NONE)
1297   case $nonopt in
1298   NONE) build_alias=$host_alias ;;
1299   *) build_alias=$nonopt ;;
1300   esac ;;
1301 esac
1302
1303 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
1304 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1305 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1306 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1307 echo "$ac_t""$build" 1>&6
1308
1309
1310 # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1311 set dummy ${ac_tool_prefix}as; ac_word=$2
1312 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1313 echo "configure:1314: checking for $ac_word" >&5
1314 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1315   echo $ac_n "(cached) $ac_c" 1>&6
1316 else
1317   if test -n "$AS"; then
1318   ac_cv_prog_AS="$AS" # Let the user override the test.
1319 else
1320   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1321   ac_dummy="$PATH"
1322   for ac_dir in $ac_dummy; do
1323     test -z "$ac_dir" && ac_dir=.
1324     if test -f $ac_dir/$ac_word; then
1325       ac_cv_prog_AS="${ac_tool_prefix}as"
1326       break
1327     fi
1328   done
1329   IFS="$ac_save_ifs"
1330   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1331 fi
1332 fi
1333 AS="$ac_cv_prog_AS"
1334 if test -n "$AS"; then
1335   echo "$ac_t""$AS" 1>&6
1336 else
1337   echo "$ac_t""no" 1>&6
1338 fi
1339
1340
1341
1342 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1343 set dummy ${ac_tool_prefix}ar; ac_word=$2
1344 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1345 echo "configure:1346: checking for $ac_word" >&5
1346 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1347   echo $ac_n "(cached) $ac_c" 1>&6
1348 else
1349   if test -n "$AR"; then
1350   ac_cv_prog_AR="$AR" # Let the user override the test.
1351 else
1352   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1353   ac_dummy="$PATH"
1354   for ac_dir in $ac_dummy; do
1355     test -z "$ac_dir" && ac_dir=.
1356     if test -f $ac_dir/$ac_word; then
1357       ac_cv_prog_AR="${ac_tool_prefix}ar"
1358       break
1359     fi
1360   done
1361   IFS="$ac_save_ifs"
1362   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1363 fi
1364 fi
1365 AR="$ac_cv_prog_AR"
1366 if test -n "$AR"; then
1367   echo "$ac_t""$AR" 1>&6
1368 else
1369   echo "$ac_t""no" 1>&6
1370 fi
1371
1372
1373
1374 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1375 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1376 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1377 echo "configure:1378: checking for $ac_word" >&5
1378 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1379   echo $ac_n "(cached) $ac_c" 1>&6
1380 else
1381   if test -n "$RANLIB"; then
1382   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1383 else
1384   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1385   ac_dummy="$PATH"
1386   for ac_dir in $ac_dummy; do
1387     test -z "$ac_dir" && ac_dir=.
1388     if test -f $ac_dir/$ac_word; then
1389       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1390       break
1391     fi
1392   done
1393   IFS="$ac_save_ifs"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403
1404 if test -z "$ac_cv_prog_RANLIB"; then
1405 if test -n "$ac_tool_prefix"; then
1406   # Extract the first word of "ranlib", so it can be a program name with args.
1407 set dummy ranlib; ac_word=$2
1408 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1409 echo "configure:1410: checking for $ac_word" >&5
1410 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1411   echo $ac_n "(cached) $ac_c" 1>&6
1412 else
1413   if test -n "$RANLIB"; then
1414   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1415 else
1416   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1417   ac_dummy="$PATH"
1418   for ac_dir in $ac_dummy; do
1419     test -z "$ac_dir" && ac_dir=.
1420     if test -f $ac_dir/$ac_word; then
1421       ac_cv_prog_RANLIB="ranlib"
1422       break
1423     fi
1424   done
1425   IFS="$ac_save_ifs"
1426   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1427 fi
1428 fi
1429 RANLIB="$ac_cv_prog_RANLIB"
1430 if test -n "$RANLIB"; then
1431   echo "$ac_t""$RANLIB" 1>&6
1432 else
1433   echo "$ac_t""no" 1>&6
1434 fi
1435
1436 else
1437   RANLIB=":"
1438 fi
1439 fi
1440
1441
1442 # Find a good install program.  We prefer a C program (faster),
1443 # so one script is as good as another.  But avoid the broken or
1444 # incompatible versions:
1445 # SysV /etc/install, /usr/sbin/install
1446 # SunOS /usr/etc/install
1447 # IRIX /sbin/install
1448 # AIX /bin/install
1449 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1450 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1451 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1452 # ./install, which can be erroneously created by make from ./install.sh.
1453 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1454 echo "configure:1455: checking for a BSD compatible install" >&5
1455 if test -z "$INSTALL"; then
1456 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1457   echo $ac_n "(cached) $ac_c" 1>&6
1458 else
1459     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1460   for ac_dir in $PATH; do
1461     # Account for people who put trailing slashes in PATH elements.
1462     case "$ac_dir/" in
1463     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1464     *)
1465       # OSF1 and SCO ODT 3.0 have their own names for install.
1466       # Don't use installbsd from OSF since it installs stuff as root
1467       # by default.
1468       for ac_prog in ginstall scoinst install; do
1469         if test -f $ac_dir/$ac_prog; then
1470           if test $ac_prog = install &&
1471             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1472             # AIX install.  It has an incompatible calling convention.
1473             :
1474           else
1475             ac_cv_path_install="$ac_dir/$ac_prog -c"
1476             break 2
1477           fi
1478         fi
1479       done
1480       ;;
1481     esac
1482   done
1483   IFS="$ac_save_IFS"
1484
1485 fi
1486   if test "${ac_cv_path_install+set}" = set; then
1487     INSTALL="$ac_cv_path_install"
1488   else
1489     # As a last resort, use the slow shell script.  We don't cache a
1490     # path for INSTALL within a source directory, because that will
1491     # break other packages using the cache if that directory is
1492     # removed, or if the path is relative.
1493     INSTALL="$ac_install_sh"
1494   fi
1495 fi
1496 echo "$ac_t""$INSTALL" 1>&6
1497
1498 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1499 # It thinks the first close brace ends the variable substitution.
1500 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1501
1502 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1503
1504 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1505
1506
1507 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1508 echo "configure:1509: checking whether to enable maintainer-specific portions of Makefiles" >&5
1509     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1510 if test "${enable_maintainer_mode+set}" = set; then
1511   enableval="$enable_maintainer_mode"
1512   USE_MAINTAINER_MODE=$enableval
1513 else
1514   USE_MAINTAINER_MODE=no
1515 fi
1516
1517   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1518
1519
1520 if test $USE_MAINTAINER_MODE = yes; then
1521   MAINTAINER_MODE_TRUE=
1522   MAINTAINER_MODE_FALSE='#'
1523 else
1524   MAINTAINER_MODE_TRUE='#'
1525   MAINTAINER_MODE_FALSE=
1526 fi
1527   MAINT=$MAINTAINER_MODE_TRUE
1528
1529
1530
1531 # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1532 # at least currently, we never actually build a program, so we never
1533 # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1534 # fails, because we are probably configuring with a cross compiler
1535 # which cant create executables.  So we include AC_EXEEXT to keep
1536 # automake happy, but we dont execute it, since we dont care about
1537 # the result.
1538 if false; then
1539
1540
1541 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1542 echo "configure:1543: checking for executable suffix" >&5
1543 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1544   echo $ac_n "(cached) $ac_c" 1>&6
1545 else
1546   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1547   ac_cv_exeext=.exe
1548 else
1549   rm -f conftest*
1550   echo 'int main () { return 0; }' > conftest.$ac_ext
1551   ac_cv_exeext=
1552   if { (eval echo configure:1553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1553     for file in conftest.*; do
1554       case $file in
1555       *.c | *.o | *.obj | *.ilk | *.pdb) ;;
1556       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1557       esac
1558     done
1559   else
1560     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1561   fi
1562   rm -f conftest*
1563   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1564 fi
1565 fi
1566
1567 EXEEXT=""
1568 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1569 echo "$ac_t""${ac_cv_exeext}" 1>&6
1570 ac_exeext=$EXEEXT
1571
1572 fi
1573
1574 # configure.host sets the following important variables
1575 #       glibcpp_cflags    - host specific C compiler flags
1576 #       glibcpp_cxxflags  - host specific C++ compiler flags
1577
1578 glibcpp_cflags=
1579 glibcpp_cxxflags=
1580
1581 . ${glibcpp_basedir}/configure.host
1582
1583 case ${glibcpp_basedir} in
1584 /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1585 *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1586 esac
1587
1588 GLIBCPP_CFLAGS="${glibcpp_cflags}"
1589 GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1590
1591
1592
1593
1594 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
1595 echo "configure:1596: checking for GNU make" >&5
1596 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
1597   echo $ac_n "(cached) $ac_c" 1>&6
1598 else
1599   _cv_gnu_make_command='' ;
1600           for a in "${MAKE:-make}" make gmake gnumake ; do
1601                   if  ( $a --version 2> /dev/null | grep  -q GNU  ) ;  then
1602                           _cv_gnu_make_command=$a ;
1603                           break;
1604                   fi
1605           done ;
1606
1607 fi
1608
1609 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
1610   if test  "x$_cv_gnu_make_command" != "x"  ; then
1611           ifGNUmake='' ;
1612   else
1613           ifGNUmake='#' ;
1614   fi
1615
1616
1617   if test "x$_cv_gnu_make_command" = "x"; then
1618     { echo "configure: error: GNU Make not found.  Please install it or correct your path." 1>&2; exit 1; }
1619   fi
1620 # Check whether --enable-shared or --disable-shared was given.
1621 if test "${enable_shared+set}" = set; then
1622   enableval="$enable_shared"
1623   p=${PACKAGE-default}
1624 case "$enableval" in
1625 yes) enable_shared=yes ;;
1626 no) enable_shared=no ;;
1627 *)
1628   enable_shared=no
1629   # Look at the argument we got.  We use all the common list separators.
1630   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1631   for pkg in $enableval; do
1632     if test "X$pkg" = "X$p"; then
1633       enable_shared=yes
1634     fi
1635   done
1636   IFS="$ac_save_ifs"
1637   ;;
1638 esac
1639 else
1640   enable_shared=yes
1641 fi
1642
1643 # Check whether --enable-static or --disable-static was given.
1644 if test "${enable_static+set}" = set; then
1645   enableval="$enable_static"
1646   p=${PACKAGE-default}
1647 case "$enableval" in
1648 yes) enable_static=yes ;;
1649 no) enable_static=no ;;
1650 *)
1651   enable_static=no
1652   # Look at the argument we got.  We use all the common list separators.
1653   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1654   for pkg in $enableval; do
1655     if test "X$pkg" = "X$p"; then
1656       enable_static=yes
1657     fi
1658   done
1659   IFS="$ac_save_ifs"
1660   ;;
1661 esac
1662 else
1663   enable_static=yes
1664 fi
1665
1666 # Check whether --enable-fast-install or --disable-fast-install was given.
1667 if test "${enable_fast_install+set}" = set; then
1668   enableval="$enable_fast_install"
1669   p=${PACKAGE-default}
1670 case "$enableval" in
1671 yes) enable_fast_install=yes ;;
1672 no) enable_fast_install=no ;;
1673 *)
1674   enable_fast_install=no
1675   # Look at the argument we got.  We use all the common list separators.
1676   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1677   for pkg in $enableval; do
1678     if test "X$pkg" = "X$p"; then
1679       enable_fast_install=yes
1680     fi
1681   done
1682   IFS="$ac_save_ifs"
1683   ;;
1684 esac
1685 else
1686   enable_fast_install=yes
1687 fi
1688
1689 # Extract the first word of "ranlib", so it can be a program name with args.
1690 set dummy ranlib; ac_word=$2
1691 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1692 echo "configure:1693: checking for $ac_word" >&5
1693 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1694   echo $ac_n "(cached) $ac_c" 1>&6
1695 else
1696   if test -n "$RANLIB"; then
1697   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1698 else
1699   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1700   ac_dummy="$PATH"
1701   for ac_dir in $ac_dummy; do
1702     test -z "$ac_dir" && ac_dir=.
1703     if test -f $ac_dir/$ac_word; then
1704       ac_cv_prog_RANLIB="ranlib"
1705       break
1706     fi
1707   done
1708   IFS="$ac_save_ifs"
1709   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1710 fi
1711 fi
1712 RANLIB="$ac_cv_prog_RANLIB"
1713 if test -n "$RANLIB"; then
1714   echo "$ac_t""$RANLIB" 1>&6
1715 else
1716   echo "$ac_t""no" 1>&6
1717 fi
1718
1719 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1720 if test "${with_gnu_ld+set}" = set; then
1721   withval="$with_gnu_ld"
1722   test "$withval" = no || with_gnu_ld=yes
1723 else
1724   with_gnu_ld=no
1725 fi
1726
1727 ac_prog=ld
1728 if test "$ac_cv_prog_gcc" = yes; then
1729   # Check if gcc -print-prog-name=ld gives a path.
1730   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1731 echo "configure:1732: checking for ld used by GCC" >&5
1732   ac_prog=`($CC -print-prog-name=ld) 2>&5`
1733   case "$ac_prog" in
1734     # Accept absolute paths.
1735     [\\/]* | [A-Za-z]:[\\/]*)
1736       re_direlt='/[^/][^/]*/\.\./'
1737       # Canonicalize the path of ld
1738       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1739       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1740         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1741       done
1742       test -z "$LD" && LD="$ac_prog"
1743       ;;
1744   "")
1745     # If it fails, then pretend we aren't using GCC.
1746     ac_prog=ld
1747     ;;
1748   *)
1749     # If it is relative, then search for the first ld in PATH.
1750     with_gnu_ld=unknown
1751     ;;
1752   esac
1753 elif test "$with_gnu_ld" = yes; then
1754   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1755 echo "configure:1756: checking for GNU ld" >&5
1756 else
1757   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1758 echo "configure:1759: checking for non-GNU ld" >&5
1759 fi
1760 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1761   echo $ac_n "(cached) $ac_c" 1>&6
1762 else
1763   if test -z "$LD"; then
1764   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1765   for ac_dir in $PATH; do
1766     test -z "$ac_dir" && ac_dir=.
1767     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1768       ac_cv_path_LD="$ac_dir/$ac_prog"
1769       # Check to see if the program is GNU ld.  I'd rather use --version,
1770       # but apparently some GNU ld's only accept -v.
1771       # Break only if it was the GNU/non-GNU ld that we prefer.
1772       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1773         test "$with_gnu_ld" != no && break
1774       else
1775         test "$with_gnu_ld" != yes && break
1776       fi
1777     fi
1778   done
1779   IFS="$ac_save_ifs"
1780 else
1781   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1782 fi
1783 fi
1784
1785 LD="$ac_cv_path_LD"
1786 if test -n "$LD"; then
1787   echo "$ac_t""$LD" 1>&6
1788 else
1789   echo "$ac_t""no" 1>&6
1790 fi
1791 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1792 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1793 echo "configure:1794: checking if the linker ($LD) is GNU ld" >&5
1794 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1795   echo $ac_n "(cached) $ac_c" 1>&6
1796 else
1797   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1798 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1799   ac_cv_prog_gnu_ld=yes
1800 else
1801   ac_cv_prog_gnu_ld=no
1802 fi
1803 fi
1804
1805 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1806
1807
1808 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1809 echo "configure:1810: checking for BSD-compatible nm" >&5
1810 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1811   echo $ac_n "(cached) $ac_c" 1>&6
1812 else
1813   if test -n "$NM"; then
1814   # Let the user override the test.
1815   ac_cv_path_NM="$NM"
1816 else
1817   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1818   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1819     test -z "$ac_dir" && ac_dir=.
1820     if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
1821       # Check to see if the nm accepts a BSD-compat flag.
1822       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1823       #   nm: unknown option "B" ignored
1824       if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1825         ac_cv_path_NM="$ac_dir/nm -B"
1826         break
1827       elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1828         ac_cv_path_NM="$ac_dir/nm -p"
1829         break
1830       else
1831         ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
1832         continue # so that we can try to find one that supports BSD flags
1833       fi
1834     fi
1835   done
1836   IFS="$ac_save_ifs"
1837   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1838 fi
1839 fi
1840
1841 NM="$ac_cv_path_NM"
1842 echo "$ac_t""$NM" 1>&6
1843
1844 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1845 echo "configure:1846: checking whether ln -s works" >&5
1846 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1847   echo $ac_n "(cached) $ac_c" 1>&6
1848 else
1849   rm -f conftestdata
1850 if ln -s X conftestdata 2>/dev/null
1851 then
1852   rm -f conftestdata
1853   ac_cv_prog_LN_S="ln -s"
1854 else
1855   ac_cv_prog_LN_S=ln
1856 fi
1857 fi
1858 LN_S="$ac_cv_prog_LN_S"
1859 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1860   echo "$ac_t""yes" 1>&6
1861 else
1862   echo "$ac_t""no" 1>&6
1863 fi
1864
1865
1866 # Check for any special flags to pass to ltconfig.
1867 libtool_flags="--cache-file=$cache_file"
1868 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
1869 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
1870 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
1871 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
1872 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
1873 libtool_flags="$libtool_flags --enable-dlopen"
1874
1875 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
1876 if test "${enable_libtool_lock+set}" = set; then
1877   enableval="$enable_libtool_lock"
1878   :
1879 fi
1880
1881 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
1882 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
1883
1884 # Some flags need to be propagated to the compiler or linker for good
1885 # libtool support.
1886 case "$host" in
1887 *-*-irix6*)
1888   # Find out which ABI we are using.
1889   echo '#line 1890 "configure"' > conftest.$ac_ext
1890   if { (eval echo configure:1891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1891     case "`/usr/bin/file conftest.o`" in
1892     *32-bit*)
1893       LD="${LD-ld} -32"
1894       ;;
1895     *N32*)
1896       LD="${LD-ld} -n32"
1897       ;;
1898     *64-bit*)
1899       LD="${LD-ld} -64"
1900       ;;
1901     esac
1902   fi
1903   rm -rf conftest*
1904   ;;
1905
1906 *-*-sco3.2v5*)
1907   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
1908   SAVE_CFLAGS="$CFLAGS"
1909   CFLAGS="$CFLAGS -belf"
1910   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
1911 echo "configure:1912: checking whether the C compiler needs -belf" >&5
1912 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
1913   echo $ac_n "(cached) $ac_c" 1>&6
1914 else
1915   cat > conftest.$ac_ext <<EOF
1916 #line 1917 "configure"
1917 #include "confdefs.h"
1918
1919 int main() {
1920
1921 ; return 0; }
1922 EOF
1923 if { (eval echo configure:1924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1924   rm -rf conftest*
1925   lt_cv_cc_needs_belf=yes
1926 else
1927   echo "configure: failed program was:" >&5
1928   cat conftest.$ac_ext >&5
1929   rm -rf conftest*
1930   lt_cv_cc_needs_belf=no
1931 fi
1932 rm -f conftest*
1933 fi
1934
1935 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
1936   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
1937     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
1938     CFLAGS="$SAVE_CFLAGS"
1939   fi
1940   ;;
1941
1942
1943 esac
1944
1945
1946 # Save cache, so that ltconfig can load it
1947 cat > confcache <<\EOF
1948 # This file is a shell script that caches the results of configure
1949 # tests run on this system so they can be shared between configure
1950 # scripts and configure runs.  It is not useful on other systems.
1951 # If it contains results you don't want to keep, you may remove or edit it.
1952 #
1953 # By default, configure uses ./config.cache as the cache file,
1954 # creating it if it does not exist already.  You can give configure
1955 # the --cache-file=FILE option to use a different cache file; that is
1956 # what configure does when it calls configure scripts in
1957 # subdirectories, so they share the cache.
1958 # Giving --cache-file=/dev/null disables caching, for debugging configure.
1959 # config.status only pays attention to the cache file if you give it the
1960 # --recheck option to rerun configure.
1961 #
1962 EOF
1963 # The following way of writing the cache mishandles newlines in values,
1964 # but we know of no workaround that is simple, portable, and efficient.
1965 # So, don't put newlines in cache variables' values.
1966 # Ultrix sh set writes to stderr and can't be redirected directly,
1967 # and sets the high bit in the cache file unless we assign to the vars.
1968 (set) 2>&1 |
1969   case `(ac_space=' '; set | grep ac_space) 2>&1` in
1970   *ac_space=\ *)
1971     # `set' does not quote correctly, so add quotes (double-quote substitution
1972     # turns \\\\ into \\, and sed turns \\ into \).
1973     sed -n \
1974       -e "s/'/'\\\\''/g" \
1975       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
1976     ;;
1977   *)
1978     # `set' quotes correctly as required by POSIX, so do not add quotes.
1979     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
1980     ;;
1981   esac >> confcache
1982 if cmp -s $cache_file confcache; then
1983   :
1984 else
1985   if test -w $cache_file; then
1986     echo "updating cache $cache_file"
1987     cat confcache > $cache_file
1988   else
1989     echo "not updating unwritable cache $cache_file"
1990   fi
1991 fi
1992 rm -f confcache
1993
1994
1995 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
1996 CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
1997 LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
1998 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
1999 DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
2000 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2001 $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
2002 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2003
2004 # Reload cache, that may have been modified by ltconfig
2005 if test -r "$cache_file"; then
2006   echo "loading cache $cache_file"
2007   . $cache_file
2008 else
2009   echo "creating cache $cache_file"
2010   > $cache_file
2011 fi
2012
2013
2014 # This can be used to rebuild libtool when needed
2015 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
2016
2017 # Always use our own libtool.
2018 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2019
2020 # Redirect the config.log output again, so that the ltconfig log is not
2021 # clobbered by the next message.
2022 exec 5>>./config.log
2023
2024
2025
2026
2027
2028 # Check for c++ or library specific bits that don't require linking.
2029 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2030 echo "configure:2031: checking how to run the C preprocessor" >&5
2031 # On Suns, sometimes $CPP names a directory.
2032 if test -n "$CPP" && test -d "$CPP"; then
2033   CPP=
2034 fi
2035 if test -z "$CPP"; then
2036 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2037   echo $ac_n "(cached) $ac_c" 1>&6
2038 else
2039     # This must be in double quotes, not single quotes, because CPP may get
2040   # substituted into the Makefile and "${CC-cc}" will confuse make.
2041   CPP="${CC-cc} -E"
2042   # On the NeXT, cc -E runs the code through the compiler's parser,
2043   # not just through cpp.
2044   cat > conftest.$ac_ext <<EOF
2045 #line 2046 "configure"
2046 #include "confdefs.h"
2047 #include <assert.h>
2048 Syntax Error
2049 EOF
2050 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2051 { (eval echo configure:2052: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2052 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2053 if test -z "$ac_err"; then
2054   :
2055 else
2056   echo "$ac_err" >&5
2057   echo "configure: failed program was:" >&5
2058   cat conftest.$ac_ext >&5
2059   rm -rf conftest*
2060   CPP="${CC-cc} -E -traditional-cpp"
2061   cat > conftest.$ac_ext <<EOF
2062 #line 2063 "configure"
2063 #include "confdefs.h"
2064 #include <assert.h>
2065 Syntax Error
2066 EOF
2067 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2068 { (eval echo configure:2069: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2069 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2070 if test -z "$ac_err"; then
2071   :
2072 else
2073   echo "$ac_err" >&5
2074   echo "configure: failed program was:" >&5
2075   cat conftest.$ac_ext >&5
2076   rm -rf conftest*
2077   CPP="${CC-cc} -nologo -E"
2078   cat > conftest.$ac_ext <<EOF
2079 #line 2080 "configure"
2080 #include "confdefs.h"
2081 #include <assert.h>
2082 Syntax Error
2083 EOF
2084 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2085 { (eval echo configure:2086: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2086 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2087 if test -z "$ac_err"; then
2088   :
2089 else
2090   echo "$ac_err" >&5
2091   echo "configure: failed program was:" >&5
2092   cat conftest.$ac_ext >&5
2093   rm -rf conftest*
2094   CPP=/lib/cpp
2095 fi
2096 rm -f conftest*
2097 fi
2098 rm -f conftest*
2099 fi
2100 rm -f conftest*
2101   ac_cv_prog_CPP="$CPP"
2102 fi
2103   CPP="$ac_cv_prog_CPP"
2104 else
2105   ac_cv_prog_CPP="$CPP"
2106 fi
2107 echo "$ac_t""$CPP" 1>&6
2108
2109
2110   # Sanity check that g++ is capable of dealing with v-3.
2111   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2112 echo "configure:2113: checking for g++ that will successfully compile this code" >&5
2113   cat > conftest.$ac_ext <<EOF
2114 #line 2115 "configure"
2115 #include "confdefs.h"
2116
2117   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2118     ok
2119   #endif
2120
2121 EOF
2122 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2123   egrep "ok" >/dev/null 2>&1; then
2124   rm -rf conftest*
2125   gpp_satisfactory=yes
2126 else
2127   rm -rf conftest*
2128   { echo "configure: error: "please upgrade to gcc-2.95 or above"" 1>&2; exit 1; }
2129 fi
2130 rm -f conftest*
2131
2132   echo "$ac_t""$gpp_satisfactory" 1>&6
2133
2134
2135     echo $ac_n "checking for cpu primitives directory""... $ac_c" 1>&6
2136 echo "configure:2137: checking for cpu primitives directory" >&5
2137     CPU_FLAGS=
2138     case "$target_cpu" in
2139       alpha*)
2140         cpu_include_dir="config/cpu/alpha"
2141         ;;
2142       arm*)
2143         cpu_include_dir="config/cpu/arm"
2144         ;;
2145       i386)
2146         cpu_include_dir="config/cpu/i386"
2147         ;;
2148       i486 | i586 | i686 | i786)
2149         cpu_include_dir="config/cpu/i486"
2150         ;;
2151       powerpc | rs6000)
2152         cpu_include_dir="config/cpu/powerpc"
2153         CPU_FLAGS='-mcpu=powerpc'
2154         ;;
2155       sparc64 | ultrasparc)
2156         cpu_include_dir="config/cpu/sparc/sparc64"
2157         ;;
2158       sparc*)
2159         cpu_include_dir="config/cpu/sparc/sparc32"
2160         ;;
2161       *)
2162         cpu_include_dir="config/cpu/generic"
2163         ;;
2164     esac
2165     echo "$ac_t""$cpu_include_dir" 1>&6
2166
2167
2168
2169
2170 # Enable all the crazy c++ stuff.
2171 # Check whether --enable-debug or --disable-debug was given.
2172 if test "${enable_debug+set}" = set; then
2173   enableval="$enable_debug"
2174   case "$enableval" in
2175  yes) enable_debug=yes ;;
2176  no)  enable_debug=no ;;
2177  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2178  esac
2179 else
2180   enable_debug=no
2181 fi
2182 case "$enable_debug" in
2183     yes)
2184         DEBUG_FLAGS='-O0 -ggdb'
2185         ;;
2186     no)
2187         DEBUG_FLAGS='-g'
2188         ;;
2189 esac
2190
2191
2192
2193   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2194 echo "configure:2195: checking for cstdio to use" >&5
2195   # Check whether --enable-cstdio or --disable-cstdio was given.
2196 if test "${enable_cstdio+set}" = set; then
2197   enableval="$enable_cstdio"
2198   if test x$enable_cstdio = xno; then
2199     enable_cstdio=libio
2200   fi
2201 else
2202   enable_cstdio=libio
2203 fi
2204
2205
2206   enable_cstdio_flag=$enable_cstdio
2207
2208     case x${enable_cstdio_flag} in
2209         xlibio | x | xno | xnone | xyes)
2210           # default
2211           CSTDIO_H=config/c_io_libio.h
2212           CSTDIO_CC=config/c_io_libio.cc
2213           echo "$ac_t""libio" 1>&6
2214
2215           # see if we are on a system with libio native (ie, linux)
2216           ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2217 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2218 echo "configure:2219: checking for libio.h" >&5
2219 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2220   echo $ac_n "(cached) $ac_c" 1>&6
2221 else
2222   cat > conftest.$ac_ext <<EOF
2223 #line 2224 "configure"
2224 #include "confdefs.h"
2225 #include <libio.h>
2226 EOF
2227 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2228 { (eval echo configure:2229: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2229 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2230 if test -z "$ac_err"; then
2231   rm -rf conftest*
2232   eval "ac_cv_header_$ac_safe=yes"
2233 else
2234   echo "$ac_err" >&5
2235   echo "configure: failed program was:" >&5
2236   cat conftest.$ac_ext >&5
2237   rm -rf conftest*
2238   eval "ac_cv_header_$ac_safe=no"
2239 fi
2240 rm -f conftest*
2241 fi
2242 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2243   echo "$ac_t""yes" 1>&6
2244   has_libio=yes
2245 else
2246   echo "$ac_t""no" 1>&6
2247 has_libio=no
2248 fi
2249
2250
2251           # bkoz XXX hack hack need version checks, this is temporary
2252           has_libio=no
2253
2254           if test $has_libio = "yes"; then
2255             BUILD_LIBIO_INCLUDE=
2256             need_libio=no
2257           else
2258           BUILD_LIBIO_INCLUDE='-I../libio'
2259             need_libio=yes
2260           fi
2261
2262
2263           # see if the _G_config.h header needs to be built.
2264           # NB: This replaces the _G_CONFIG_H machinery in libio-v2
2265           ac_safe=`echo "_G_config.h" | sed 'y%./+-%__p_%'`
2266 echo $ac_n "checking for _G_config.h""... $ac_c" 1>&6
2267 echo "configure:2268: checking for _G_config.h" >&5
2268 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2269   echo $ac_n "(cached) $ac_c" 1>&6
2270 else
2271   cat > conftest.$ac_ext <<EOF
2272 #line 2273 "configure"
2273 #include "confdefs.h"
2274 #include <_G_config.h>
2275 EOF
2276 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2277 { (eval echo configure:2278: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2278 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2279 if test -z "$ac_err"; then
2280   rm -rf conftest*
2281   eval "ac_cv_header_$ac_safe=yes"
2282 else
2283   echo "$ac_err" >&5
2284   echo "configure: failed program was:" >&5
2285   cat conftest.$ac_ext >&5
2286   rm -rf conftest*
2287   eval "ac_cv_header_$ac_safe=no"
2288 fi
2289 rm -f conftest*
2290 fi
2291 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2292   echo "$ac_t""yes" 1>&6
2293   has_gconf_h=yes
2294 else
2295   echo "$ac_t""no" 1>&6
2296 has_gconf_h=no
2297 fi
2298
2299
2300
2301 if test "$has_gconf_h" = no; then
2302   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE=
2303   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE='#'
2304 else
2305   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE='#'
2306   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE=
2307 fi
2308           # bkoz XXX hack need to add support for non-glibc systems here
2309            has_gconf=no
2310
2311           # bkoz XXX need to add checks for this
2312           need_wlibio=yes
2313           ;;
2314         xwince)
2315           CSTDIO_H=config/c_io_wince.h
2316           CSTDIO_CC=config/c_io_wince.cc
2317           echo "$ac_t""wince" 1>&6
2318
2319           need_libio=no
2320           BUILD_LIBIO_INCLUDE=
2321
2322           ;;
2323         *)
2324           echo "$enable_cstdio is an unknown io package" 1>&2
2325           exit 1
2326           ;;
2327   esac
2328
2329
2330
2331
2332 if test "$need_libio" = yes; then
2333   GLIBCPP_NEED_LIBIO_TRUE=
2334   GLIBCPP_NEED_LIBIO_FALSE='#'
2335 else
2336   GLIBCPP_NEED_LIBIO_TRUE='#'
2337   GLIBCPP_NEED_LIBIO_FALSE=
2338 fi
2339
2340
2341 if test "$need_wlibio" = yes; then
2342   GLIBCPP_NEED_WLIBIO_TRUE=
2343   GLIBCPP_NEED_WLIBIO_FALSE='#'
2344 else
2345   GLIBCPP_NEED_WLIBIO_TRUE='#'
2346   GLIBCPP_NEED_WLIBIO_FALSE=
2347 fi
2348
2349
2350   # Check whether --enable-long-long or --disable-long-long was given.
2351 if test "${enable_long_long+set}" = set; then
2352   enableval="$enable_long_long"
2353     case "$enableval" in
2354    yes) enable_long_long=yes ;;
2355    no)  enable_long_long=no ;;
2356    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2357    esac
2358 else
2359   enable_long_long=yes
2360 fi
2361
2362   # Check for the existance of functions used if long long is enabled.
2363   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2364 echo "configure:2365: checking for strtoll" >&5
2365 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2366   echo $ac_n "(cached) $ac_c" 1>&6
2367 else
2368   cat > conftest.$ac_ext <<EOF
2369 #line 2370 "configure"
2370 #include "confdefs.h"
2371 /* System header to define __stub macros and hopefully few prototypes,
2372     which can conflict with char strtoll(); below.  */
2373 #include <assert.h>
2374 /* Override any gcc2 internal prototype to avoid an error.  */
2375 /* We use char because int might match the return type of a gcc2
2376     builtin and then its argument prototype would still apply.  */
2377 char strtoll();
2378
2379 int main() {
2380
2381 /* The GNU C library defines this for functions which it implements
2382     to always fail with ENOSYS.  Some functions are actually named
2383     something starting with __ and the normal name is an alias.  */
2384 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2385 choke me
2386 #else
2387 strtoll();
2388 #endif
2389
2390 ; return 0; }
2391 EOF
2392 if { (eval echo configure:2393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2393   rm -rf conftest*
2394   eval "ac_cv_func_strtoll=yes"
2395 else
2396   echo "configure: failed program was:" >&5
2397   cat conftest.$ac_ext >&5
2398   rm -rf conftest*
2399   eval "ac_cv_func_strtoll=no"
2400 fi
2401 rm -f conftest*
2402 fi
2403
2404 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2405   echo "$ac_t""yes" 1>&6
2406   :
2407 else
2408   echo "$ac_t""no" 1>&6
2409 ac_strtoll=no
2410 fi
2411
2412   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2413 echo "configure:2414: checking for strtoull" >&5
2414 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2415   echo $ac_n "(cached) $ac_c" 1>&6
2416 else
2417   cat > conftest.$ac_ext <<EOF
2418 #line 2419 "configure"
2419 #include "confdefs.h"
2420 /* System header to define __stub macros and hopefully few prototypes,
2421     which can conflict with char strtoull(); below.  */
2422 #include <assert.h>
2423 /* Override any gcc2 internal prototype to avoid an error.  */
2424 /* We use char because int might match the return type of a gcc2
2425     builtin and then its argument prototype would still apply.  */
2426 char strtoull();
2427
2428 int main() {
2429
2430 /* The GNU C library defines this for functions which it implements
2431     to always fail with ENOSYS.  Some functions are actually named
2432     something starting with __ and the normal name is an alias.  */
2433 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2434 choke me
2435 #else
2436 strtoull();
2437 #endif
2438
2439 ; return 0; }
2440 EOF
2441 if { (eval echo configure:2442: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2442   rm -rf conftest*
2443   eval "ac_cv_func_strtoull=yes"
2444 else
2445   echo "configure: failed program was:" >&5
2446   cat conftest.$ac_ext >&5
2447   rm -rf conftest*
2448   eval "ac_cv_func_strtoull=no"
2449 fi
2450 rm -f conftest*
2451 fi
2452
2453 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2454   echo "$ac_t""yes" 1>&6
2455   :
2456 else
2457   echo "$ac_t""no" 1>&6
2458 ac_strtoull=no
2459 fi
2460
2461
2462   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2463 echo "configure:2464: checking for enabled long long" >&5
2464   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2465     enable_long_long=no;
2466   fi;
2467   echo "$ac_t""$enable_long_long" 1>&6
2468
2469     case "$enable_long_long" in
2470     yes)  cat >> confdefs.h <<\EOF
2471 #define _GLIBCPP_USE_LONG_LONG 1
2472 EOF
2473
2474           ;;
2475   esac
2476
2477 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2478 echo "configure:2479: checking for enabled cshadow headers" >&5
2479 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2480 if test "${enable_cshadow_headers+set}" = set; then
2481   enableval="$enable_cshadow_headers"
2482   case "$enableval" in
2483  yes) enable_cshadow_headers=yes
2484         ;;
2485  no)  enable_cshadow_headers=no
2486         ;;
2487  *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
2488         ;;
2489  esac
2490 else
2491   enable_cshadow_headers=no
2492 fi
2493 echo "$ac_t""$enable_cshadow_headers" 1>&6
2494 case "$enable_cshadow_headers" in
2495     yes)
2496         CSHADOWFLAGS="-D_GNU_SOURCE"
2497         CSHADOW_INCLUDES=" -I$srcdir/shadow -I$blddir/cshadow"
2498         ;;
2499     no)
2500         CSHADOWFLAGS=""
2501         CSHADOW_INCLUDES=""
2502         ;;
2503 esac
2504
2505
2506
2507
2508
2509 if test "$enable_cshadow_headers" = yes; then
2510   GLIBCPP_USE_CSHADOW_TRUE=
2511   GLIBCPP_USE_CSHADOW_FALSE='#'
2512 else
2513   GLIBCPP_USE_CSHADOW_TRUE='#'
2514   GLIBCPP_USE_CSHADOW_FALSE=
2515 fi
2516
2517
2518       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
2519 echo "configure:2520: checking for threads package to use" >&5
2520   # Check whether --enable-threads or --disable-threads was given.
2521 if test "${enable_threads+set}" = set; then
2522   enableval="$enable_threads"
2523   if test x$enable_threads = xno; then
2524     enable_threads=''
2525   fi
2526 else
2527   enable_threads=''
2528 fi
2529
2530
2531   enable_threads_flag=$enable_threads
2532
2533     case x${enable_threads_flag} in
2534         x | xno | xnone)
2535                 # No threads
2536                 target_thread_file='single'
2537                 ;;
2538         xyes)
2539                 # default
2540                 target_thread_file=''
2541                 ;;
2542         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
2543         xsolaris | xwin32 | xdce | xvxworks)
2544                 target_thread_file=$enable_threads_flag
2545                 ;;
2546         *)
2547                 echo "$enable_threads is an unknown thread package" 1>&2
2548                 exit 1
2549                 ;;
2550   esac
2551
2552     case "$target_thread_file" in
2553     no | none | single)
2554       THREADS=none
2555       ;;
2556     posix | pthreads)
2557       THREADS=posix
2558       case "$target" in
2559         *-*-linux*)
2560         ;;
2561       esac
2562       ;;
2563     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
2564       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
2565       ;;
2566     *)
2567       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
2568       ;;
2569   esac
2570   echo "$ac_t""$THREADS" 1>&6
2571
2572   THREADLIBS=
2573   THREADINCS=
2574   THREADDEPS=
2575   THREADOBJS=
2576   THREADH=
2577   THREADSPEC=
2578   case "$THREADS" in
2579     posix)
2580       ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
2581 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
2582 echo "configure:2583: checking for pthread.h" >&5
2583 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2584   echo $ac_n "(cached) $ac_c" 1>&6
2585 else
2586   cat > conftest.$ac_ext <<EOF
2587 #line 2588 "configure"
2588 #include "confdefs.h"
2589 #include <pthread.h>
2590 EOF
2591 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2592 { (eval echo configure:2593: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2593 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2594 if test -z "$ac_err"; then
2595   rm -rf conftest*
2596   eval "ac_cv_header_$ac_safe=yes"
2597 else
2598   echo "$ac_err" >&5
2599   echo "configure: failed program was:" >&5
2600   cat conftest.$ac_ext >&5
2601   rm -rf conftest*
2602   eval "ac_cv_header_$ac_safe=no"
2603 fi
2604 rm -f conftest*
2605 fi
2606 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2607   echo "$ac_t""yes" 1>&6
2608   have_pthread_h=yes
2609 else
2610   echo "$ac_t""no" 1>&6
2611 have_pthread_h=
2612 fi
2613
2614       THREADLIBS=-lpthread
2615       THREADSPEC=-lpthread
2616                   THREADH=threads-posix.h
2617       ;;
2618     none)
2619                   THREADH=threads-no.h
2620       ;;
2621   esac
2622
2623
2624
2625
2626
2627
2628
2629 #GLIBCPP_ENABLE_RELIBGCC([../..])
2630 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
2631 if test "${enable_cxx_flags+set}" = set; then
2632   enableval="$enable_cxx_flags"
2633   case "x$enableval" in
2634  xyes)   { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
2635  xno|x)  enable_cxx_flags='' ;;
2636  *)      enable_cxx_flags="$enableval" ;;
2637  esac
2638 else
2639   enable_cxx_flags='none'
2640 fi
2641 if test "$enable_cxx_flags" = "none"; then enable_cxx_flags=''; fi
2642 if test -n "$enable_cxx_flags"; then
2643     for f in $enable_cxx_flags; do
2644         case "$f" in
2645             -fhonor-std)  ;;
2646             -*)  ;;
2647             *)   # and we're trying to pass /what/ exactly?
2648                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
2649         esac
2650     done
2651 fi
2652 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2653
2654
2655
2656
2657 if test -n "$with_cross_host"; then
2658
2659   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
2660   # may not work correctly, because the compiler may not be able to
2661   # link executables.
2662
2663   xcompiling=1
2664   NATIVE=no
2665   # If Canadian cross, then don't pick up tools from the build
2666   # directory.
2667   if test "$build" != "$with_cross_host"; then
2668     CANADIAN=yes
2669     NULL_TARGET=yes
2670   else
2671     CANADIAN=no
2672     NULL_TARGET=no
2673   fi
2674
2675   case "$target_alias" in
2676     *-wince-*)
2677         # Configure for Microsoft Windows CE, or whatever they are
2678         # currently calling it.
2679         cat >> confdefs.h <<\EOF
2680 #define HAVE_FLOAT_H 1
2681 EOF
2682
2683
2684         cat >> confdefs.h <<\EOF
2685 #define HAVE__FINITE 1
2686 EOF
2687
2688         cat >> confdefs.h <<\EOF
2689 #define HAVE__ISNAN 1
2690 EOF
2691
2692         cat >> confdefs.h <<\EOF
2693 #define HAVE__COPYSIGN 1
2694 EOF
2695
2696         cat >> confdefs.h <<\EOF
2697 #define HAVE__FPCLASS 1
2698 EOF
2699
2700         cat >> confdefs.h <<\EOF
2701 #define HAVE_MODF 1
2702 EOF
2703
2704
2705         ctype_include_dir="config/wince"
2706
2707
2708         cat >> confdefs.h <<\EOF
2709 #define _GLIBCPP_NEED_MBSTATE_T 1
2710 EOF
2711
2712
2713         cat >> confdefs.h <<\EOF
2714 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2715 EOF
2716
2717         cat >> confdefs.h <<\EOF
2718 #define _GLIBCPP_BUGGY_COMPLEX 1
2719 EOF
2720
2721         ;;
2722     *)
2723         # We assume newlib.  This lets us hard-code the functions we know
2724         # we'll have.
2725         cat >> confdefs.h <<\EOF
2726 #define HAVE_FINITE 1
2727 EOF
2728
2729         cat >> confdefs.h <<\EOF
2730 #define HAVE_ISNAN 1
2731 EOF
2732
2733         cat >> confdefs.h <<\EOF
2734 #define HAVE_ISNANF 1
2735 EOF
2736
2737         cat >> confdefs.h <<\EOF
2738 #define HAVE_ISINF 1
2739 EOF
2740
2741         cat >> confdefs.h <<\EOF
2742 #define HAVE_ISINFF 1
2743 EOF
2744
2745
2746         ctype_include_dir="config/newlib"
2747
2748
2749         cat >> confdefs.h <<\EOF
2750 #define _GLIBCPP_NEED_MBSTATE_T 1
2751 EOF
2752
2753
2754         cat >> confdefs.h <<\EOF
2755 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2756 EOF
2757
2758         cat >> confdefs.h <<\EOF
2759 #define _GLIBCPP_BUGGY_COMPLEX 1
2760 EOF
2761
2762         # need to ceck for faster f versions of math functions, ie sinf?
2763         ;;
2764   esac
2765 else
2766
2767   # We are being configured natively. We can do more elaborate tests
2768   # that include AC_TRY_COMPILE now, as the linker is assumed to be
2769   # working.
2770
2771   xcompiling=0
2772   NATIVE=yes
2773   CANADIAN=no
2774   NULL_TARGET=no
2775
2776   # Check for available headers.
2777   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
2778   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h
2779 do
2780 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
2781 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
2782 echo "configure:2783: checking for $ac_hdr" >&5
2783 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2784   echo $ac_n "(cached) $ac_c" 1>&6
2785 else
2786   cat > conftest.$ac_ext <<EOF
2787 #line 2788 "configure"
2788 #include "confdefs.h"
2789 #include <$ac_hdr>
2790 EOF
2791 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2792 { (eval echo configure:2793: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2793 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2794 if test -z "$ac_err"; then
2795   rm -rf conftest*
2796   eval "ac_cv_header_$ac_safe=yes"
2797 else
2798   echo "$ac_err" >&5
2799   echo "configure: failed program was:" >&5
2800   cat conftest.$ac_ext >&5
2801   rm -rf conftest*
2802   eval "ac_cv_header_$ac_safe=no"
2803 fi
2804 rm -f conftest*
2805 fi
2806 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2807   echo "$ac_t""yes" 1>&6
2808     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
2809   cat >> confdefs.h <<EOF
2810 #define $ac_tr_hdr 1
2811 EOF
2812
2813 else
2814   echo "$ac_t""no" 1>&6
2815 fi
2816 done
2817
2818
2819
2820   # All these tests are for C++; save the language and the compiler flags.
2821   # The CXXFLAGS thing is suspicious, but based on similar bits
2822   # found in GLIBCPP_CONFIGURE.
2823
2824   ac_ext=C
2825 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2826 ac_cpp='$CXXCPP $CPPFLAGS'
2827 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2828 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2829 cross_compiling=$ac_cv_prog_cxx_cross
2830
2831   ac_test_CXXFLAGS="${CXXFLAGS+set}"
2832   ac_save_CXXFLAGS="$CXXFLAGS"
2833   WERROR='-Werror'
2834
2835   # Check for pragma system_header.
2836   echo $ac_n "checking for g++ that supports pragma system_header""... $ac_c" 1>&6
2837 echo "configure:2838: checking for g++ that supports pragma system_header" >&5
2838   CXXFLAGS='-Wunknown-pragmas -Werror'
2839   cat > conftest.$ac_ext <<EOF
2840 #line 2841 "configure"
2841 #include "confdefs.h"
2842 #pragma system_header
2843 int main() {
2844 int foo;
2845
2846 ; return 0; }
2847 EOF
2848 if { (eval echo configure:2849: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2849   rm -rf conftest*
2850   ac_newpragma=yes
2851 else
2852   echo "configure: failed program was:" >&5
2853   cat conftest.$ac_ext >&5
2854   rm -rf conftest*
2855   ac_newpragma=no
2856 fi
2857 rm -f conftest*
2858   if test "$ac_test_CXXFLAGS" = set; then
2859     CXXFLAGS="$ac_save_CXXFLAGS"
2860   else
2861     # this is the suspicious part
2862     CXXFLAGS=''
2863   fi
2864   if test "$ac_newpragma" = "no"; then
2865     WERROR="$WERROR -Wno-unknown-pragmas"
2866   fi
2867   echo "$ac_t""$ac_newpragma" 1>&6
2868
2869   # Check for more sophisticated diagnostic control.
2870   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
2871 echo "configure:2872: checking for g++ that supports -fdiagnostics-show-location=once" >&5
2872   CXXFLAGS='-fdiagnostics-show-location=once'
2873   cat > conftest.$ac_ext <<EOF
2874 #line 2875 "configure"
2875 #include "confdefs.h"
2876
2877 int main() {
2878 int foo;
2879
2880 ; return 0; }
2881 EOF
2882 if { (eval echo configure:2883: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2883   rm -rf conftest*
2884   ac_gabydiags=yes
2885 else
2886   echo "configure: failed program was:" >&5
2887   cat conftest.$ac_ext >&5
2888   rm -rf conftest*
2889   ac_gabydiags=no
2890 fi
2891 rm -f conftest*
2892   if test "$ac_test_CXXFLAGS" = set; then
2893     CXXFLAGS="$ac_save_CXXFLAGS"
2894   else
2895     # this is the suspicious part
2896     CXXFLAGS=''
2897   fi
2898   if test "$ac_gabydiags" = "yes"; then
2899     WFMT_FLAGS='-fdiagnostics-show-location=once'
2900   fi
2901   echo "$ac_t""$ac_gabydiags" 1>&6
2902
2903   # Check for -ffunction-sections -fdata-sections
2904   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
2905 echo "configure:2906: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
2906   CXXFLAGS='-ffunction-sections -fdata-sections'
2907   cat > conftest.$ac_ext <<EOF
2908 #line 2909 "configure"
2909 #include "confdefs.h"
2910
2911 int main() {
2912 int foo;
2913
2914 ; return 0; }
2915 EOF
2916 if { (eval echo configure:2917: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2917   rm -rf conftest*
2918   ac_fdsections=yes
2919 else
2920   echo "configure: failed program was:" >&5
2921   cat conftest.$ac_ext >&5
2922   rm -rf conftest*
2923   ac_fdsections=no
2924 fi
2925 rm -f conftest*
2926   if test "$ac_test_CXXFLAGS" = set; then
2927     CXXFLAGS="$ac_save_CXXFLAGS"
2928   else
2929     # this is the suspicious part
2930     CXXFLAGS=''
2931   fi
2932   if test "$ac_fdsections" = "yes"; then
2933     SECTION_FLAGS='-ffunction-sections -fdata-sections'
2934   fi
2935   echo "$ac_t""$ac_fdsections" 1>&6
2936
2937   ac_ext=c
2938 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2939 ac_cpp='$CPP $CPPFLAGS'
2940 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2941 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2942 cross_compiling=$ac_cv_prog_cc_cross
2943
2944
2945
2946
2947
2948
2949   # All these tests are for C++; save the language and the compiler flags.
2950   # Need to do this so that g++ won't try to link in libstdc++
2951   ac_test_CFLAGS="${CFLAGS+set}"
2952   ac_save_CFLAGS="$CFLAGS"
2953   CFLAGS='-x c++  -Wl,--gc-sections'
2954
2955   # Check for -Wl,--gc-sections
2956   echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
2957 echo "configure:2958: checking for ld that supports -Wl,--gc-sections" >&5
2958   if test "$cross_compiling" = yes; then
2959   ac_sectionLDflags=yes
2960 else
2961   cat > conftest.$ac_ext <<EOF
2962 #line 2963 "configure"
2963 #include "confdefs.h"
2964
2965    int main(void)
2966    {
2967      try { throw 1; }
2968      catch (...) { };
2969      return 0;
2970    }
2971
2972 EOF
2973 if { (eval echo configure:2974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
2974 then
2975   ac_sectionLDflags=yes
2976 else
2977   echo "configure: failed program was:" >&5
2978   cat conftest.$ac_ext >&5
2979   rm -fr conftest*
2980   ac_sectionLFflags=no
2981 fi
2982 rm -fr conftest*
2983 fi
2984
2985   if test "$ac_test_CFLAGS" = set; then
2986     CFLAGS="$ac_save_CFLAGS"
2987   else
2988     # this is the suspicious part
2989     CFLAGS=''
2990   fi
2991   if test "$ac_sectionLDflags" = "yes"; then
2992     SECTION_LDFLAGS='-Wl,--gc-sections'
2993   fi
2994   echo "$ac_t""$ac_sectionLDflags" 1>&6
2995
2996
2997
2998
2999
3000
3001   ac_ext=C
3002 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3003 ac_cpp='$CXXCPP $CPPFLAGS'
3004 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3005 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3006 cross_compiling=$ac_cv_prog_cxx_cross
3007
3008   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3009 echo "configure:3010: checking for __builtin_abs declaration" >&5
3010   cat > conftest.$ac_ext <<EOF
3011 #line 3012 "configure"
3012 #include "confdefs.h"
3013 #include <math.h>
3014 int main() {
3015  __builtin_abs(0);
3016 ; return 0; }
3017 EOF
3018 if { (eval echo configure:3019: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3019   rm -rf conftest*
3020   use___builtin_abs=yes
3021 else
3022   echo "configure: failed program was:" >&5
3023   cat conftest.$ac_ext >&5
3024   rm -rf conftest*
3025   use___builtin_abs=no
3026 fi
3027 rm -f conftest*
3028   echo "$ac_t""$use___builtin_abs" 1>&6
3029   ac_ext=c
3030 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3031 ac_cpp='$CPP $CPPFLAGS'
3032 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3033 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3034 cross_compiling=$ac_cv_prog_cc_cross
3035
3036   if test x$use___builtin_abs = x"yes"; then
3037     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3038 echo "configure:3039: checking for __builtin_abs linkage" >&5
3039       cat > conftest.$ac_ext <<EOF
3040 #line 3041 "configure"
3041 #include "confdefs.h"
3042 #include <math.h>
3043 int main() {
3044  __builtin_abs(0);
3045 ; return 0; }
3046 EOF
3047 if { (eval echo configure:3048: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3048   rm -rf conftest*
3049   link___builtin_abs=yes
3050 else
3051   echo "configure: failed program was:" >&5
3052   cat conftest.$ac_ext >&5
3053   rm -rf conftest*
3054   link___builtin_abs=no
3055 fi
3056 rm -f conftest*
3057     echo "$ac_t""$link___builtin_abs" 1>&6
3058     if test x$link___builtin_abs = x"yes"; then
3059       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3060       cat >> confdefs.h <<EOF
3061 #define ${ac_tr_func} 1
3062 EOF
3063
3064     fi
3065   fi
3066
3067
3068
3069   ac_ext=C
3070 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3071 ac_cpp='$CXXCPP $CPPFLAGS'
3072 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3073 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3074 cross_compiling=$ac_cv_prog_cxx_cross
3075
3076   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3077 echo "configure:3078: checking for __builtin_fabsf declaration" >&5
3078   cat > conftest.$ac_ext <<EOF
3079 #line 3080 "configure"
3080 #include "confdefs.h"
3081 #include <math.h>
3082 int main() {
3083  __builtin_fabsf(0);
3084 ; return 0; }
3085 EOF
3086 if { (eval echo configure:3087: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3087   rm -rf conftest*
3088   use___builtin_fabsf=yes
3089 else
3090   echo "configure: failed program was:" >&5
3091   cat conftest.$ac_ext >&5
3092   rm -rf conftest*
3093   use___builtin_fabsf=no
3094 fi
3095 rm -f conftest*
3096   echo "$ac_t""$use___builtin_fabsf" 1>&6
3097   ac_ext=c
3098 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3099 ac_cpp='$CPP $CPPFLAGS'
3100 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3101 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3102 cross_compiling=$ac_cv_prog_cc_cross
3103
3104   if test x$use___builtin_fabsf = x"yes"; then
3105     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3106 echo "configure:3107: checking for __builtin_fabsf linkage" >&5
3107       cat > conftest.$ac_ext <<EOF
3108 #line 3109 "configure"
3109 #include "confdefs.h"
3110 #include <math.h>
3111 int main() {
3112  __builtin_fabsf(0);
3113 ; return 0; }
3114 EOF
3115 if { (eval echo configure:3116: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3116   rm -rf conftest*
3117   link___builtin_fabsf=yes
3118 else
3119   echo "configure: failed program was:" >&5
3120   cat conftest.$ac_ext >&5
3121   rm -rf conftest*
3122   link___builtin_fabsf=no
3123 fi
3124 rm -f conftest*
3125     echo "$ac_t""$link___builtin_fabsf" 1>&6
3126     if test x$link___builtin_fabsf = x"yes"; then
3127       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3128       cat >> confdefs.h <<EOF
3129 #define ${ac_tr_func} 1
3130 EOF
3131
3132     fi
3133   fi
3134
3135
3136
3137   ac_ext=C
3138 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3139 ac_cpp='$CXXCPP $CPPFLAGS'
3140 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3141 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3142 cross_compiling=$ac_cv_prog_cxx_cross
3143
3144   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3145 echo "configure:3146: checking for __builtin_fabs declaration" >&5
3146   cat > conftest.$ac_ext <<EOF
3147 #line 3148 "configure"
3148 #include "confdefs.h"
3149 #include <math.h>
3150 int main() {
3151  __builtin_fabs(0);
3152 ; return 0; }
3153 EOF
3154 if { (eval echo configure:3155: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3155   rm -rf conftest*
3156   use___builtin_fabs=yes
3157 else
3158   echo "configure: failed program was:" >&5
3159   cat conftest.$ac_ext >&5
3160   rm -rf conftest*
3161   use___builtin_fabs=no
3162 fi
3163 rm -f conftest*
3164   echo "$ac_t""$use___builtin_fabs" 1>&6
3165   ac_ext=c
3166 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3167 ac_cpp='$CPP $CPPFLAGS'
3168 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3169 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3170 cross_compiling=$ac_cv_prog_cc_cross
3171
3172   if test x$use___builtin_fabs = x"yes"; then
3173     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3174 echo "configure:3175: checking for __builtin_fabs linkage" >&5
3175       cat > conftest.$ac_ext <<EOF
3176 #line 3177 "configure"
3177 #include "confdefs.h"
3178 #include <math.h>
3179 int main() {
3180  __builtin_fabs(0);
3181 ; return 0; }
3182 EOF
3183 if { (eval echo configure:3184: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3184   rm -rf conftest*
3185   link___builtin_fabs=yes
3186 else
3187   echo "configure: failed program was:" >&5
3188   cat conftest.$ac_ext >&5
3189   rm -rf conftest*
3190   link___builtin_fabs=no
3191 fi
3192 rm -f conftest*
3193     echo "$ac_t""$link___builtin_fabs" 1>&6
3194     if test x$link___builtin_fabs = x"yes"; then
3195       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3196       cat >> confdefs.h <<EOF
3197 #define ${ac_tr_func} 1
3198 EOF
3199
3200     fi
3201   fi
3202
3203
3204
3205   ac_ext=C
3206 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3207 ac_cpp='$CXXCPP $CPPFLAGS'
3208 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3209 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3210 cross_compiling=$ac_cv_prog_cxx_cross
3211
3212   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3213 echo "configure:3214: checking for __builtin_fabsl declaration" >&5
3214   cat > conftest.$ac_ext <<EOF
3215 #line 3216 "configure"
3216 #include "confdefs.h"
3217 #include <math.h>
3218 int main() {
3219  __builtin_fabsl(0);
3220 ; return 0; }
3221 EOF
3222 if { (eval echo configure:3223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3223   rm -rf conftest*
3224   use___builtin_fabsl=yes
3225 else
3226   echo "configure: failed program was:" >&5
3227   cat conftest.$ac_ext >&5
3228   rm -rf conftest*
3229   use___builtin_fabsl=no
3230 fi
3231 rm -f conftest*
3232   echo "$ac_t""$use___builtin_fabsl" 1>&6
3233   ac_ext=c
3234 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3235 ac_cpp='$CPP $CPPFLAGS'
3236 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3237 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3238 cross_compiling=$ac_cv_prog_cc_cross
3239
3240   if test x$use___builtin_fabsl = x"yes"; then
3241     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3242 echo "configure:3243: checking for __builtin_fabsl linkage" >&5
3243       cat > conftest.$ac_ext <<EOF
3244 #line 3245 "configure"
3245 #include "confdefs.h"
3246 #include <math.h>
3247 int main() {
3248  __builtin_fabsl(0);
3249 ; return 0; }
3250 EOF
3251 if { (eval echo configure:3252: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3252   rm -rf conftest*
3253   link___builtin_fabsl=yes
3254 else
3255   echo "configure: failed program was:" >&5
3256   cat conftest.$ac_ext >&5
3257   rm -rf conftest*
3258   link___builtin_fabsl=no
3259 fi
3260 rm -f conftest*
3261     echo "$ac_t""$link___builtin_fabsl" 1>&6
3262     if test x$link___builtin_fabsl = x"yes"; then
3263       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3264       cat >> confdefs.h <<EOF
3265 #define ${ac_tr_func} 1
3266 EOF
3267
3268     fi
3269   fi
3270
3271
3272
3273   ac_ext=C
3274 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3275 ac_cpp='$CXXCPP $CPPFLAGS'
3276 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3277 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3278 cross_compiling=$ac_cv_prog_cxx_cross
3279
3280   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3281 echo "configure:3282: checking for __builtin_labs declaration" >&5
3282   cat > conftest.$ac_ext <<EOF
3283 #line 3284 "configure"
3284 #include "confdefs.h"
3285 #include <math.h>
3286 int main() {
3287  __builtin_labs(0);
3288 ; return 0; }
3289 EOF
3290 if { (eval echo configure:3291: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3291   rm -rf conftest*
3292   use___builtin_labs=yes
3293 else
3294   echo "configure: failed program was:" >&5
3295   cat conftest.$ac_ext >&5
3296   rm -rf conftest*
3297   use___builtin_labs=no
3298 fi
3299 rm -f conftest*
3300   echo "$ac_t""$use___builtin_labs" 1>&6
3301   ac_ext=c
3302 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3303 ac_cpp='$CPP $CPPFLAGS'
3304 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3305 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3306 cross_compiling=$ac_cv_prog_cc_cross
3307
3308   if test x$use___builtin_labs = x"yes"; then
3309     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3310 echo "configure:3311: checking for __builtin_labs linkage" >&5
3311       cat > conftest.$ac_ext <<EOF
3312 #line 3313 "configure"
3313 #include "confdefs.h"
3314 #include <math.h>
3315 int main() {
3316  __builtin_labs(0);
3317 ; return 0; }
3318 EOF
3319 if { (eval echo configure:3320: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3320   rm -rf conftest*
3321   link___builtin_labs=yes
3322 else
3323   echo "configure: failed program was:" >&5
3324   cat conftest.$ac_ext >&5
3325   rm -rf conftest*
3326   link___builtin_labs=no
3327 fi
3328 rm -f conftest*
3329     echo "$ac_t""$link___builtin_labs" 1>&6
3330     if test x$link___builtin_labs = x"yes"; then
3331       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3332       cat >> confdefs.h <<EOF
3333 #define ${ac_tr_func} 1
3334 EOF
3335
3336     fi
3337   fi
3338
3339
3340
3341
3342   ac_ext=C
3343 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3344 ac_cpp='$CXXCPP $CPPFLAGS'
3345 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3346 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3347 cross_compiling=$ac_cv_prog_cxx_cross
3348
3349   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3350 echo "configure:3351: checking for __builtin_sqrtf declaration" >&5
3351   cat > conftest.$ac_ext <<EOF
3352 #line 3353 "configure"
3353 #include "confdefs.h"
3354 #include <math.h>
3355 int main() {
3356  __builtin_sqrtf(0);
3357 ; return 0; }
3358 EOF
3359 if { (eval echo configure:3360: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3360   rm -rf conftest*
3361   use___builtin_sqrtf=yes
3362 else
3363   echo "configure: failed program was:" >&5
3364   cat conftest.$ac_ext >&5
3365   rm -rf conftest*
3366   use___builtin_sqrtf=no
3367 fi
3368 rm -f conftest*
3369   echo "$ac_t""$use___builtin_sqrtf" 1>&6
3370   ac_ext=c
3371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3372 ac_cpp='$CPP $CPPFLAGS'
3373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3375 cross_compiling=$ac_cv_prog_cc_cross
3376
3377   if test x$use___builtin_sqrtf = x"yes"; then
3378     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3379 echo "configure:3380: checking for __builtin_sqrtf linkage" >&5
3380       cat > conftest.$ac_ext <<EOF
3381 #line 3382 "configure"
3382 #include "confdefs.h"
3383 #include <math.h>
3384 int main() {
3385  __builtin_sqrtf(0);
3386 ; return 0; }
3387 EOF
3388 if { (eval echo configure:3389: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3389   rm -rf conftest*
3390   link___builtin_sqrtf=yes
3391 else
3392   echo "configure: failed program was:" >&5
3393   cat conftest.$ac_ext >&5
3394   rm -rf conftest*
3395   link___builtin_sqrtf=no
3396 fi
3397 rm -f conftest*
3398     echo "$ac_t""$link___builtin_sqrtf" 1>&6
3399     if test x$link___builtin_sqrtf = x"yes"; then
3400       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3401       cat >> confdefs.h <<EOF
3402 #define ${ac_tr_func} 1
3403 EOF
3404
3405     fi
3406   fi
3407
3408
3409
3410   ac_ext=C
3411 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3412 ac_cpp='$CXXCPP $CPPFLAGS'
3413 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3414 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3415 cross_compiling=$ac_cv_prog_cxx_cross
3416
3417   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
3418 echo "configure:3419: checking for __builtin_fsqrt declaration" >&5
3419   cat > conftest.$ac_ext <<EOF
3420 #line 3421 "configure"
3421 #include "confdefs.h"
3422 #include <math.h>
3423 int main() {
3424  __builtin_fsqrt(0);
3425 ; return 0; }
3426 EOF
3427 if { (eval echo configure:3428: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3428   rm -rf conftest*
3429   use___builtin_fsqrt=yes
3430 else
3431   echo "configure: failed program was:" >&5
3432   cat conftest.$ac_ext >&5
3433   rm -rf conftest*
3434   use___builtin_fsqrt=no
3435 fi
3436 rm -f conftest*
3437   echo "$ac_t""$use___builtin_fsqrt" 1>&6
3438   ac_ext=c
3439 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3440 ac_cpp='$CPP $CPPFLAGS'
3441 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3442 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3443 cross_compiling=$ac_cv_prog_cc_cross
3444
3445   if test x$use___builtin_fsqrt = x"yes"; then
3446     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
3447 echo "configure:3448: checking for __builtin_fsqrt linkage" >&5
3448       cat > conftest.$ac_ext <<EOF
3449 #line 3450 "configure"
3450 #include "confdefs.h"
3451 #include <math.h>
3452 int main() {
3453  __builtin_fsqrt(0);
3454 ; return 0; }
3455 EOF
3456 if { (eval echo configure:3457: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3457   rm -rf conftest*
3458   link___builtin_fsqrt=yes
3459 else
3460   echo "configure: failed program was:" >&5
3461   cat conftest.$ac_ext >&5
3462   rm -rf conftest*
3463   link___builtin_fsqrt=no
3464 fi
3465 rm -f conftest*
3466     echo "$ac_t""$link___builtin_fsqrt" 1>&6
3467     if test x$link___builtin_fsqrt = x"yes"; then
3468       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3469       cat >> confdefs.h <<EOF
3470 #define ${ac_tr_func} 1
3471 EOF
3472
3473     fi
3474   fi
3475
3476
3477
3478   ac_ext=C
3479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3480 ac_cpp='$CXXCPP $CPPFLAGS'
3481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3483 cross_compiling=$ac_cv_prog_cxx_cross
3484
3485   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
3486 echo "configure:3487: checking for __builtin_sqrtl declaration" >&5
3487   cat > conftest.$ac_ext <<EOF
3488 #line 3489 "configure"
3489 #include "confdefs.h"
3490 #include <math.h>
3491 int main() {
3492  __builtin_sqrtl(0);
3493 ; return 0; }
3494 EOF
3495 if { (eval echo configure:3496: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3496   rm -rf conftest*
3497   use___builtin_sqrtl=yes
3498 else
3499   echo "configure: failed program was:" >&5
3500   cat conftest.$ac_ext >&5
3501   rm -rf conftest*
3502   use___builtin_sqrtl=no
3503 fi
3504 rm -f conftest*
3505   echo "$ac_t""$use___builtin_sqrtl" 1>&6
3506   ac_ext=c
3507 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3508 ac_cpp='$CPP $CPPFLAGS'
3509 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3510 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3511 cross_compiling=$ac_cv_prog_cc_cross
3512
3513   if test x$use___builtin_sqrtl = x"yes"; then
3514     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
3515 echo "configure:3516: checking for __builtin_sqrtl linkage" >&5
3516       cat > conftest.$ac_ext <<EOF
3517 #line 3518 "configure"
3518 #include "confdefs.h"
3519 #include <math.h>
3520 int main() {
3521  __builtin_sqrtl(0);
3522 ; return 0; }
3523 EOF
3524 if { (eval echo configure:3525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3525   rm -rf conftest*
3526   link___builtin_sqrtl=yes
3527 else
3528   echo "configure: failed program was:" >&5
3529   cat conftest.$ac_ext >&5
3530   rm -rf conftest*
3531   link___builtin_sqrtl=no
3532 fi
3533 rm -f conftest*
3534     echo "$ac_t""$link___builtin_sqrtl" 1>&6
3535     if test x$link___builtin_sqrtl = x"yes"; then
3536       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3537       cat >> confdefs.h <<EOF
3538 #define ${ac_tr_func} 1
3539 EOF
3540
3541     fi
3542   fi
3543
3544
3545
3546
3547   ac_ext=C
3548 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3549 ac_cpp='$CXXCPP $CPPFLAGS'
3550 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3551 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3552 cross_compiling=$ac_cv_prog_cxx_cross
3553
3554   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
3555 echo "configure:3556: checking for __builtin_sinf declaration" >&5
3556   cat > conftest.$ac_ext <<EOF
3557 #line 3558 "configure"
3558 #include "confdefs.h"
3559 #include <math.h>
3560 int main() {
3561  __builtin_sinf(0);
3562 ; return 0; }
3563 EOF
3564 if { (eval echo configure:3565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3565   rm -rf conftest*
3566   use___builtin_sinf=yes
3567 else
3568   echo "configure: failed program was:" >&5
3569   cat conftest.$ac_ext >&5
3570   rm -rf conftest*
3571   use___builtin_sinf=no
3572 fi
3573 rm -f conftest*
3574   echo "$ac_t""$use___builtin_sinf" 1>&6
3575   ac_ext=c
3576 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3577 ac_cpp='$CPP $CPPFLAGS'
3578 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3579 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3580 cross_compiling=$ac_cv_prog_cc_cross
3581
3582   if test x$use___builtin_sinf = x"yes"; then
3583     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
3584 echo "configure:3585: checking for __builtin_sinf linkage" >&5
3585       cat > conftest.$ac_ext <<EOF
3586 #line 3587 "configure"
3587 #include "confdefs.h"
3588 #include <math.h>
3589 int main() {
3590  __builtin_sinf(0);
3591 ; return 0; }
3592 EOF
3593 if { (eval echo configure:3594: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3594   rm -rf conftest*
3595   link___builtin_sinf=yes
3596 else
3597   echo "configure: failed program was:" >&5
3598   cat conftest.$ac_ext >&5
3599   rm -rf conftest*
3600   link___builtin_sinf=no
3601 fi
3602 rm -f conftest*
3603     echo "$ac_t""$link___builtin_sinf" 1>&6
3604     if test x$link___builtin_sinf = x"yes"; then
3605       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3606       cat >> confdefs.h <<EOF
3607 #define ${ac_tr_func} 1
3608 EOF
3609
3610     fi
3611   fi
3612
3613
3614
3615   ac_ext=C
3616 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3617 ac_cpp='$CXXCPP $CPPFLAGS'
3618 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3619 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3620 cross_compiling=$ac_cv_prog_cxx_cross
3621
3622   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
3623 echo "configure:3624: checking for __builtin_sin declaration" >&5
3624   cat > conftest.$ac_ext <<EOF
3625 #line 3626 "configure"
3626 #include "confdefs.h"
3627 #include <math.h>
3628 int main() {
3629  __builtin_sin(0);
3630 ; return 0; }
3631 EOF
3632 if { (eval echo configure:3633: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3633   rm -rf conftest*
3634   use___builtin_sin=yes
3635 else
3636   echo "configure: failed program was:" >&5
3637   cat conftest.$ac_ext >&5
3638   rm -rf conftest*
3639   use___builtin_sin=no
3640 fi
3641 rm -f conftest*
3642   echo "$ac_t""$use___builtin_sin" 1>&6
3643   ac_ext=c
3644 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3645 ac_cpp='$CPP $CPPFLAGS'
3646 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3647 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3648 cross_compiling=$ac_cv_prog_cc_cross
3649
3650   if test x$use___builtin_sin = x"yes"; then
3651     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
3652 echo "configure:3653: checking for __builtin_sin linkage" >&5
3653       cat > conftest.$ac_ext <<EOF
3654 #line 3655 "configure"
3655 #include "confdefs.h"
3656 #include <math.h>
3657 int main() {
3658  __builtin_sin(0);
3659 ; return 0; }
3660 EOF
3661 if { (eval echo configure:3662: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3662   rm -rf conftest*
3663   link___builtin_sin=yes
3664 else
3665   echo "configure: failed program was:" >&5
3666   cat conftest.$ac_ext >&5
3667   rm -rf conftest*
3668   link___builtin_sin=no
3669 fi
3670 rm -f conftest*
3671     echo "$ac_t""$link___builtin_sin" 1>&6
3672     if test x$link___builtin_sin = x"yes"; then
3673       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3674       cat >> confdefs.h <<EOF
3675 #define ${ac_tr_func} 1
3676 EOF
3677
3678     fi
3679   fi
3680
3681
3682
3683   ac_ext=C
3684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3685 ac_cpp='$CXXCPP $CPPFLAGS'
3686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3688 cross_compiling=$ac_cv_prog_cxx_cross
3689
3690   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
3691 echo "configure:3692: checking for __builtin_sinl declaration" >&5
3692   cat > conftest.$ac_ext <<EOF
3693 #line 3694 "configure"
3694 #include "confdefs.h"
3695 #include <math.h>
3696 int main() {
3697  __builtin_sinl(0);
3698 ; return 0; }
3699 EOF
3700 if { (eval echo configure:3701: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3701   rm -rf conftest*
3702   use___builtin_sinl=yes
3703 else
3704   echo "configure: failed program was:" >&5
3705   cat conftest.$ac_ext >&5
3706   rm -rf conftest*
3707   use___builtin_sinl=no
3708 fi
3709 rm -f conftest*
3710   echo "$ac_t""$use___builtin_sinl" 1>&6
3711   ac_ext=c
3712 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3713 ac_cpp='$CPP $CPPFLAGS'
3714 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3715 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3716 cross_compiling=$ac_cv_prog_cc_cross
3717
3718   if test x$use___builtin_sinl = x"yes"; then
3719     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
3720 echo "configure:3721: checking for __builtin_sinl linkage" >&5
3721       cat > conftest.$ac_ext <<EOF
3722 #line 3723 "configure"
3723 #include "confdefs.h"
3724 #include <math.h>
3725 int main() {
3726  __builtin_sinl(0);
3727 ; return 0; }
3728 EOF
3729 if { (eval echo configure:3730: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3730   rm -rf conftest*
3731   link___builtin_sinl=yes
3732 else
3733   echo "configure: failed program was:" >&5
3734   cat conftest.$ac_ext >&5
3735   rm -rf conftest*
3736   link___builtin_sinl=no
3737 fi
3738 rm -f conftest*
3739     echo "$ac_t""$link___builtin_sinl" 1>&6
3740     if test x$link___builtin_sinl = x"yes"; then
3741       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3742       cat >> confdefs.h <<EOF
3743 #define ${ac_tr_func} 1
3744 EOF
3745
3746     fi
3747   fi
3748
3749
3750
3751
3752   ac_ext=C
3753 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3754 ac_cpp='$CXXCPP $CPPFLAGS'
3755 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3756 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3757 cross_compiling=$ac_cv_prog_cxx_cross
3758
3759   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
3760 echo "configure:3761: checking for __builtin_cosf declaration" >&5
3761   cat > conftest.$ac_ext <<EOF
3762 #line 3763 "configure"
3763 #include "confdefs.h"
3764 #include <math.h>
3765 int main() {
3766  __builtin_cosf(0);
3767 ; return 0; }
3768 EOF
3769 if { (eval echo configure:3770: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3770   rm -rf conftest*
3771   use___builtin_cosf=yes
3772 else
3773   echo "configure: failed program was:" >&5
3774   cat conftest.$ac_ext >&5
3775   rm -rf conftest*
3776   use___builtin_cosf=no
3777 fi
3778 rm -f conftest*
3779   echo "$ac_t""$use___builtin_cosf" 1>&6
3780   ac_ext=c
3781 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3782 ac_cpp='$CPP $CPPFLAGS'
3783 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3784 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3785 cross_compiling=$ac_cv_prog_cc_cross
3786
3787   if test x$use___builtin_cosf = x"yes"; then
3788     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
3789 echo "configure:3790: checking for __builtin_cosf linkage" >&5
3790       cat > conftest.$ac_ext <<EOF
3791 #line 3792 "configure"
3792 #include "confdefs.h"
3793 #include <math.h>
3794 int main() {
3795  __builtin_cosf(0);
3796 ; return 0; }
3797 EOF
3798 if { (eval echo configure:3799: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3799   rm -rf conftest*
3800   link___builtin_cosf=yes
3801 else
3802   echo "configure: failed program was:" >&5
3803   cat conftest.$ac_ext >&5
3804   rm -rf conftest*
3805   link___builtin_cosf=no
3806 fi
3807 rm -f conftest*
3808     echo "$ac_t""$link___builtin_cosf" 1>&6
3809     if test x$link___builtin_cosf = x"yes"; then
3810       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3811       cat >> confdefs.h <<EOF
3812 #define ${ac_tr_func} 1
3813 EOF
3814
3815     fi
3816   fi
3817
3818
3819
3820   ac_ext=C
3821 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3822 ac_cpp='$CXXCPP $CPPFLAGS'
3823 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3824 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3825 cross_compiling=$ac_cv_prog_cxx_cross
3826
3827   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
3828 echo "configure:3829: checking for __builtin_cos declaration" >&5
3829   cat > conftest.$ac_ext <<EOF
3830 #line 3831 "configure"
3831 #include "confdefs.h"
3832 #include <math.h>
3833 int main() {
3834  __builtin_cos(0);
3835 ; return 0; }
3836 EOF
3837 if { (eval echo configure:3838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3838   rm -rf conftest*
3839   use___builtin_cos=yes
3840 else
3841   echo "configure: failed program was:" >&5
3842   cat conftest.$ac_ext >&5
3843   rm -rf conftest*
3844   use___builtin_cos=no
3845 fi
3846 rm -f conftest*
3847   echo "$ac_t""$use___builtin_cos" 1>&6
3848   ac_ext=c
3849 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3850 ac_cpp='$CPP $CPPFLAGS'
3851 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3852 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3853 cross_compiling=$ac_cv_prog_cc_cross
3854
3855   if test x$use___builtin_cos = x"yes"; then
3856     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
3857 echo "configure:3858: checking for __builtin_cos linkage" >&5
3858       cat > conftest.$ac_ext <<EOF
3859 #line 3860 "configure"
3860 #include "confdefs.h"
3861 #include <math.h>
3862 int main() {
3863  __builtin_cos(0);
3864 ; return 0; }
3865 EOF
3866 if { (eval echo configure:3867: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3867   rm -rf conftest*
3868   link___builtin_cos=yes
3869 else
3870   echo "configure: failed program was:" >&5
3871   cat conftest.$ac_ext >&5
3872   rm -rf conftest*
3873   link___builtin_cos=no
3874 fi
3875 rm -f conftest*
3876     echo "$ac_t""$link___builtin_cos" 1>&6
3877     if test x$link___builtin_cos = x"yes"; then
3878       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3879       cat >> confdefs.h <<EOF
3880 #define ${ac_tr_func} 1
3881 EOF
3882
3883     fi
3884   fi
3885
3886
3887
3888   ac_ext=C
3889 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3890 ac_cpp='$CXXCPP $CPPFLAGS'
3891 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3892 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3893 cross_compiling=$ac_cv_prog_cxx_cross
3894
3895   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
3896 echo "configure:3897: checking for __builtin_cosl declaration" >&5
3897   cat > conftest.$ac_ext <<EOF
3898 #line 3899 "configure"
3899 #include "confdefs.h"
3900 #include <math.h>
3901 int main() {
3902  __builtin_cosl(0);
3903 ; return 0; }
3904 EOF
3905 if { (eval echo configure:3906: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3906   rm -rf conftest*
3907   use___builtin_cosl=yes
3908 else
3909   echo "configure: failed program was:" >&5
3910   cat conftest.$ac_ext >&5
3911   rm -rf conftest*
3912   use___builtin_cosl=no
3913 fi
3914 rm -f conftest*
3915   echo "$ac_t""$use___builtin_cosl" 1>&6
3916   ac_ext=c
3917 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3918 ac_cpp='$CPP $CPPFLAGS'
3919 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3920 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3921 cross_compiling=$ac_cv_prog_cc_cross
3922
3923   if test x$use___builtin_cosl = x"yes"; then
3924     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
3925 echo "configure:3926: checking for __builtin_cosl linkage" >&5
3926       cat > conftest.$ac_ext <<EOF
3927 #line 3928 "configure"
3928 #include "confdefs.h"
3929 #include <math.h>
3930 int main() {
3931  __builtin_cosl(0);
3932 ; return 0; }
3933 EOF
3934 if { (eval echo configure:3935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3935   rm -rf conftest*
3936   link___builtin_cosl=yes
3937 else
3938   echo "configure: failed program was:" >&5
3939   cat conftest.$ac_ext >&5
3940   rm -rf conftest*
3941   link___builtin_cosl=no
3942 fi
3943 rm -f conftest*
3944     echo "$ac_t""$link___builtin_cosl" 1>&6
3945     if test x$link___builtin_cosl = x"yes"; then
3946       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3947       cat >> confdefs.h <<EOF
3948 #define ${ac_tr_func} 1
3949 EOF
3950
3951     fi
3952   fi
3953
3954
3955               dummyvar=no
3956   if test x$dummyvar = x"yes"; then
3957     cat >> confdefs.h <<\EOF
3958 #define HAVE___BUILTIN_ABS 1
3959 EOF
3960
3961     cat >> confdefs.h <<\EOF
3962 #define HAVE___BUILTIN_LABS 1
3963 EOF
3964
3965     cat >> confdefs.h <<\EOF
3966 #define HAVE___BUILTIN_COS 1
3967 EOF
3968
3969     cat >> confdefs.h <<\EOF
3970 #define HAVE___BUILTIN_COSF 1
3971 EOF
3972
3973     cat >> confdefs.h <<\EOF
3974 #define HAVE___BUILTIN_COSL 1
3975 EOF
3976
3977     cat >> confdefs.h <<\EOF
3978 #define HAVE___BUILTIN_FABS 1
3979 EOF
3980
3981     cat >> confdefs.h <<\EOF
3982 #define HAVE___BUILTIN_FABSF 1
3983 EOF
3984
3985     cat >> confdefs.h <<\EOF
3986 #define HAVE___BUILTIN_FABSL 1
3987 EOF
3988
3989     cat >> confdefs.h <<\EOF
3990 #define HAVE___BUILTIN_SIN 1
3991 EOF
3992
3993     cat >> confdefs.h <<\EOF
3994 #define HAVE___BUILTIN_SINF 1
3995 EOF
3996
3997     cat >> confdefs.h <<\EOF
3998 #define HAVE___BUILTIN_SINL 1
3999 EOF
4000
4001     cat >> confdefs.h <<\EOF
4002 #define HAVE___BUILTIN_FSQRT 1
4003 EOF
4004
4005     cat >> confdefs.h <<\EOF
4006 #define HAVE___BUILTIN_SQRTF 1
4007 EOF
4008
4009     cat >> confdefs.h <<\EOF
4010 #define HAVE___BUILTIN_SQRTL 1
4011 EOF
4012
4013   fi
4014
4015
4016   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4017   ac_save_CXXFLAGS="$CXXFLAGS"
4018   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4019
4020     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4021 echo "configure:4022: checking for sin in -lm" >&5
4022 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4023 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4024   echo $ac_n "(cached) $ac_c" 1>&6
4025 else
4026   ac_save_LIBS="$LIBS"
4027 LIBS="-lm  $LIBS"
4028 cat > conftest.$ac_ext <<EOF
4029 #line 4030 "configure"
4030 #include "confdefs.h"
4031 /* Override any gcc2 internal prototype to avoid an error.  */
4032 /* We use char because int might match the return type of a gcc2
4033     builtin and then its argument prototype would still apply.  */
4034 char sin();
4035
4036 int main() {
4037 sin()
4038 ; return 0; }
4039 EOF
4040 if { (eval echo configure:4041: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4041   rm -rf conftest*
4042   eval "ac_cv_lib_$ac_lib_var=yes"
4043 else
4044   echo "configure: failed program was:" >&5
4045   cat conftest.$ac_ext >&5
4046   rm -rf conftest*
4047   eval "ac_cv_lib_$ac_lib_var=no"
4048 fi
4049 rm -f conftest*
4050 LIBS="$ac_save_LIBS"
4051
4052 fi
4053 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4054   echo "$ac_t""yes" 1>&6
4055   libm="-lm"
4056 else
4057   echo "$ac_t""no" 1>&6
4058 fi
4059
4060   ac_save_LIBS="$LIBS"
4061   LIBS="$LIBS $libm"
4062
4063     for ac_func in strtof strtold
4064 do
4065 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4066 echo "configure:4067: checking for $ac_func" >&5
4067 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4068   echo $ac_n "(cached) $ac_c" 1>&6
4069 else
4070   cat > conftest.$ac_ext <<EOF
4071 #line 4072 "configure"
4072 #include "confdefs.h"
4073 /* System header to define __stub macros and hopefully few prototypes,
4074     which can conflict with char $ac_func(); below.  */
4075 #include <assert.h>
4076 /* Override any gcc2 internal prototype to avoid an error.  */
4077 /* We use char because int might match the return type of a gcc2
4078     builtin and then its argument prototype would still apply.  */
4079 char $ac_func();
4080
4081 int main() {
4082
4083 /* The GNU C library defines this for functions which it implements
4084     to always fail with ENOSYS.  Some functions are actually named
4085     something starting with __ and the normal name is an alias.  */
4086 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4087 choke me
4088 #else
4089 $ac_func();
4090 #endif
4091
4092 ; return 0; }
4093 EOF
4094 if { (eval echo configure:4095: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4095   rm -rf conftest*
4096   eval "ac_cv_func_$ac_func=yes"
4097 else
4098   echo "configure: failed program was:" >&5
4099   cat conftest.$ac_ext >&5
4100   rm -rf conftest*
4101   eval "ac_cv_func_$ac_func=no"
4102 fi
4103 rm -f conftest*
4104 fi
4105
4106 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4107   echo "$ac_t""yes" 1>&6
4108     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4109   cat >> confdefs.h <<EOF
4110 #define $ac_tr_func 1
4111 EOF
4112
4113 else
4114   echo "$ac_t""no" 1>&6
4115 fi
4116 done
4117
4118
4119
4120
4121   ac_ext=C
4122 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4123 ac_cpp='$CXXCPP $CPPFLAGS'
4124 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4125 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4126 cross_compiling=$ac_cv_prog_cxx_cross
4127
4128   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4129 echo "configure:4130: checking for isinf declaration" >&5
4130   cat > conftest.$ac_ext <<EOF
4131 #line 4132 "configure"
4132 #include "confdefs.h"
4133 #include <math.h>
4134 int main() {
4135  isinf(0);
4136 ; return 0; }
4137 EOF
4138 if { (eval echo configure:4139: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4139   rm -rf conftest*
4140   use_isinf=yes
4141 else
4142   echo "configure: failed program was:" >&5
4143   cat conftest.$ac_ext >&5
4144   rm -rf conftest*
4145   use_isinf=no
4146 fi
4147 rm -f conftest*
4148   echo "$ac_t""$use_isinf" 1>&6
4149   ac_ext=c
4150 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4151 ac_cpp='$CPP $CPPFLAGS'
4152 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4153 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4154 cross_compiling=$ac_cv_prog_cc_cross
4155
4156   if test x$use_isinf = x"yes"; then
4157     for ac_func in isinf
4158 do
4159 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4160 echo "configure:4161: checking for $ac_func" >&5
4161 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4162   echo $ac_n "(cached) $ac_c" 1>&6
4163 else
4164   cat > conftest.$ac_ext <<EOF
4165 #line 4166 "configure"
4166 #include "confdefs.h"
4167 /* System header to define __stub macros and hopefully few prototypes,
4168     which can conflict with char $ac_func(); below.  */
4169 #include <assert.h>
4170 /* Override any gcc2 internal prototype to avoid an error.  */
4171 /* We use char because int might match the return type of a gcc2
4172     builtin and then its argument prototype would still apply.  */
4173 char $ac_func();
4174
4175 int main() {
4176
4177 /* The GNU C library defines this for functions which it implements
4178     to always fail with ENOSYS.  Some functions are actually named
4179     something starting with __ and the normal name is an alias.  */
4180 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4181 choke me
4182 #else
4183 $ac_func();
4184 #endif
4185
4186 ; return 0; }
4187 EOF
4188 if { (eval echo configure:4189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4189   rm -rf conftest*
4190   eval "ac_cv_func_$ac_func=yes"
4191 else
4192   echo "configure: failed program was:" >&5
4193   cat conftest.$ac_ext >&5
4194   rm -rf conftest*
4195   eval "ac_cv_func_$ac_func=no"
4196 fi
4197 rm -f conftest*
4198 fi
4199
4200 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4201   echo "$ac_t""yes" 1>&6
4202     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4203   cat >> confdefs.h <<EOF
4204 #define $ac_tr_func 1
4205 EOF
4206
4207 else
4208   echo "$ac_t""no" 1>&6
4209 fi
4210 done
4211
4212   fi
4213
4214
4215
4216   ac_ext=C
4217 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4218 ac_cpp='$CXXCPP $CPPFLAGS'
4219 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4220 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4221 cross_compiling=$ac_cv_prog_cxx_cross
4222
4223   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4224 echo "configure:4225: checking for isnan declaration" >&5
4225   cat > conftest.$ac_ext <<EOF
4226 #line 4227 "configure"
4227 #include "confdefs.h"
4228 #include <math.h>
4229 int main() {
4230  isnan(0);
4231 ; return 0; }
4232 EOF
4233 if { (eval echo configure:4234: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4234   rm -rf conftest*
4235   use_isnan=yes
4236 else
4237   echo "configure: failed program was:" >&5
4238   cat conftest.$ac_ext >&5
4239   rm -rf conftest*
4240   use_isnan=no
4241 fi
4242 rm -f conftest*
4243   echo "$ac_t""$use_isnan" 1>&6
4244   ac_ext=c
4245 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4246 ac_cpp='$CPP $CPPFLAGS'
4247 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4248 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4249 cross_compiling=$ac_cv_prog_cc_cross
4250
4251   if test x$use_isnan = x"yes"; then
4252     for ac_func in isnan
4253 do
4254 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4255 echo "configure:4256: checking for $ac_func" >&5
4256 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4257   echo $ac_n "(cached) $ac_c" 1>&6
4258 else
4259   cat > conftest.$ac_ext <<EOF
4260 #line 4261 "configure"
4261 #include "confdefs.h"
4262 /* System header to define __stub macros and hopefully few prototypes,
4263     which can conflict with char $ac_func(); below.  */
4264 #include <assert.h>
4265 /* Override any gcc2 internal prototype to avoid an error.  */
4266 /* We use char because int might match the return type of a gcc2
4267     builtin and then its argument prototype would still apply.  */
4268 char $ac_func();
4269
4270 int main() {
4271
4272 /* The GNU C library defines this for functions which it implements
4273     to always fail with ENOSYS.  Some functions are actually named
4274     something starting with __ and the normal name is an alias.  */
4275 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4276 choke me
4277 #else
4278 $ac_func();
4279 #endif
4280
4281 ; return 0; }
4282 EOF
4283 if { (eval echo configure:4284: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4284   rm -rf conftest*
4285   eval "ac_cv_func_$ac_func=yes"
4286 else
4287   echo "configure: failed program was:" >&5
4288   cat conftest.$ac_ext >&5
4289   rm -rf conftest*
4290   eval "ac_cv_func_$ac_func=no"
4291 fi
4292 rm -f conftest*
4293 fi
4294
4295 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4296   echo "$ac_t""yes" 1>&6
4297     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4298   cat >> confdefs.h <<EOF
4299 #define $ac_tr_func 1
4300 EOF
4301
4302 else
4303   echo "$ac_t""no" 1>&6
4304 fi
4305 done
4306
4307   fi
4308
4309
4310
4311   ac_ext=C
4312 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4313 ac_cpp='$CXXCPP $CPPFLAGS'
4314 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4315 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4316 cross_compiling=$ac_cv_prog_cxx_cross
4317
4318   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
4319 echo "configure:4320: checking for finite declaration" >&5
4320   cat > conftest.$ac_ext <<EOF
4321 #line 4322 "configure"
4322 #include "confdefs.h"
4323 #include <math.h>
4324 int main() {
4325  finite(0);
4326 ; return 0; }
4327 EOF
4328 if { (eval echo configure:4329: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4329   rm -rf conftest*
4330   use_finite=yes
4331 else
4332   echo "configure: failed program was:" >&5
4333   cat conftest.$ac_ext >&5
4334   rm -rf conftest*
4335   use_finite=no
4336 fi
4337 rm -f conftest*
4338   echo "$ac_t""$use_finite" 1>&6
4339   ac_ext=c
4340 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4341 ac_cpp='$CPP $CPPFLAGS'
4342 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4343 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4344 cross_compiling=$ac_cv_prog_cc_cross
4345
4346   if test x$use_finite = x"yes"; then
4347     for ac_func in finite
4348 do
4349 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4350 echo "configure:4351: checking for $ac_func" >&5
4351 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4352   echo $ac_n "(cached) $ac_c" 1>&6
4353 else
4354   cat > conftest.$ac_ext <<EOF
4355 #line 4356 "configure"
4356 #include "confdefs.h"
4357 /* System header to define __stub macros and hopefully few prototypes,
4358     which can conflict with char $ac_func(); below.  */
4359 #include <assert.h>
4360 /* Override any gcc2 internal prototype to avoid an error.  */
4361 /* We use char because int might match the return type of a gcc2
4362     builtin and then its argument prototype would still apply.  */
4363 char $ac_func();
4364
4365 int main() {
4366
4367 /* The GNU C library defines this for functions which it implements
4368     to always fail with ENOSYS.  Some functions are actually named
4369     something starting with __ and the normal name is an alias.  */
4370 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4371 choke me
4372 #else
4373 $ac_func();
4374 #endif
4375
4376 ; return 0; }
4377 EOF
4378 if { (eval echo configure:4379: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4379   rm -rf conftest*
4380   eval "ac_cv_func_$ac_func=yes"
4381 else
4382   echo "configure: failed program was:" >&5
4383   cat conftest.$ac_ext >&5
4384   rm -rf conftest*
4385   eval "ac_cv_func_$ac_func=no"
4386 fi
4387 rm -f conftest*
4388 fi
4389
4390 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4391   echo "$ac_t""yes" 1>&6
4392     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4393   cat >> confdefs.h <<EOF
4394 #define $ac_tr_func 1
4395 EOF
4396
4397 else
4398   echo "$ac_t""no" 1>&6
4399 fi
4400 done
4401
4402   fi
4403
4404
4405
4406   ac_ext=C
4407 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4408 ac_cpp='$CXXCPP $CPPFLAGS'
4409 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4410 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4411 cross_compiling=$ac_cv_prog_cxx_cross
4412
4413   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
4414 echo "configure:4415: checking for copysign declaration" >&5
4415   cat > conftest.$ac_ext <<EOF
4416 #line 4417 "configure"
4417 #include "confdefs.h"
4418 #include <math.h>
4419 int main() {
4420  copysign(0, 0);
4421 ; return 0; }
4422 EOF
4423 if { (eval echo configure:4424: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4424   rm -rf conftest*
4425   use_copysign=yes
4426 else
4427   echo "configure: failed program was:" >&5
4428   cat conftest.$ac_ext >&5
4429   rm -rf conftest*
4430   use_copysign=no
4431 fi
4432 rm -f conftest*
4433   echo "$ac_t""$use_copysign" 1>&6
4434   ac_ext=c
4435 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4436 ac_cpp='$CPP $CPPFLAGS'
4437 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4438 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4439 cross_compiling=$ac_cv_prog_cc_cross
4440
4441   if test x$use_copysign = x"yes"; then
4442     for ac_func in copysign
4443 do
4444 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4445 echo "configure:4446: checking for $ac_func" >&5
4446 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4447   echo $ac_n "(cached) $ac_c" 1>&6
4448 else
4449   cat > conftest.$ac_ext <<EOF
4450 #line 4451 "configure"
4451 #include "confdefs.h"
4452 /* System header to define __stub macros and hopefully few prototypes,
4453     which can conflict with char $ac_func(); below.  */
4454 #include <assert.h>
4455 /* Override any gcc2 internal prototype to avoid an error.  */
4456 /* We use char because int might match the return type of a gcc2
4457     builtin and then its argument prototype would still apply.  */
4458 char $ac_func();
4459
4460 int main() {
4461
4462 /* The GNU C library defines this for functions which it implements
4463     to always fail with ENOSYS.  Some functions are actually named
4464     something starting with __ and the normal name is an alias.  */
4465 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4466 choke me
4467 #else
4468 $ac_func();
4469 #endif
4470
4471 ; return 0; }
4472 EOF
4473 if { (eval echo configure:4474: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4474   rm -rf conftest*
4475   eval "ac_cv_func_$ac_func=yes"
4476 else
4477   echo "configure: failed program was:" >&5
4478   cat conftest.$ac_ext >&5
4479   rm -rf conftest*
4480   eval "ac_cv_func_$ac_func=no"
4481 fi
4482 rm -f conftest*
4483 fi
4484
4485 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4486   echo "$ac_t""yes" 1>&6
4487     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4488   cat >> confdefs.h <<EOF
4489 #define $ac_tr_func 1
4490 EOF
4491
4492 else
4493   echo "$ac_t""no" 1>&6
4494 fi
4495 done
4496
4497   fi
4498
4499
4500
4501   ac_ext=C
4502 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4503 ac_cpp='$CXXCPP $CPPFLAGS'
4504 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4505 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4506 cross_compiling=$ac_cv_prog_cxx_cross
4507
4508   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
4509 echo "configure:4510: checking for sincos declaration" >&5
4510   cat > conftest.$ac_ext <<EOF
4511 #line 4512 "configure"
4512 #include "confdefs.h"
4513 #include <math.h>
4514 int main() {
4515  sincos(0, 0, 0);
4516 ; return 0; }
4517 EOF
4518 if { (eval echo configure:4519: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4519   rm -rf conftest*
4520   use_sincos=yes
4521 else
4522   echo "configure: failed program was:" >&5
4523   cat conftest.$ac_ext >&5
4524   rm -rf conftest*
4525   use_sincos=no
4526 fi
4527 rm -f conftest*
4528   echo "$ac_t""$use_sincos" 1>&6
4529   ac_ext=c
4530 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4531 ac_cpp='$CPP $CPPFLAGS'
4532 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4533 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4534 cross_compiling=$ac_cv_prog_cc_cross
4535
4536   if test x$use_sincos = x"yes"; then
4537     for ac_func in sincos
4538 do
4539 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4540 echo "configure:4541: checking for $ac_func" >&5
4541 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4542   echo $ac_n "(cached) $ac_c" 1>&6
4543 else
4544   cat > conftest.$ac_ext <<EOF
4545 #line 4546 "configure"
4546 #include "confdefs.h"
4547 /* System header to define __stub macros and hopefully few prototypes,
4548     which can conflict with char $ac_func(); below.  */
4549 #include <assert.h>
4550 /* Override any gcc2 internal prototype to avoid an error.  */
4551 /* We use char because int might match the return type of a gcc2
4552     builtin and then its argument prototype would still apply.  */
4553 char $ac_func();
4554
4555 int main() {
4556
4557 /* The GNU C library defines this for functions which it implements
4558     to always fail with ENOSYS.  Some functions are actually named
4559     something starting with __ and the normal name is an alias.  */
4560 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4561 choke me
4562 #else
4563 $ac_func();
4564 #endif
4565
4566 ; return 0; }
4567 EOF
4568 if { (eval echo configure:4569: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4569   rm -rf conftest*
4570   eval "ac_cv_func_$ac_func=yes"
4571 else
4572   echo "configure: failed program was:" >&5
4573   cat conftest.$ac_ext >&5
4574   rm -rf conftest*
4575   eval "ac_cv_func_$ac_func=no"
4576 fi
4577 rm -f conftest*
4578 fi
4579
4580 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4581   echo "$ac_t""yes" 1>&6
4582     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4583   cat >> confdefs.h <<EOF
4584 #define $ac_tr_func 1
4585 EOF
4586
4587 else
4588   echo "$ac_t""no" 1>&6
4589 fi
4590 done
4591
4592   fi
4593
4594
4595
4596   ac_ext=C
4597 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4598 ac_cpp='$CXXCPP $CPPFLAGS'
4599 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4600 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4601 cross_compiling=$ac_cv_prog_cxx_cross
4602
4603   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
4604 echo "configure:4605: checking for fpclass declaration" >&5
4605   cat > conftest.$ac_ext <<EOF
4606 #line 4607 "configure"
4607 #include "confdefs.h"
4608 #include <math.h>
4609 int main() {
4610  fpclass(0);
4611 ; return 0; }
4612 EOF
4613 if { (eval echo configure:4614: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4614   rm -rf conftest*
4615   use_fpclass=yes
4616 else
4617   echo "configure: failed program was:" >&5
4618   cat conftest.$ac_ext >&5
4619   rm -rf conftest*
4620   use_fpclass=no
4621 fi
4622 rm -f conftest*
4623   echo "$ac_t""$use_fpclass" 1>&6
4624   ac_ext=c
4625 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4626 ac_cpp='$CPP $CPPFLAGS'
4627 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4628 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4629 cross_compiling=$ac_cv_prog_cc_cross
4630
4631   if test x$use_fpclass = x"yes"; then
4632     for ac_func in fpclass
4633 do
4634 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4635 echo "configure:4636: checking for $ac_func" >&5
4636 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4637   echo $ac_n "(cached) $ac_c" 1>&6
4638 else
4639   cat > conftest.$ac_ext <<EOF
4640 #line 4641 "configure"
4641 #include "confdefs.h"
4642 /* System header to define __stub macros and hopefully few prototypes,
4643     which can conflict with char $ac_func(); below.  */
4644 #include <assert.h>
4645 /* Override any gcc2 internal prototype to avoid an error.  */
4646 /* We use char because int might match the return type of a gcc2
4647     builtin and then its argument prototype would still apply.  */
4648 char $ac_func();
4649
4650 int main() {
4651
4652 /* The GNU C library defines this for functions which it implements
4653     to always fail with ENOSYS.  Some functions are actually named
4654     something starting with __ and the normal name is an alias.  */
4655 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4656 choke me
4657 #else
4658 $ac_func();
4659 #endif
4660
4661 ; return 0; }
4662 EOF
4663 if { (eval echo configure:4664: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4664   rm -rf conftest*
4665   eval "ac_cv_func_$ac_func=yes"
4666 else
4667   echo "configure: failed program was:" >&5
4668   cat conftest.$ac_ext >&5
4669   rm -rf conftest*
4670   eval "ac_cv_func_$ac_func=no"
4671 fi
4672 rm -f conftest*
4673 fi
4674
4675 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4676   echo "$ac_t""yes" 1>&6
4677     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4678   cat >> confdefs.h <<EOF
4679 #define $ac_tr_func 1
4680 EOF
4681
4682 else
4683   echo "$ac_t""no" 1>&6
4684 fi
4685 done
4686
4687   fi
4688
4689
4690
4691   ac_ext=C
4692 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4693 ac_cpp='$CXXCPP $CPPFLAGS'
4694 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4695 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4696 cross_compiling=$ac_cv_prog_cxx_cross
4697
4698   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
4699 echo "configure:4700: checking for qfpclass declaration" >&5
4700   cat > conftest.$ac_ext <<EOF
4701 #line 4702 "configure"
4702 #include "confdefs.h"
4703 #include <math.h>
4704 int main() {
4705  qfpclass(0);
4706 ; return 0; }
4707 EOF
4708 if { (eval echo configure:4709: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4709   rm -rf conftest*
4710   use_qfpclass=yes
4711 else
4712   echo "configure: failed program was:" >&5
4713   cat conftest.$ac_ext >&5
4714   rm -rf conftest*
4715   use_qfpclass=no
4716 fi
4717 rm -f conftest*
4718   echo "$ac_t""$use_qfpclass" 1>&6
4719   ac_ext=c
4720 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4721 ac_cpp='$CPP $CPPFLAGS'
4722 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4723 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4724 cross_compiling=$ac_cv_prog_cc_cross
4725
4726   if test x$use_qfpclass = x"yes"; then
4727     for ac_func in qfpclass
4728 do
4729 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4730 echo "configure:4731: checking for $ac_func" >&5
4731 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4732   echo $ac_n "(cached) $ac_c" 1>&6
4733 else
4734   cat > conftest.$ac_ext <<EOF
4735 #line 4736 "configure"
4736 #include "confdefs.h"
4737 /* System header to define __stub macros and hopefully few prototypes,
4738     which can conflict with char $ac_func(); below.  */
4739 #include <assert.h>
4740 /* Override any gcc2 internal prototype to avoid an error.  */
4741 /* We use char because int might match the return type of a gcc2
4742     builtin and then its argument prototype would still apply.  */
4743 char $ac_func();
4744
4745 int main() {
4746
4747 /* The GNU C library defines this for functions which it implements
4748     to always fail with ENOSYS.  Some functions are actually named
4749     something starting with __ and the normal name is an alias.  */
4750 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4751 choke me
4752 #else
4753 $ac_func();
4754 #endif
4755
4756 ; return 0; }
4757 EOF
4758 if { (eval echo configure:4759: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4759   rm -rf conftest*
4760   eval "ac_cv_func_$ac_func=yes"
4761 else
4762   echo "configure: failed program was:" >&5
4763   cat conftest.$ac_ext >&5
4764   rm -rf conftest*
4765   eval "ac_cv_func_$ac_func=no"
4766 fi
4767 rm -f conftest*
4768 fi
4769
4770 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4771   echo "$ac_t""yes" 1>&6
4772     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4773   cat >> confdefs.h <<EOF
4774 #define $ac_tr_func 1
4775 EOF
4776
4777 else
4778   echo "$ac_t""no" 1>&6
4779 fi
4780 done
4781
4782   fi
4783
4784
4785
4786
4787   ac_ext=C
4788 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4789 ac_cpp='$CXXCPP $CPPFLAGS'
4790 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4791 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4792 cross_compiling=$ac_cv_prog_cxx_cross
4793
4794   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
4795 echo "configure:4796: checking for isnanf declaration" >&5
4796   cat > conftest.$ac_ext <<EOF
4797 #line 4798 "configure"
4798 #include "confdefs.h"
4799 #include <math.h>
4800 int main() {
4801  isnanf(0);
4802 ; return 0; }
4803 EOF
4804 if { (eval echo configure:4805: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4805   rm -rf conftest*
4806   use_isnanf=yes
4807 else
4808   echo "configure: failed program was:" >&5
4809   cat conftest.$ac_ext >&5
4810   rm -rf conftest*
4811   use_isnanf=no
4812 fi
4813 rm -f conftest*
4814   echo "$ac_t""$use_isnanf" 1>&6
4815   ac_ext=c
4816 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4817 ac_cpp='$CPP $CPPFLAGS'
4818 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4819 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4820 cross_compiling=$ac_cv_prog_cc_cross
4821
4822   if test x$use_isnanf = x"yes"; then
4823     for ac_func in isnanf
4824 do
4825 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4826 echo "configure:4827: checking for $ac_func" >&5
4827 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4828   echo $ac_n "(cached) $ac_c" 1>&6
4829 else
4830   cat > conftest.$ac_ext <<EOF
4831 #line 4832 "configure"
4832 #include "confdefs.h"
4833 /* System header to define __stub macros and hopefully few prototypes,
4834     which can conflict with char $ac_func(); below.  */
4835 #include <assert.h>
4836 /* Override any gcc2 internal prototype to avoid an error.  */
4837 /* We use char because int might match the return type of a gcc2
4838     builtin and then its argument prototype would still apply.  */
4839 char $ac_func();
4840
4841 int main() {
4842
4843 /* The GNU C library defines this for functions which it implements
4844     to always fail with ENOSYS.  Some functions are actually named
4845     something starting with __ and the normal name is an alias.  */
4846 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4847 choke me
4848 #else
4849 $ac_func();
4850 #endif
4851
4852 ; return 0; }
4853 EOF
4854 if { (eval echo configure:4855: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4855   rm -rf conftest*
4856   eval "ac_cv_func_$ac_func=yes"
4857 else
4858   echo "configure: failed program was:" >&5
4859   cat conftest.$ac_ext >&5
4860   rm -rf conftest*
4861   eval "ac_cv_func_$ac_func=no"
4862 fi
4863 rm -f conftest*
4864 fi
4865
4866 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4867   echo "$ac_t""yes" 1>&6
4868     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4869   cat >> confdefs.h <<EOF
4870 #define $ac_tr_func 1
4871 EOF
4872
4873 else
4874   echo "$ac_t""no" 1>&6
4875 fi
4876 done
4877
4878   fi
4879
4880
4881
4882   ac_ext=C
4883 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4884 ac_cpp='$CXXCPP $CPPFLAGS'
4885 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4886 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4887 cross_compiling=$ac_cv_prog_cxx_cross
4888
4889   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
4890 echo "configure:4891: checking for isinff declaration" >&5
4891   cat > conftest.$ac_ext <<EOF
4892 #line 4893 "configure"
4893 #include "confdefs.h"
4894 #include <math.h>
4895 int main() {
4896  isinff(0);
4897 ; return 0; }
4898 EOF
4899 if { (eval echo configure:4900: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4900   rm -rf conftest*
4901   use_isinff=yes
4902 else
4903   echo "configure: failed program was:" >&5
4904   cat conftest.$ac_ext >&5
4905   rm -rf conftest*
4906   use_isinff=no
4907 fi
4908 rm -f conftest*
4909   echo "$ac_t""$use_isinff" 1>&6
4910   ac_ext=c
4911 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4912 ac_cpp='$CPP $CPPFLAGS'
4913 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4914 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4915 cross_compiling=$ac_cv_prog_cc_cross
4916
4917   if test x$use_isinff = x"yes"; then
4918     for ac_func in isinff
4919 do
4920 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4921 echo "configure:4922: checking for $ac_func" >&5
4922 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4923   echo $ac_n "(cached) $ac_c" 1>&6
4924 else
4925   cat > conftest.$ac_ext <<EOF
4926 #line 4927 "configure"
4927 #include "confdefs.h"
4928 /* System header to define __stub macros and hopefully few prototypes,
4929     which can conflict with char $ac_func(); below.  */
4930 #include <assert.h>
4931 /* Override any gcc2 internal prototype to avoid an error.  */
4932 /* We use char because int might match the return type of a gcc2
4933     builtin and then its argument prototype would still apply.  */
4934 char $ac_func();
4935
4936 int main() {
4937
4938 /* The GNU C library defines this for functions which it implements
4939     to always fail with ENOSYS.  Some functions are actually named
4940     something starting with __ and the normal name is an alias.  */
4941 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4942 choke me
4943 #else
4944 $ac_func();
4945 #endif
4946
4947 ; return 0; }
4948 EOF
4949 if { (eval echo configure:4950: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4950   rm -rf conftest*
4951   eval "ac_cv_func_$ac_func=yes"
4952 else
4953   echo "configure: failed program was:" >&5
4954   cat conftest.$ac_ext >&5
4955   rm -rf conftest*
4956   eval "ac_cv_func_$ac_func=no"
4957 fi
4958 rm -f conftest*
4959 fi
4960
4961 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4962   echo "$ac_t""yes" 1>&6
4963     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4964   cat >> confdefs.h <<EOF
4965 #define $ac_tr_func 1
4966 EOF
4967
4968 else
4969   echo "$ac_t""no" 1>&6
4970 fi
4971 done
4972
4973   fi
4974
4975
4976
4977   ac_ext=C
4978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4979 ac_cpp='$CXXCPP $CPPFLAGS'
4980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4982 cross_compiling=$ac_cv_prog_cxx_cross
4983
4984   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
4985 echo "configure:4986: checking for acosf declaration" >&5
4986   cat > conftest.$ac_ext <<EOF
4987 #line 4988 "configure"
4988 #include "confdefs.h"
4989 #include <math.h>
4990 int main() {
4991  acosf(0);
4992 ; return 0; }
4993 EOF
4994 if { (eval echo configure:4995: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4995   rm -rf conftest*
4996   use_acosf=yes
4997 else
4998   echo "configure: failed program was:" >&5
4999   cat conftest.$ac_ext >&5
5000   rm -rf conftest*
5001   use_acosf=no
5002 fi
5003 rm -f conftest*
5004   echo "$ac_t""$use_acosf" 1>&6
5005   ac_ext=c
5006 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5007 ac_cpp='$CPP $CPPFLAGS'
5008 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5009 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5010 cross_compiling=$ac_cv_prog_cc_cross
5011
5012   if test x$use_acosf = x"yes"; then
5013     for ac_func in acosf
5014 do
5015 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5016 echo "configure:5017: checking for $ac_func" >&5
5017 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5018   echo $ac_n "(cached) $ac_c" 1>&6
5019 else
5020   cat > conftest.$ac_ext <<EOF
5021 #line 5022 "configure"
5022 #include "confdefs.h"
5023 /* System header to define __stub macros and hopefully few prototypes,
5024     which can conflict with char $ac_func(); below.  */
5025 #include <assert.h>
5026 /* Override any gcc2 internal prototype to avoid an error.  */
5027 /* We use char because int might match the return type of a gcc2
5028     builtin and then its argument prototype would still apply.  */
5029 char $ac_func();
5030
5031 int main() {
5032
5033 /* The GNU C library defines this for functions which it implements
5034     to always fail with ENOSYS.  Some functions are actually named
5035     something starting with __ and the normal name is an alias.  */
5036 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5037 choke me
5038 #else
5039 $ac_func();
5040 #endif
5041
5042 ; return 0; }
5043 EOF
5044 if { (eval echo configure:5045: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5045   rm -rf conftest*
5046   eval "ac_cv_func_$ac_func=yes"
5047 else
5048   echo "configure: failed program was:" >&5
5049   cat conftest.$ac_ext >&5
5050   rm -rf conftest*
5051   eval "ac_cv_func_$ac_func=no"
5052 fi
5053 rm -f conftest*
5054 fi
5055
5056 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5057   echo "$ac_t""yes" 1>&6
5058     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5059   cat >> confdefs.h <<EOF
5060 #define $ac_tr_func 1
5061 EOF
5062
5063 else
5064   echo "$ac_t""no" 1>&6
5065 fi
5066 done
5067
5068   fi
5069
5070
5071
5072   ac_ext=C
5073 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5074 ac_cpp='$CXXCPP $CPPFLAGS'
5075 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5076 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5077 cross_compiling=$ac_cv_prog_cxx_cross
5078
5079   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5080 echo "configure:5081: checking for asinf declaration" >&5
5081   cat > conftest.$ac_ext <<EOF
5082 #line 5083 "configure"
5083 #include "confdefs.h"
5084 #include <math.h>
5085 int main() {
5086  asinf(0);
5087 ; return 0; }
5088 EOF
5089 if { (eval echo configure:5090: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5090   rm -rf conftest*
5091   use_asinf=yes
5092 else
5093   echo "configure: failed program was:" >&5
5094   cat conftest.$ac_ext >&5
5095   rm -rf conftest*
5096   use_asinf=no
5097 fi
5098 rm -f conftest*
5099   echo "$ac_t""$use_asinf" 1>&6
5100   ac_ext=c
5101 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5102 ac_cpp='$CPP $CPPFLAGS'
5103 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5104 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5105 cross_compiling=$ac_cv_prog_cc_cross
5106
5107   if test x$use_asinf = x"yes"; then
5108     for ac_func in asinf
5109 do
5110 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5111 echo "configure:5112: checking for $ac_func" >&5
5112 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5113   echo $ac_n "(cached) $ac_c" 1>&6
5114 else
5115   cat > conftest.$ac_ext <<EOF
5116 #line 5117 "configure"
5117 #include "confdefs.h"
5118 /* System header to define __stub macros and hopefully few prototypes,
5119     which can conflict with char $ac_func(); below.  */
5120 #include <assert.h>
5121 /* Override any gcc2 internal prototype to avoid an error.  */
5122 /* We use char because int might match the return type of a gcc2
5123     builtin and then its argument prototype would still apply.  */
5124 char $ac_func();
5125
5126 int main() {
5127
5128 /* The GNU C library defines this for functions which it implements
5129     to always fail with ENOSYS.  Some functions are actually named
5130     something starting with __ and the normal name is an alias.  */
5131 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5132 choke me
5133 #else
5134 $ac_func();
5135 #endif
5136
5137 ; return 0; }
5138 EOF
5139 if { (eval echo configure:5140: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5140   rm -rf conftest*
5141   eval "ac_cv_func_$ac_func=yes"
5142 else
5143   echo "configure: failed program was:" >&5
5144   cat conftest.$ac_ext >&5
5145   rm -rf conftest*
5146   eval "ac_cv_func_$ac_func=no"
5147 fi
5148 rm -f conftest*
5149 fi
5150
5151 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5152   echo "$ac_t""yes" 1>&6
5153     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5154   cat >> confdefs.h <<EOF
5155 #define $ac_tr_func 1
5156 EOF
5157
5158 else
5159   echo "$ac_t""no" 1>&6
5160 fi
5161 done
5162
5163   fi
5164
5165
5166
5167   ac_ext=C
5168 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5169 ac_cpp='$CXXCPP $CPPFLAGS'
5170 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5171 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5172 cross_compiling=$ac_cv_prog_cxx_cross
5173
5174   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5175 echo "configure:5176: checking for atanf declaration" >&5
5176   cat > conftest.$ac_ext <<EOF
5177 #line 5178 "configure"
5178 #include "confdefs.h"
5179 #include <math.h>
5180 int main() {
5181  atanf(0);
5182 ; return 0; }
5183 EOF
5184 if { (eval echo configure:5185: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5185   rm -rf conftest*
5186   use_atanf=yes
5187 else
5188   echo "configure: failed program was:" >&5
5189   cat conftest.$ac_ext >&5
5190   rm -rf conftest*
5191   use_atanf=no
5192 fi
5193 rm -f conftest*
5194   echo "$ac_t""$use_atanf" 1>&6
5195   ac_ext=c
5196 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5197 ac_cpp='$CPP $CPPFLAGS'
5198 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5199 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5200 cross_compiling=$ac_cv_prog_cc_cross
5201
5202   if test x$use_atanf = x"yes"; then
5203     for ac_func in atanf
5204 do
5205 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5206 echo "configure:5207: checking for $ac_func" >&5
5207 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5208   echo $ac_n "(cached) $ac_c" 1>&6
5209 else
5210   cat > conftest.$ac_ext <<EOF
5211 #line 5212 "configure"
5212 #include "confdefs.h"
5213 /* System header to define __stub macros and hopefully few prototypes,
5214     which can conflict with char $ac_func(); below.  */
5215 #include <assert.h>
5216 /* Override any gcc2 internal prototype to avoid an error.  */
5217 /* We use char because int might match the return type of a gcc2
5218     builtin and then its argument prototype would still apply.  */
5219 char $ac_func();
5220
5221 int main() {
5222
5223 /* The GNU C library defines this for functions which it implements
5224     to always fail with ENOSYS.  Some functions are actually named
5225     something starting with __ and the normal name is an alias.  */
5226 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5227 choke me
5228 #else
5229 $ac_func();
5230 #endif
5231
5232 ; return 0; }
5233 EOF
5234 if { (eval echo configure:5235: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5235   rm -rf conftest*
5236   eval "ac_cv_func_$ac_func=yes"
5237 else
5238   echo "configure: failed program was:" >&5
5239   cat conftest.$ac_ext >&5
5240   rm -rf conftest*
5241   eval "ac_cv_func_$ac_func=no"
5242 fi
5243 rm -f conftest*
5244 fi
5245
5246 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5247   echo "$ac_t""yes" 1>&6
5248     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5249   cat >> confdefs.h <<EOF
5250 #define $ac_tr_func 1
5251 EOF
5252
5253 else
5254   echo "$ac_t""no" 1>&6
5255 fi
5256 done
5257
5258   fi
5259
5260
5261
5262   ac_ext=C
5263 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5264 ac_cpp='$CXXCPP $CPPFLAGS'
5265 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5266 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5267 cross_compiling=$ac_cv_prog_cxx_cross
5268
5269   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
5270 echo "configure:5271: checking for atan2f declaration" >&5
5271   cat > conftest.$ac_ext <<EOF
5272 #line 5273 "configure"
5273 #include "confdefs.h"
5274 #include <math.h>
5275 int main() {
5276  atan2f(0, 0);
5277 ; return 0; }
5278 EOF
5279 if { (eval echo configure:5280: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5280   rm -rf conftest*
5281   use_atan2f=yes
5282 else
5283   echo "configure: failed program was:" >&5
5284   cat conftest.$ac_ext >&5
5285   rm -rf conftest*
5286   use_atan2f=no
5287 fi
5288 rm -f conftest*
5289   echo "$ac_t""$use_atan2f" 1>&6
5290   ac_ext=c
5291 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5292 ac_cpp='$CPP $CPPFLAGS'
5293 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5294 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5295 cross_compiling=$ac_cv_prog_cc_cross
5296
5297   if test x$use_atan2f = x"yes"; then
5298     for ac_func in atan2f
5299 do
5300 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5301 echo "configure:5302: checking for $ac_func" >&5
5302 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5303   echo $ac_n "(cached) $ac_c" 1>&6
5304 else
5305   cat > conftest.$ac_ext <<EOF
5306 #line 5307 "configure"
5307 #include "confdefs.h"
5308 /* System header to define __stub macros and hopefully few prototypes,
5309     which can conflict with char $ac_func(); below.  */
5310 #include <assert.h>
5311 /* Override any gcc2 internal prototype to avoid an error.  */
5312 /* We use char because int might match the return type of a gcc2
5313     builtin and then its argument prototype would still apply.  */
5314 char $ac_func();
5315
5316 int main() {
5317
5318 /* The GNU C library defines this for functions which it implements
5319     to always fail with ENOSYS.  Some functions are actually named
5320     something starting with __ and the normal name is an alias.  */
5321 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5322 choke me
5323 #else
5324 $ac_func();
5325 #endif
5326
5327 ; return 0; }
5328 EOF
5329 if { (eval echo configure:5330: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5330   rm -rf conftest*
5331   eval "ac_cv_func_$ac_func=yes"
5332 else
5333   echo "configure: failed program was:" >&5
5334   cat conftest.$ac_ext >&5
5335   rm -rf conftest*
5336   eval "ac_cv_func_$ac_func=no"
5337 fi
5338 rm -f conftest*
5339 fi
5340
5341 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5342   echo "$ac_t""yes" 1>&6
5343     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5344   cat >> confdefs.h <<EOF
5345 #define $ac_tr_func 1
5346 EOF
5347
5348 else
5349   echo "$ac_t""no" 1>&6
5350 fi
5351 done
5352
5353   fi
5354
5355
5356
5357   ac_ext=C
5358 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5359 ac_cpp='$CXXCPP $CPPFLAGS'
5360 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5361 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5362 cross_compiling=$ac_cv_prog_cxx_cross
5363
5364   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
5365 echo "configure:5366: checking for ceilf declaration" >&5
5366   cat > conftest.$ac_ext <<EOF
5367 #line 5368 "configure"
5368 #include "confdefs.h"
5369 #include <math.h>
5370 int main() {
5371  ceilf(0);
5372 ; return 0; }
5373 EOF
5374 if { (eval echo configure:5375: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5375   rm -rf conftest*
5376   use_ceilf=yes
5377 else
5378   echo "configure: failed program was:" >&5
5379   cat conftest.$ac_ext >&5
5380   rm -rf conftest*
5381   use_ceilf=no
5382 fi
5383 rm -f conftest*
5384   echo "$ac_t""$use_ceilf" 1>&6
5385   ac_ext=c
5386 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5387 ac_cpp='$CPP $CPPFLAGS'
5388 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5389 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5390 cross_compiling=$ac_cv_prog_cc_cross
5391
5392   if test x$use_ceilf = x"yes"; then
5393     for ac_func in ceilf
5394 do
5395 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5396 echo "configure:5397: checking for $ac_func" >&5
5397 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5398   echo $ac_n "(cached) $ac_c" 1>&6
5399 else
5400   cat > conftest.$ac_ext <<EOF
5401 #line 5402 "configure"
5402 #include "confdefs.h"
5403 /* System header to define __stub macros and hopefully few prototypes,
5404     which can conflict with char $ac_func(); below.  */
5405 #include <assert.h>
5406 /* Override any gcc2 internal prototype to avoid an error.  */
5407 /* We use char because int might match the return type of a gcc2
5408     builtin and then its argument prototype would still apply.  */
5409 char $ac_func();
5410
5411 int main() {
5412
5413 /* The GNU C library defines this for functions which it implements
5414     to always fail with ENOSYS.  Some functions are actually named
5415     something starting with __ and the normal name is an alias.  */
5416 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5417 choke me
5418 #else
5419 $ac_func();
5420 #endif
5421
5422 ; return 0; }
5423 EOF
5424 if { (eval echo configure:5425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5425   rm -rf conftest*
5426   eval "ac_cv_func_$ac_func=yes"
5427 else
5428   echo "configure: failed program was:" >&5
5429   cat conftest.$ac_ext >&5
5430   rm -rf conftest*
5431   eval "ac_cv_func_$ac_func=no"
5432 fi
5433 rm -f conftest*
5434 fi
5435
5436 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5437   echo "$ac_t""yes" 1>&6
5438     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5439   cat >> confdefs.h <<EOF
5440 #define $ac_tr_func 1
5441 EOF
5442
5443 else
5444   echo "$ac_t""no" 1>&6
5445 fi
5446 done
5447
5448   fi
5449
5450
5451
5452   ac_ext=C
5453 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5454 ac_cpp='$CXXCPP $CPPFLAGS'
5455 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5456 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5457 cross_compiling=$ac_cv_prog_cxx_cross
5458
5459   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
5460 echo "configure:5461: checking for cosf declaration" >&5
5461   cat > conftest.$ac_ext <<EOF
5462 #line 5463 "configure"
5463 #include "confdefs.h"
5464 #include <math.h>
5465 int main() {
5466  cosf(0);
5467 ; return 0; }
5468 EOF
5469 if { (eval echo configure:5470: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5470   rm -rf conftest*
5471   use_cosf=yes
5472 else
5473   echo "configure: failed program was:" >&5
5474   cat conftest.$ac_ext >&5
5475   rm -rf conftest*
5476   use_cosf=no
5477 fi
5478 rm -f conftest*
5479   echo "$ac_t""$use_cosf" 1>&6
5480   ac_ext=c
5481 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5482 ac_cpp='$CPP $CPPFLAGS'
5483 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5484 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5485 cross_compiling=$ac_cv_prog_cc_cross
5486
5487   if test x$use_cosf = x"yes"; then
5488     for ac_func in cosf
5489 do
5490 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5491 echo "configure:5492: checking for $ac_func" >&5
5492 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5493   echo $ac_n "(cached) $ac_c" 1>&6
5494 else
5495   cat > conftest.$ac_ext <<EOF
5496 #line 5497 "configure"
5497 #include "confdefs.h"
5498 /* System header to define __stub macros and hopefully few prototypes,
5499     which can conflict with char $ac_func(); below.  */
5500 #include <assert.h>
5501 /* Override any gcc2 internal prototype to avoid an error.  */
5502 /* We use char because int might match the return type of a gcc2
5503     builtin and then its argument prototype would still apply.  */
5504 char $ac_func();
5505
5506 int main() {
5507
5508 /* The GNU C library defines this for functions which it implements
5509     to always fail with ENOSYS.  Some functions are actually named
5510     something starting with __ and the normal name is an alias.  */
5511 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5512 choke me
5513 #else
5514 $ac_func();
5515 #endif
5516
5517 ; return 0; }
5518 EOF
5519 if { (eval echo configure:5520: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5520   rm -rf conftest*
5521   eval "ac_cv_func_$ac_func=yes"
5522 else
5523   echo "configure: failed program was:" >&5
5524   cat conftest.$ac_ext >&5
5525   rm -rf conftest*
5526   eval "ac_cv_func_$ac_func=no"
5527 fi
5528 rm -f conftest*
5529 fi
5530
5531 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5532   echo "$ac_t""yes" 1>&6
5533     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5534   cat >> confdefs.h <<EOF
5535 #define $ac_tr_func 1
5536 EOF
5537
5538 else
5539   echo "$ac_t""no" 1>&6
5540 fi
5541 done
5542
5543   fi
5544
5545
5546
5547   ac_ext=C
5548 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5549 ac_cpp='$CXXCPP $CPPFLAGS'
5550 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5551 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5552 cross_compiling=$ac_cv_prog_cxx_cross
5553
5554   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
5555 echo "configure:5556: checking for coshf declaration" >&5
5556   cat > conftest.$ac_ext <<EOF
5557 #line 5558 "configure"
5558 #include "confdefs.h"
5559 #include <math.h>
5560 int main() {
5561  coshf(0);
5562 ; return 0; }
5563 EOF
5564 if { (eval echo configure:5565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5565   rm -rf conftest*
5566   use_coshf=yes
5567 else
5568   echo "configure: failed program was:" >&5
5569   cat conftest.$ac_ext >&5
5570   rm -rf conftest*
5571   use_coshf=no
5572 fi
5573 rm -f conftest*
5574   echo "$ac_t""$use_coshf" 1>&6
5575   ac_ext=c
5576 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5577 ac_cpp='$CPP $CPPFLAGS'
5578 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5579 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5580 cross_compiling=$ac_cv_prog_cc_cross
5581
5582   if test x$use_coshf = x"yes"; then
5583     for ac_func in coshf
5584 do
5585 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5586 echo "configure:5587: checking for $ac_func" >&5
5587 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5588   echo $ac_n "(cached) $ac_c" 1>&6
5589 else
5590   cat > conftest.$ac_ext <<EOF
5591 #line 5592 "configure"
5592 #include "confdefs.h"
5593 /* System header to define __stub macros and hopefully few prototypes,
5594     which can conflict with char $ac_func(); below.  */
5595 #include <assert.h>
5596 /* Override any gcc2 internal prototype to avoid an error.  */
5597 /* We use char because int might match the return type of a gcc2
5598     builtin and then its argument prototype would still apply.  */
5599 char $ac_func();
5600
5601 int main() {
5602
5603 /* The GNU C library defines this for functions which it implements
5604     to always fail with ENOSYS.  Some functions are actually named
5605     something starting with __ and the normal name is an alias.  */
5606 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5607 choke me
5608 #else
5609 $ac_func();
5610 #endif
5611
5612 ; return 0; }
5613 EOF
5614 if { (eval echo configure:5615: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5615   rm -rf conftest*
5616   eval "ac_cv_func_$ac_func=yes"
5617 else
5618   echo "configure: failed program was:" >&5
5619   cat conftest.$ac_ext >&5
5620   rm -rf conftest*
5621   eval "ac_cv_func_$ac_func=no"
5622 fi
5623 rm -f conftest*
5624 fi
5625
5626 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5627   echo "$ac_t""yes" 1>&6
5628     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5629   cat >> confdefs.h <<EOF
5630 #define $ac_tr_func 1
5631 EOF
5632
5633 else
5634   echo "$ac_t""no" 1>&6
5635 fi
5636 done
5637
5638   fi
5639
5640
5641
5642   ac_ext=C
5643 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5644 ac_cpp='$CXXCPP $CPPFLAGS'
5645 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5646 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5647 cross_compiling=$ac_cv_prog_cxx_cross
5648
5649   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
5650 echo "configure:5651: checking for expf declaration" >&5
5651   cat > conftest.$ac_ext <<EOF
5652 #line 5653 "configure"
5653 #include "confdefs.h"
5654 #include <math.h>
5655 int main() {
5656  expf(0);
5657 ; return 0; }
5658 EOF
5659 if { (eval echo configure:5660: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5660   rm -rf conftest*
5661   use_expf=yes
5662 else
5663   echo "configure: failed program was:" >&5
5664   cat conftest.$ac_ext >&5
5665   rm -rf conftest*
5666   use_expf=no
5667 fi
5668 rm -f conftest*
5669   echo "$ac_t""$use_expf" 1>&6
5670   ac_ext=c
5671 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5672 ac_cpp='$CPP $CPPFLAGS'
5673 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5674 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5675 cross_compiling=$ac_cv_prog_cc_cross
5676
5677   if test x$use_expf = x"yes"; then
5678     for ac_func in expf
5679 do
5680 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5681 echo "configure:5682: checking for $ac_func" >&5
5682 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5683   echo $ac_n "(cached) $ac_c" 1>&6
5684 else
5685   cat > conftest.$ac_ext <<EOF
5686 #line 5687 "configure"
5687 #include "confdefs.h"
5688 /* System header to define __stub macros and hopefully few prototypes,
5689     which can conflict with char $ac_func(); below.  */
5690 #include <assert.h>
5691 /* Override any gcc2 internal prototype to avoid an error.  */
5692 /* We use char because int might match the return type of a gcc2
5693     builtin and then its argument prototype would still apply.  */
5694 char $ac_func();
5695
5696 int main() {
5697
5698 /* The GNU C library defines this for functions which it implements
5699     to always fail with ENOSYS.  Some functions are actually named
5700     something starting with __ and the normal name is an alias.  */
5701 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5702 choke me
5703 #else
5704 $ac_func();
5705 #endif
5706
5707 ; return 0; }
5708 EOF
5709 if { (eval echo configure:5710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5710   rm -rf conftest*
5711   eval "ac_cv_func_$ac_func=yes"
5712 else
5713   echo "configure: failed program was:" >&5
5714   cat conftest.$ac_ext >&5
5715   rm -rf conftest*
5716   eval "ac_cv_func_$ac_func=no"
5717 fi
5718 rm -f conftest*
5719 fi
5720
5721 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5722   echo "$ac_t""yes" 1>&6
5723     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5724   cat >> confdefs.h <<EOF
5725 #define $ac_tr_func 1
5726 EOF
5727
5728 else
5729   echo "$ac_t""no" 1>&6
5730 fi
5731 done
5732
5733   fi
5734
5735
5736
5737   ac_ext=C
5738 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5739 ac_cpp='$CXXCPP $CPPFLAGS'
5740 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5741 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5742 cross_compiling=$ac_cv_prog_cxx_cross
5743
5744   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
5745 echo "configure:5746: checking for fabsf declaration" >&5
5746   cat > conftest.$ac_ext <<EOF
5747 #line 5748 "configure"
5748 #include "confdefs.h"
5749 #include <math.h>
5750 int main() {
5751  fabsf(0);
5752 ; return 0; }
5753 EOF
5754 if { (eval echo configure:5755: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5755   rm -rf conftest*
5756   use_fabsf=yes
5757 else
5758   echo "configure: failed program was:" >&5
5759   cat conftest.$ac_ext >&5
5760   rm -rf conftest*
5761   use_fabsf=no
5762 fi
5763 rm -f conftest*
5764   echo "$ac_t""$use_fabsf" 1>&6
5765   ac_ext=c
5766 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5767 ac_cpp='$CPP $CPPFLAGS'
5768 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5769 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5770 cross_compiling=$ac_cv_prog_cc_cross
5771
5772   if test x$use_fabsf = x"yes"; then
5773     for ac_func in fabsf
5774 do
5775 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5776 echo "configure:5777: checking for $ac_func" >&5
5777 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5778   echo $ac_n "(cached) $ac_c" 1>&6
5779 else
5780   cat > conftest.$ac_ext <<EOF
5781 #line 5782 "configure"
5782 #include "confdefs.h"
5783 /* System header to define __stub macros and hopefully few prototypes,
5784     which can conflict with char $ac_func(); below.  */
5785 #include <assert.h>
5786 /* Override any gcc2 internal prototype to avoid an error.  */
5787 /* We use char because int might match the return type of a gcc2
5788     builtin and then its argument prototype would still apply.  */
5789 char $ac_func();
5790
5791 int main() {
5792
5793 /* The GNU C library defines this for functions which it implements
5794     to always fail with ENOSYS.  Some functions are actually named
5795     something starting with __ and the normal name is an alias.  */
5796 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5797 choke me
5798 #else
5799 $ac_func();
5800 #endif
5801
5802 ; return 0; }
5803 EOF
5804 if { (eval echo configure:5805: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5805   rm -rf conftest*
5806   eval "ac_cv_func_$ac_func=yes"
5807 else
5808   echo "configure: failed program was:" >&5
5809   cat conftest.$ac_ext >&5
5810   rm -rf conftest*
5811   eval "ac_cv_func_$ac_func=no"
5812 fi
5813 rm -f conftest*
5814 fi
5815
5816 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5817   echo "$ac_t""yes" 1>&6
5818     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5819   cat >> confdefs.h <<EOF
5820 #define $ac_tr_func 1
5821 EOF
5822
5823 else
5824   echo "$ac_t""no" 1>&6
5825 fi
5826 done
5827
5828   fi
5829
5830
5831
5832   ac_ext=C
5833 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5834 ac_cpp='$CXXCPP $CPPFLAGS'
5835 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5836 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5837 cross_compiling=$ac_cv_prog_cxx_cross
5838
5839   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
5840 echo "configure:5841: checking for floorf declaration" >&5
5841   cat > conftest.$ac_ext <<EOF
5842 #line 5843 "configure"
5843 #include "confdefs.h"
5844 #include <math.h>
5845 int main() {
5846  floorf(0);
5847 ; return 0; }
5848 EOF
5849 if { (eval echo configure:5850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5850   rm -rf conftest*
5851   use_floorf=yes
5852 else
5853   echo "configure: failed program was:" >&5
5854   cat conftest.$ac_ext >&5
5855   rm -rf conftest*
5856   use_floorf=no
5857 fi
5858 rm -f conftest*
5859   echo "$ac_t""$use_floorf" 1>&6
5860   ac_ext=c
5861 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5862 ac_cpp='$CPP $CPPFLAGS'
5863 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5864 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5865 cross_compiling=$ac_cv_prog_cc_cross
5866
5867   if test x$use_floorf = x"yes"; then
5868     for ac_func in floorf
5869 do
5870 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5871 echo "configure:5872: checking for $ac_func" >&5
5872 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5873   echo $ac_n "(cached) $ac_c" 1>&6
5874 else
5875   cat > conftest.$ac_ext <<EOF
5876 #line 5877 "configure"
5877 #include "confdefs.h"
5878 /* System header to define __stub macros and hopefully few prototypes,
5879     which can conflict with char $ac_func(); below.  */
5880 #include <assert.h>
5881 /* Override any gcc2 internal prototype to avoid an error.  */
5882 /* We use char because int might match the return type of a gcc2
5883     builtin and then its argument prototype would still apply.  */
5884 char $ac_func();
5885
5886 int main() {
5887
5888 /* The GNU C library defines this for functions which it implements
5889     to always fail with ENOSYS.  Some functions are actually named
5890     something starting with __ and the normal name is an alias.  */
5891 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5892 choke me
5893 #else
5894 $ac_func();
5895 #endif
5896
5897 ; return 0; }
5898 EOF
5899 if { (eval echo configure:5900: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5900   rm -rf conftest*
5901   eval "ac_cv_func_$ac_func=yes"
5902 else
5903   echo "configure: failed program was:" >&5
5904   cat conftest.$ac_ext >&5
5905   rm -rf conftest*
5906   eval "ac_cv_func_$ac_func=no"
5907 fi
5908 rm -f conftest*
5909 fi
5910
5911 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5912   echo "$ac_t""yes" 1>&6
5913     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5914   cat >> confdefs.h <<EOF
5915 #define $ac_tr_func 1
5916 EOF
5917
5918 else
5919   echo "$ac_t""no" 1>&6
5920 fi
5921 done
5922
5923   fi
5924
5925
5926
5927   ac_ext=C
5928 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5929 ac_cpp='$CXXCPP $CPPFLAGS'
5930 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5931 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5932 cross_compiling=$ac_cv_prog_cxx_cross
5933
5934   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
5935 echo "configure:5936: checking for fmodf declaration" >&5
5936   cat > conftest.$ac_ext <<EOF
5937 #line 5938 "configure"
5938 #include "confdefs.h"
5939 #include <math.h>
5940 int main() {
5941  fmodf(0, 0);
5942 ; return 0; }
5943 EOF
5944 if { (eval echo configure:5945: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5945   rm -rf conftest*
5946   use_fmodf=yes
5947 else
5948   echo "configure: failed program was:" >&5
5949   cat conftest.$ac_ext >&5
5950   rm -rf conftest*
5951   use_fmodf=no
5952 fi
5953 rm -f conftest*
5954   echo "$ac_t""$use_fmodf" 1>&6
5955   ac_ext=c
5956 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5957 ac_cpp='$CPP $CPPFLAGS'
5958 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5959 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5960 cross_compiling=$ac_cv_prog_cc_cross
5961
5962   if test x$use_fmodf = x"yes"; then
5963     for ac_func in fmodf
5964 do
5965 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5966 echo "configure:5967: checking for $ac_func" >&5
5967 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5968   echo $ac_n "(cached) $ac_c" 1>&6
5969 else
5970   cat > conftest.$ac_ext <<EOF
5971 #line 5972 "configure"
5972 #include "confdefs.h"
5973 /* System header to define __stub macros and hopefully few prototypes,
5974     which can conflict with char $ac_func(); below.  */
5975 #include <assert.h>
5976 /* Override any gcc2 internal prototype to avoid an error.  */
5977 /* We use char because int might match the return type of a gcc2
5978     builtin and then its argument prototype would still apply.  */
5979 char $ac_func();
5980
5981 int main() {
5982
5983 /* The GNU C library defines this for functions which it implements
5984     to always fail with ENOSYS.  Some functions are actually named
5985     something starting with __ and the normal name is an alias.  */
5986 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5987 choke me
5988 #else
5989 $ac_func();
5990 #endif
5991
5992 ; return 0; }
5993 EOF
5994 if { (eval echo configure:5995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5995   rm -rf conftest*
5996   eval "ac_cv_func_$ac_func=yes"
5997 else
5998   echo "configure: failed program was:" >&5
5999   cat conftest.$ac_ext >&5
6000   rm -rf conftest*
6001   eval "ac_cv_func_$ac_func=no"
6002 fi
6003 rm -f conftest*
6004 fi
6005
6006 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6007   echo "$ac_t""yes" 1>&6
6008     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6009   cat >> confdefs.h <<EOF
6010 #define $ac_tr_func 1
6011 EOF
6012
6013 else
6014   echo "$ac_t""no" 1>&6
6015 fi
6016 done
6017
6018   fi
6019
6020
6021
6022   ac_ext=C
6023 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6024 ac_cpp='$CXXCPP $CPPFLAGS'
6025 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6026 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6027 cross_compiling=$ac_cv_prog_cxx_cross
6028
6029   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6030 echo "configure:6031: checking for frexpf declaration" >&5
6031   cat > conftest.$ac_ext <<EOF
6032 #line 6033 "configure"
6033 #include "confdefs.h"
6034 #include <math.h>
6035 int main() {
6036  frexpf(0, 0);
6037 ; return 0; }
6038 EOF
6039 if { (eval echo configure:6040: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6040   rm -rf conftest*
6041   use_frexpf=yes
6042 else
6043   echo "configure: failed program was:" >&5
6044   cat conftest.$ac_ext >&5
6045   rm -rf conftest*
6046   use_frexpf=no
6047 fi
6048 rm -f conftest*
6049   echo "$ac_t""$use_frexpf" 1>&6
6050   ac_ext=c
6051 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6052 ac_cpp='$CPP $CPPFLAGS'
6053 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6054 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6055 cross_compiling=$ac_cv_prog_cc_cross
6056
6057   if test x$use_frexpf = x"yes"; then
6058     for ac_func in frexpf
6059 do
6060 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6061 echo "configure:6062: checking for $ac_func" >&5
6062 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6063   echo $ac_n "(cached) $ac_c" 1>&6
6064 else
6065   cat > conftest.$ac_ext <<EOF
6066 #line 6067 "configure"
6067 #include "confdefs.h"
6068 /* System header to define __stub macros and hopefully few prototypes,
6069     which can conflict with char $ac_func(); below.  */
6070 #include <assert.h>
6071 /* Override any gcc2 internal prototype to avoid an error.  */
6072 /* We use char because int might match the return type of a gcc2
6073     builtin and then its argument prototype would still apply.  */
6074 char $ac_func();
6075
6076 int main() {
6077
6078 /* The GNU C library defines this for functions which it implements
6079     to always fail with ENOSYS.  Some functions are actually named
6080     something starting with __ and the normal name is an alias.  */
6081 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6082 choke me
6083 #else
6084 $ac_func();
6085 #endif
6086
6087 ; return 0; }
6088 EOF
6089 if { (eval echo configure:6090: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6090   rm -rf conftest*
6091   eval "ac_cv_func_$ac_func=yes"
6092 else
6093   echo "configure: failed program was:" >&5
6094   cat conftest.$ac_ext >&5
6095   rm -rf conftest*
6096   eval "ac_cv_func_$ac_func=no"
6097 fi
6098 rm -f conftest*
6099 fi
6100
6101 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6102   echo "$ac_t""yes" 1>&6
6103     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6104   cat >> confdefs.h <<EOF
6105 #define $ac_tr_func 1
6106 EOF
6107
6108 else
6109   echo "$ac_t""no" 1>&6
6110 fi
6111 done
6112
6113   fi
6114
6115
6116
6117   ac_ext=C
6118 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6119 ac_cpp='$CXXCPP $CPPFLAGS'
6120 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6121 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6122 cross_compiling=$ac_cv_prog_cxx_cross
6123
6124   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6125 echo "configure:6126: checking for ldexpf declaration" >&5
6126   cat > conftest.$ac_ext <<EOF
6127 #line 6128 "configure"
6128 #include "confdefs.h"
6129 #include <math.h>
6130 int main() {
6131  ldexpf(0, 0);
6132 ; return 0; }
6133 EOF
6134 if { (eval echo configure:6135: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6135   rm -rf conftest*
6136   use_ldexpf=yes
6137 else
6138   echo "configure: failed program was:" >&5
6139   cat conftest.$ac_ext >&5
6140   rm -rf conftest*
6141   use_ldexpf=no
6142 fi
6143 rm -f conftest*
6144   echo "$ac_t""$use_ldexpf" 1>&6
6145   ac_ext=c
6146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6147 ac_cpp='$CPP $CPPFLAGS'
6148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6150 cross_compiling=$ac_cv_prog_cc_cross
6151
6152   if test x$use_ldexpf = x"yes"; then
6153     for ac_func in ldexpf
6154 do
6155 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6156 echo "configure:6157: checking for $ac_func" >&5
6157 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6158   echo $ac_n "(cached) $ac_c" 1>&6
6159 else
6160   cat > conftest.$ac_ext <<EOF
6161 #line 6162 "configure"
6162 #include "confdefs.h"
6163 /* System header to define __stub macros and hopefully few prototypes,
6164     which can conflict with char $ac_func(); below.  */
6165 #include <assert.h>
6166 /* Override any gcc2 internal prototype to avoid an error.  */
6167 /* We use char because int might match the return type of a gcc2
6168     builtin and then its argument prototype would still apply.  */
6169 char $ac_func();
6170
6171 int main() {
6172
6173 /* The GNU C library defines this for functions which it implements
6174     to always fail with ENOSYS.  Some functions are actually named
6175     something starting with __ and the normal name is an alias.  */
6176 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6177 choke me
6178 #else
6179 $ac_func();
6180 #endif
6181
6182 ; return 0; }
6183 EOF
6184 if { (eval echo configure:6185: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6185   rm -rf conftest*
6186   eval "ac_cv_func_$ac_func=yes"
6187 else
6188   echo "configure: failed program was:" >&5
6189   cat conftest.$ac_ext >&5
6190   rm -rf conftest*
6191   eval "ac_cv_func_$ac_func=no"
6192 fi
6193 rm -f conftest*
6194 fi
6195
6196 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6197   echo "$ac_t""yes" 1>&6
6198     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6199   cat >> confdefs.h <<EOF
6200 #define $ac_tr_func 1
6201 EOF
6202
6203 else
6204   echo "$ac_t""no" 1>&6
6205 fi
6206 done
6207
6208   fi
6209
6210
6211
6212   ac_ext=C
6213 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6214 ac_cpp='$CXXCPP $CPPFLAGS'
6215 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6216 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6217 cross_compiling=$ac_cv_prog_cxx_cross
6218
6219   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6220 echo "configure:6221: checking for logf declaration" >&5
6221   cat > conftest.$ac_ext <<EOF
6222 #line 6223 "configure"
6223 #include "confdefs.h"
6224 #include <math.h>
6225 int main() {
6226  logf(0);
6227 ; return 0; }
6228 EOF
6229 if { (eval echo configure:6230: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6230   rm -rf conftest*
6231   use_logf=yes
6232 else
6233   echo "configure: failed program was:" >&5
6234   cat conftest.$ac_ext >&5
6235   rm -rf conftest*
6236   use_logf=no
6237 fi
6238 rm -f conftest*
6239   echo "$ac_t""$use_logf" 1>&6
6240   ac_ext=c
6241 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6242 ac_cpp='$CPP $CPPFLAGS'
6243 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6244 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6245 cross_compiling=$ac_cv_prog_cc_cross
6246
6247   if test x$use_logf = x"yes"; then
6248     for ac_func in logf
6249 do
6250 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6251 echo "configure:6252: checking for $ac_func" >&5
6252 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6253   echo $ac_n "(cached) $ac_c" 1>&6
6254 else
6255   cat > conftest.$ac_ext <<EOF
6256 #line 6257 "configure"
6257 #include "confdefs.h"
6258 /* System header to define __stub macros and hopefully few prototypes,
6259     which can conflict with char $ac_func(); below.  */
6260 #include <assert.h>
6261 /* Override any gcc2 internal prototype to avoid an error.  */
6262 /* We use char because int might match the return type of a gcc2
6263     builtin and then its argument prototype would still apply.  */
6264 char $ac_func();
6265
6266 int main() {
6267
6268 /* The GNU C library defines this for functions which it implements
6269     to always fail with ENOSYS.  Some functions are actually named
6270     something starting with __ and the normal name is an alias.  */
6271 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6272 choke me
6273 #else
6274 $ac_func();
6275 #endif
6276
6277 ; return 0; }
6278 EOF
6279 if { (eval echo configure:6280: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6280   rm -rf conftest*
6281   eval "ac_cv_func_$ac_func=yes"
6282 else
6283   echo "configure: failed program was:" >&5
6284   cat conftest.$ac_ext >&5
6285   rm -rf conftest*
6286   eval "ac_cv_func_$ac_func=no"
6287 fi
6288 rm -f conftest*
6289 fi
6290
6291 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6292   echo "$ac_t""yes" 1>&6
6293     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6294   cat >> confdefs.h <<EOF
6295 #define $ac_tr_func 1
6296 EOF
6297
6298 else
6299   echo "$ac_t""no" 1>&6
6300 fi
6301 done
6302
6303   fi
6304
6305
6306
6307   ac_ext=C
6308 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6309 ac_cpp='$CXXCPP $CPPFLAGS'
6310 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6311 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6312 cross_compiling=$ac_cv_prog_cxx_cross
6313
6314   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
6315 echo "configure:6316: checking for log10f declaration" >&5
6316   cat > conftest.$ac_ext <<EOF
6317 #line 6318 "configure"
6318 #include "confdefs.h"
6319 #include <math.h>
6320 int main() {
6321  log10f(0);
6322 ; return 0; }
6323 EOF
6324 if { (eval echo configure:6325: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6325   rm -rf conftest*
6326   use_log10f=yes
6327 else
6328   echo "configure: failed program was:" >&5
6329   cat conftest.$ac_ext >&5
6330   rm -rf conftest*
6331   use_log10f=no
6332 fi
6333 rm -f conftest*
6334   echo "$ac_t""$use_log10f" 1>&6
6335   ac_ext=c
6336 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6337 ac_cpp='$CPP $CPPFLAGS'
6338 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6339 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6340 cross_compiling=$ac_cv_prog_cc_cross
6341
6342   if test x$use_log10f = x"yes"; then
6343     for ac_func in log10f
6344 do
6345 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6346 echo "configure:6347: checking for $ac_func" >&5
6347 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6348   echo $ac_n "(cached) $ac_c" 1>&6
6349 else
6350   cat > conftest.$ac_ext <<EOF
6351 #line 6352 "configure"
6352 #include "confdefs.h"
6353 /* System header to define __stub macros and hopefully few prototypes,
6354     which can conflict with char $ac_func(); below.  */
6355 #include <assert.h>
6356 /* Override any gcc2 internal prototype to avoid an error.  */
6357 /* We use char because int might match the return type of a gcc2
6358     builtin and then its argument prototype would still apply.  */
6359 char $ac_func();
6360
6361 int main() {
6362
6363 /* The GNU C library defines this for functions which it implements
6364     to always fail with ENOSYS.  Some functions are actually named
6365     something starting with __ and the normal name is an alias.  */
6366 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6367 choke me
6368 #else
6369 $ac_func();
6370 #endif
6371
6372 ; return 0; }
6373 EOF
6374 if { (eval echo configure:6375: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6375   rm -rf conftest*
6376   eval "ac_cv_func_$ac_func=yes"
6377 else
6378   echo "configure: failed program was:" >&5
6379   cat conftest.$ac_ext >&5
6380   rm -rf conftest*
6381   eval "ac_cv_func_$ac_func=no"
6382 fi
6383 rm -f conftest*
6384 fi
6385
6386 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6387   echo "$ac_t""yes" 1>&6
6388     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6389   cat >> confdefs.h <<EOF
6390 #define $ac_tr_func 1
6391 EOF
6392
6393 else
6394   echo "$ac_t""no" 1>&6
6395 fi
6396 done
6397
6398   fi
6399
6400
6401
6402   ac_ext=C
6403 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6404 ac_cpp='$CXXCPP $CPPFLAGS'
6405 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6406 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6407 cross_compiling=$ac_cv_prog_cxx_cross
6408
6409   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
6410 echo "configure:6411: checking for modff declaration" >&5
6411   cat > conftest.$ac_ext <<EOF
6412 #line 6413 "configure"
6413 #include "confdefs.h"
6414 #include <math.h>
6415 int main() {
6416  modff(0, 0);
6417 ; return 0; }
6418 EOF
6419 if { (eval echo configure:6420: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6420   rm -rf conftest*
6421   use_modff=yes
6422 else
6423   echo "configure: failed program was:" >&5
6424   cat conftest.$ac_ext >&5
6425   rm -rf conftest*
6426   use_modff=no
6427 fi
6428 rm -f conftest*
6429   echo "$ac_t""$use_modff" 1>&6
6430   ac_ext=c
6431 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6432 ac_cpp='$CPP $CPPFLAGS'
6433 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6434 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6435 cross_compiling=$ac_cv_prog_cc_cross
6436
6437   if test x$use_modff = x"yes"; then
6438     for ac_func in modff
6439 do
6440 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6441 echo "configure:6442: checking for $ac_func" >&5
6442 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6443   echo $ac_n "(cached) $ac_c" 1>&6
6444 else
6445   cat > conftest.$ac_ext <<EOF
6446 #line 6447 "configure"
6447 #include "confdefs.h"
6448 /* System header to define __stub macros and hopefully few prototypes,
6449     which can conflict with char $ac_func(); below.  */
6450 #include <assert.h>
6451 /* Override any gcc2 internal prototype to avoid an error.  */
6452 /* We use char because int might match the return type of a gcc2
6453     builtin and then its argument prototype would still apply.  */
6454 char $ac_func();
6455
6456 int main() {
6457
6458 /* The GNU C library defines this for functions which it implements
6459     to always fail with ENOSYS.  Some functions are actually named
6460     something starting with __ and the normal name is an alias.  */
6461 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6462 choke me
6463 #else
6464 $ac_func();
6465 #endif
6466
6467 ; return 0; }
6468 EOF
6469 if { (eval echo configure:6470: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6470   rm -rf conftest*
6471   eval "ac_cv_func_$ac_func=yes"
6472 else
6473   echo "configure: failed program was:" >&5
6474   cat conftest.$ac_ext >&5
6475   rm -rf conftest*
6476   eval "ac_cv_func_$ac_func=no"
6477 fi
6478 rm -f conftest*
6479 fi
6480
6481 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6482   echo "$ac_t""yes" 1>&6
6483     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6484   cat >> confdefs.h <<EOF
6485 #define $ac_tr_func 1
6486 EOF
6487
6488 else
6489   echo "$ac_t""no" 1>&6
6490 fi
6491 done
6492
6493   fi
6494
6495
6496
6497   ac_ext=C
6498 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6499 ac_cpp='$CXXCPP $CPPFLAGS'
6500 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6501 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6502 cross_compiling=$ac_cv_prog_cxx_cross
6503
6504   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
6505 echo "configure:6506: checking for powf declaration" >&5
6506   cat > conftest.$ac_ext <<EOF
6507 #line 6508 "configure"
6508 #include "confdefs.h"
6509 #include <math.h>
6510 int main() {
6511  powf(0, 0);
6512 ; return 0; }
6513 EOF
6514 if { (eval echo configure:6515: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6515   rm -rf conftest*
6516   use_powf=yes
6517 else
6518   echo "configure: failed program was:" >&5
6519   cat conftest.$ac_ext >&5
6520   rm -rf conftest*
6521   use_powf=no
6522 fi
6523 rm -f conftest*
6524   echo "$ac_t""$use_powf" 1>&6
6525   ac_ext=c
6526 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6527 ac_cpp='$CPP $CPPFLAGS'
6528 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6529 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6530 cross_compiling=$ac_cv_prog_cc_cross
6531
6532   if test x$use_powf = x"yes"; then
6533     for ac_func in powf
6534 do
6535 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6536 echo "configure:6537: checking for $ac_func" >&5
6537 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6538   echo $ac_n "(cached) $ac_c" 1>&6
6539 else
6540   cat > conftest.$ac_ext <<EOF
6541 #line 6542 "configure"
6542 #include "confdefs.h"
6543 /* System header to define __stub macros and hopefully few prototypes,
6544     which can conflict with char $ac_func(); below.  */
6545 #include <assert.h>
6546 /* Override any gcc2 internal prototype to avoid an error.  */
6547 /* We use char because int might match the return type of a gcc2
6548     builtin and then its argument prototype would still apply.  */
6549 char $ac_func();
6550
6551 int main() {
6552
6553 /* The GNU C library defines this for functions which it implements
6554     to always fail with ENOSYS.  Some functions are actually named
6555     something starting with __ and the normal name is an alias.  */
6556 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6557 choke me
6558 #else
6559 $ac_func();
6560 #endif
6561
6562 ; return 0; }
6563 EOF
6564 if { (eval echo configure:6565: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6565   rm -rf conftest*
6566   eval "ac_cv_func_$ac_func=yes"
6567 else
6568   echo "configure: failed program was:" >&5
6569   cat conftest.$ac_ext >&5
6570   rm -rf conftest*
6571   eval "ac_cv_func_$ac_func=no"
6572 fi
6573 rm -f conftest*
6574 fi
6575
6576 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6577   echo "$ac_t""yes" 1>&6
6578     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6579   cat >> confdefs.h <<EOF
6580 #define $ac_tr_func 1
6581 EOF
6582
6583 else
6584   echo "$ac_t""no" 1>&6
6585 fi
6586 done
6587
6588   fi
6589
6590
6591
6592   ac_ext=C
6593 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6594 ac_cpp='$CXXCPP $CPPFLAGS'
6595 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6596 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6597 cross_compiling=$ac_cv_prog_cxx_cross
6598
6599   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
6600 echo "configure:6601: checking for sinf declaration" >&5
6601   cat > conftest.$ac_ext <<EOF
6602 #line 6603 "configure"
6603 #include "confdefs.h"
6604 #include <math.h>
6605 int main() {
6606  sinf(0);
6607 ; return 0; }
6608 EOF
6609 if { (eval echo configure:6610: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6610   rm -rf conftest*
6611   use_sinf=yes
6612 else
6613   echo "configure: failed program was:" >&5
6614   cat conftest.$ac_ext >&5
6615   rm -rf conftest*
6616   use_sinf=no
6617 fi
6618 rm -f conftest*
6619   echo "$ac_t""$use_sinf" 1>&6
6620   ac_ext=c
6621 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6622 ac_cpp='$CPP $CPPFLAGS'
6623 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6624 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6625 cross_compiling=$ac_cv_prog_cc_cross
6626
6627   if test x$use_sinf = x"yes"; then
6628     for ac_func in sinf
6629 do
6630 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6631 echo "configure:6632: checking for $ac_func" >&5
6632 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6633   echo $ac_n "(cached) $ac_c" 1>&6
6634 else
6635   cat > conftest.$ac_ext <<EOF
6636 #line 6637 "configure"
6637 #include "confdefs.h"
6638 /* System header to define __stub macros and hopefully few prototypes,
6639     which can conflict with char $ac_func(); below.  */
6640 #include <assert.h>
6641 /* Override any gcc2 internal prototype to avoid an error.  */
6642 /* We use char because int might match the return type of a gcc2
6643     builtin and then its argument prototype would still apply.  */
6644 char $ac_func();
6645
6646 int main() {
6647
6648 /* The GNU C library defines this for functions which it implements
6649     to always fail with ENOSYS.  Some functions are actually named
6650     something starting with __ and the normal name is an alias.  */
6651 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6652 choke me
6653 #else
6654 $ac_func();
6655 #endif
6656
6657 ; return 0; }
6658 EOF
6659 if { (eval echo configure:6660: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6660   rm -rf conftest*
6661   eval "ac_cv_func_$ac_func=yes"
6662 else
6663   echo "configure: failed program was:" >&5
6664   cat conftest.$ac_ext >&5
6665   rm -rf conftest*
6666   eval "ac_cv_func_$ac_func=no"
6667 fi
6668 rm -f conftest*
6669 fi
6670
6671 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6672   echo "$ac_t""yes" 1>&6
6673     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6674   cat >> confdefs.h <<EOF
6675 #define $ac_tr_func 1
6676 EOF
6677
6678 else
6679   echo "$ac_t""no" 1>&6
6680 fi
6681 done
6682
6683   fi
6684
6685
6686
6687   ac_ext=C
6688 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6689 ac_cpp='$CXXCPP $CPPFLAGS'
6690 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6691 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6692 cross_compiling=$ac_cv_prog_cxx_cross
6693
6694   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
6695 echo "configure:6696: checking for sinhf declaration" >&5
6696   cat > conftest.$ac_ext <<EOF
6697 #line 6698 "configure"
6698 #include "confdefs.h"
6699 #include <math.h>
6700 int main() {
6701  sinhf(0);
6702 ; return 0; }
6703 EOF
6704 if { (eval echo configure:6705: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6705   rm -rf conftest*
6706   use_sinhf=yes
6707 else
6708   echo "configure: failed program was:" >&5
6709   cat conftest.$ac_ext >&5
6710   rm -rf conftest*
6711   use_sinhf=no
6712 fi
6713 rm -f conftest*
6714   echo "$ac_t""$use_sinhf" 1>&6
6715   ac_ext=c
6716 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6717 ac_cpp='$CPP $CPPFLAGS'
6718 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6719 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6720 cross_compiling=$ac_cv_prog_cc_cross
6721
6722   if test x$use_sinhf = x"yes"; then
6723     for ac_func in sinhf
6724 do
6725 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6726 echo "configure:6727: checking for $ac_func" >&5
6727 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6728   echo $ac_n "(cached) $ac_c" 1>&6
6729 else
6730   cat > conftest.$ac_ext <<EOF
6731 #line 6732 "configure"
6732 #include "confdefs.h"
6733 /* System header to define __stub macros and hopefully few prototypes,
6734     which can conflict with char $ac_func(); below.  */
6735 #include <assert.h>
6736 /* Override any gcc2 internal prototype to avoid an error.  */
6737 /* We use char because int might match the return type of a gcc2
6738     builtin and then its argument prototype would still apply.  */
6739 char $ac_func();
6740
6741 int main() {
6742
6743 /* The GNU C library defines this for functions which it implements
6744     to always fail with ENOSYS.  Some functions are actually named
6745     something starting with __ and the normal name is an alias.  */
6746 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6747 choke me
6748 #else
6749 $ac_func();
6750 #endif
6751
6752 ; return 0; }
6753 EOF
6754 if { (eval echo configure:6755: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6755   rm -rf conftest*
6756   eval "ac_cv_func_$ac_func=yes"
6757 else
6758   echo "configure: failed program was:" >&5
6759   cat conftest.$ac_ext >&5
6760   rm -rf conftest*
6761   eval "ac_cv_func_$ac_func=no"
6762 fi
6763 rm -f conftest*
6764 fi
6765
6766 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6767   echo "$ac_t""yes" 1>&6
6768     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6769   cat >> confdefs.h <<EOF
6770 #define $ac_tr_func 1
6771 EOF
6772
6773 else
6774   echo "$ac_t""no" 1>&6
6775 fi
6776 done
6777
6778   fi
6779
6780
6781
6782   ac_ext=C
6783 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6784 ac_cpp='$CXXCPP $CPPFLAGS'
6785 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6786 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6787 cross_compiling=$ac_cv_prog_cxx_cross
6788
6789   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
6790 echo "configure:6791: checking for sqrtf declaration" >&5
6791   cat > conftest.$ac_ext <<EOF
6792 #line 6793 "configure"
6793 #include "confdefs.h"
6794 #include <math.h>
6795 int main() {
6796  sqrtf(0);
6797 ; return 0; }
6798 EOF
6799 if { (eval echo configure:6800: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6800   rm -rf conftest*
6801   use_sqrtf=yes
6802 else
6803   echo "configure: failed program was:" >&5
6804   cat conftest.$ac_ext >&5
6805   rm -rf conftest*
6806   use_sqrtf=no
6807 fi
6808 rm -f conftest*
6809   echo "$ac_t""$use_sqrtf" 1>&6
6810   ac_ext=c
6811 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6812 ac_cpp='$CPP $CPPFLAGS'
6813 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6814 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6815 cross_compiling=$ac_cv_prog_cc_cross
6816
6817   if test x$use_sqrtf = x"yes"; then
6818     for ac_func in sqrtf
6819 do
6820 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6821 echo "configure:6822: checking for $ac_func" >&5
6822 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6823   echo $ac_n "(cached) $ac_c" 1>&6
6824 else
6825   cat > conftest.$ac_ext <<EOF
6826 #line 6827 "configure"
6827 #include "confdefs.h"
6828 /* System header to define __stub macros and hopefully few prototypes,
6829     which can conflict with char $ac_func(); below.  */
6830 #include <assert.h>
6831 /* Override any gcc2 internal prototype to avoid an error.  */
6832 /* We use char because int might match the return type of a gcc2
6833     builtin and then its argument prototype would still apply.  */
6834 char $ac_func();
6835
6836 int main() {
6837
6838 /* The GNU C library defines this for functions which it implements
6839     to always fail with ENOSYS.  Some functions are actually named
6840     something starting with __ and the normal name is an alias.  */
6841 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6842 choke me
6843 #else
6844 $ac_func();
6845 #endif
6846
6847 ; return 0; }
6848 EOF
6849 if { (eval echo configure:6850: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6850   rm -rf conftest*
6851   eval "ac_cv_func_$ac_func=yes"
6852 else
6853   echo "configure: failed program was:" >&5
6854   cat conftest.$ac_ext >&5
6855   rm -rf conftest*
6856   eval "ac_cv_func_$ac_func=no"
6857 fi
6858 rm -f conftest*
6859 fi
6860
6861 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6862   echo "$ac_t""yes" 1>&6
6863     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6864   cat >> confdefs.h <<EOF
6865 #define $ac_tr_func 1
6866 EOF
6867
6868 else
6869   echo "$ac_t""no" 1>&6
6870 fi
6871 done
6872
6873   fi
6874
6875
6876
6877   ac_ext=C
6878 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6879 ac_cpp='$CXXCPP $CPPFLAGS'
6880 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6881 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6882 cross_compiling=$ac_cv_prog_cxx_cross
6883
6884   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
6885 echo "configure:6886: checking for tanf declaration" >&5
6886   cat > conftest.$ac_ext <<EOF
6887 #line 6888 "configure"
6888 #include "confdefs.h"
6889 #include <math.h>
6890 int main() {
6891  tanf(0);
6892 ; return 0; }
6893 EOF
6894 if { (eval echo configure:6895: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6895   rm -rf conftest*
6896   use_tanf=yes
6897 else
6898   echo "configure: failed program was:" >&5
6899   cat conftest.$ac_ext >&5
6900   rm -rf conftest*
6901   use_tanf=no
6902 fi
6903 rm -f conftest*
6904   echo "$ac_t""$use_tanf" 1>&6
6905   ac_ext=c
6906 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6907 ac_cpp='$CPP $CPPFLAGS'
6908 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6909 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6910 cross_compiling=$ac_cv_prog_cc_cross
6911
6912   if test x$use_tanf = x"yes"; then
6913     for ac_func in tanf
6914 do
6915 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6916 echo "configure:6917: checking for $ac_func" >&5
6917 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6918   echo $ac_n "(cached) $ac_c" 1>&6
6919 else
6920   cat > conftest.$ac_ext <<EOF
6921 #line 6922 "configure"
6922 #include "confdefs.h"
6923 /* System header to define __stub macros and hopefully few prototypes,
6924     which can conflict with char $ac_func(); below.  */
6925 #include <assert.h>
6926 /* Override any gcc2 internal prototype to avoid an error.  */
6927 /* We use char because int might match the return type of a gcc2
6928     builtin and then its argument prototype would still apply.  */
6929 char $ac_func();
6930
6931 int main() {
6932
6933 /* The GNU C library defines this for functions which it implements
6934     to always fail with ENOSYS.  Some functions are actually named
6935     something starting with __ and the normal name is an alias.  */
6936 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6937 choke me
6938 #else
6939 $ac_func();
6940 #endif
6941
6942 ; return 0; }
6943 EOF
6944 if { (eval echo configure:6945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6945   rm -rf conftest*
6946   eval "ac_cv_func_$ac_func=yes"
6947 else
6948   echo "configure: failed program was:" >&5
6949   cat conftest.$ac_ext >&5
6950   rm -rf conftest*
6951   eval "ac_cv_func_$ac_func=no"
6952 fi
6953 rm -f conftest*
6954 fi
6955
6956 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6957   echo "$ac_t""yes" 1>&6
6958     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6959   cat >> confdefs.h <<EOF
6960 #define $ac_tr_func 1
6961 EOF
6962
6963 else
6964   echo "$ac_t""no" 1>&6
6965 fi
6966 done
6967
6968   fi
6969
6970
6971
6972   ac_ext=C
6973 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6974 ac_cpp='$CXXCPP $CPPFLAGS'
6975 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6976 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6977 cross_compiling=$ac_cv_prog_cxx_cross
6978
6979   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
6980 echo "configure:6981: checking for tanhf declaration" >&5
6981   cat > conftest.$ac_ext <<EOF
6982 #line 6983 "configure"
6983 #include "confdefs.h"
6984 #include <math.h>
6985 int main() {
6986  tanhf(0);
6987 ; return 0; }
6988 EOF
6989 if { (eval echo configure:6990: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6990   rm -rf conftest*
6991   use_tanhf=yes
6992 else
6993   echo "configure: failed program was:" >&5
6994   cat conftest.$ac_ext >&5
6995   rm -rf conftest*
6996   use_tanhf=no
6997 fi
6998 rm -f conftest*
6999   echo "$ac_t""$use_tanhf" 1>&6
7000   ac_ext=c
7001 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7002 ac_cpp='$CPP $CPPFLAGS'
7003 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7004 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7005 cross_compiling=$ac_cv_prog_cc_cross
7006
7007   if test x$use_tanhf = x"yes"; then
7008     for ac_func in tanhf
7009 do
7010 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7011 echo "configure:7012: checking for $ac_func" >&5
7012 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7013   echo $ac_n "(cached) $ac_c" 1>&6
7014 else
7015   cat > conftest.$ac_ext <<EOF
7016 #line 7017 "configure"
7017 #include "confdefs.h"
7018 /* System header to define __stub macros and hopefully few prototypes,
7019     which can conflict with char $ac_func(); below.  */
7020 #include <assert.h>
7021 /* Override any gcc2 internal prototype to avoid an error.  */
7022 /* We use char because int might match the return type of a gcc2
7023     builtin and then its argument prototype would still apply.  */
7024 char $ac_func();
7025
7026 int main() {
7027
7028 /* The GNU C library defines this for functions which it implements
7029     to always fail with ENOSYS.  Some functions are actually named
7030     something starting with __ and the normal name is an alias.  */
7031 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7032 choke me
7033 #else
7034 $ac_func();
7035 #endif
7036
7037 ; return 0; }
7038 EOF
7039 if { (eval echo configure:7040: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7040   rm -rf conftest*
7041   eval "ac_cv_func_$ac_func=yes"
7042 else
7043   echo "configure: failed program was:" >&5
7044   cat conftest.$ac_ext >&5
7045   rm -rf conftest*
7046   eval "ac_cv_func_$ac_func=no"
7047 fi
7048 rm -f conftest*
7049 fi
7050
7051 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7052   echo "$ac_t""yes" 1>&6
7053     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7054   cat >> confdefs.h <<EOF
7055 #define $ac_tr_func 1
7056 EOF
7057
7058 else
7059   echo "$ac_t""no" 1>&6
7060 fi
7061 done
7062
7063   fi
7064
7065
7066
7067   ac_ext=C
7068 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7069 ac_cpp='$CXXCPP $CPPFLAGS'
7070 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7071 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7072 cross_compiling=$ac_cv_prog_cxx_cross
7073
7074   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7075 echo "configure:7076: checking for sincosf declaration" >&5
7076   cat > conftest.$ac_ext <<EOF
7077 #line 7078 "configure"
7078 #include "confdefs.h"
7079 #include <math.h>
7080 int main() {
7081  sincosf(0, 0, 0);
7082 ; return 0; }
7083 EOF
7084 if { (eval echo configure:7085: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7085   rm -rf conftest*
7086   use_sincosf=yes
7087 else
7088   echo "configure: failed program was:" >&5
7089   cat conftest.$ac_ext >&5
7090   rm -rf conftest*
7091   use_sincosf=no
7092 fi
7093 rm -f conftest*
7094   echo "$ac_t""$use_sincosf" 1>&6
7095   ac_ext=c
7096 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7097 ac_cpp='$CPP $CPPFLAGS'
7098 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7099 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7100 cross_compiling=$ac_cv_prog_cc_cross
7101
7102   if test x$use_sincosf = x"yes"; then
7103     for ac_func in sincosf
7104 do
7105 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7106 echo "configure:7107: checking for $ac_func" >&5
7107 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7108   echo $ac_n "(cached) $ac_c" 1>&6
7109 else
7110   cat > conftest.$ac_ext <<EOF
7111 #line 7112 "configure"
7112 #include "confdefs.h"
7113 /* System header to define __stub macros and hopefully few prototypes,
7114     which can conflict with char $ac_func(); below.  */
7115 #include <assert.h>
7116 /* Override any gcc2 internal prototype to avoid an error.  */
7117 /* We use char because int might match the return type of a gcc2
7118     builtin and then its argument prototype would still apply.  */
7119 char $ac_func();
7120
7121 int main() {
7122
7123 /* The GNU C library defines this for functions which it implements
7124     to always fail with ENOSYS.  Some functions are actually named
7125     something starting with __ and the normal name is an alias.  */
7126 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7127 choke me
7128 #else
7129 $ac_func();
7130 #endif
7131
7132 ; return 0; }
7133 EOF
7134 if { (eval echo configure:7135: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7135   rm -rf conftest*
7136   eval "ac_cv_func_$ac_func=yes"
7137 else
7138   echo "configure: failed program was:" >&5
7139   cat conftest.$ac_ext >&5
7140   rm -rf conftest*
7141   eval "ac_cv_func_$ac_func=no"
7142 fi
7143 rm -f conftest*
7144 fi
7145
7146 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7147   echo "$ac_t""yes" 1>&6
7148     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7149   cat >> confdefs.h <<EOF
7150 #define $ac_tr_func 1
7151 EOF
7152
7153 else
7154   echo "$ac_t""no" 1>&6
7155 fi
7156 done
7157
7158   fi
7159
7160
7161
7162   ac_ext=C
7163 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7164 ac_cpp='$CXXCPP $CPPFLAGS'
7165 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7166 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7167 cross_compiling=$ac_cv_prog_cxx_cross
7168
7169   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
7170 echo "configure:7171: checking for finitef declaration" >&5
7171   cat > conftest.$ac_ext <<EOF
7172 #line 7173 "configure"
7173 #include "confdefs.h"
7174 #include <math.h>
7175 int main() {
7176  finitef(0);
7177 ; return 0; }
7178 EOF
7179 if { (eval echo configure:7180: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7180   rm -rf conftest*
7181   use_finitef=yes
7182 else
7183   echo "configure: failed program was:" >&5
7184   cat conftest.$ac_ext >&5
7185   rm -rf conftest*
7186   use_finitef=no
7187 fi
7188 rm -f conftest*
7189   echo "$ac_t""$use_finitef" 1>&6
7190   ac_ext=c
7191 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7192 ac_cpp='$CPP $CPPFLAGS'
7193 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7194 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7195 cross_compiling=$ac_cv_prog_cc_cross
7196
7197   if test x$use_finitef = x"yes"; then
7198     for ac_func in finitef
7199 do
7200 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7201 echo "configure:7202: checking for $ac_func" >&5
7202 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7203   echo $ac_n "(cached) $ac_c" 1>&6
7204 else
7205   cat > conftest.$ac_ext <<EOF
7206 #line 7207 "configure"
7207 #include "confdefs.h"
7208 /* System header to define __stub macros and hopefully few prototypes,
7209     which can conflict with char $ac_func(); below.  */
7210 #include <assert.h>
7211 /* Override any gcc2 internal prototype to avoid an error.  */
7212 /* We use char because int might match the return type of a gcc2
7213     builtin and then its argument prototype would still apply.  */
7214 char $ac_func();
7215
7216 int main() {
7217
7218 /* The GNU C library defines this for functions which it implements
7219     to always fail with ENOSYS.  Some functions are actually named
7220     something starting with __ and the normal name is an alias.  */
7221 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7222 choke me
7223 #else
7224 $ac_func();
7225 #endif
7226
7227 ; return 0; }
7228 EOF
7229 if { (eval echo configure:7230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7230   rm -rf conftest*
7231   eval "ac_cv_func_$ac_func=yes"
7232 else
7233   echo "configure: failed program was:" >&5
7234   cat conftest.$ac_ext >&5
7235   rm -rf conftest*
7236   eval "ac_cv_func_$ac_func=no"
7237 fi
7238 rm -f conftest*
7239 fi
7240
7241 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7242   echo "$ac_t""yes" 1>&6
7243     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7244   cat >> confdefs.h <<EOF
7245 #define $ac_tr_func 1
7246 EOF
7247
7248 else
7249   echo "$ac_t""no" 1>&6
7250 fi
7251 done
7252
7253   fi
7254
7255
7256
7257
7258   ac_ext=C
7259 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7260 ac_cpp='$CXXCPP $CPPFLAGS'
7261 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7262 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7263 cross_compiling=$ac_cv_prog_cxx_cross
7264
7265   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
7266 echo "configure:7267: checking for isnanl declaration" >&5
7267   cat > conftest.$ac_ext <<EOF
7268 #line 7269 "configure"
7269 #include "confdefs.h"
7270 #include <math.h>
7271 int main() {
7272  isnanl(0);
7273 ; return 0; }
7274 EOF
7275 if { (eval echo configure:7276: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7276   rm -rf conftest*
7277   use_isnanl=yes
7278 else
7279   echo "configure: failed program was:" >&5
7280   cat conftest.$ac_ext >&5
7281   rm -rf conftest*
7282   use_isnanl=no
7283 fi
7284 rm -f conftest*
7285   echo "$ac_t""$use_isnanl" 1>&6
7286   ac_ext=c
7287 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7288 ac_cpp='$CPP $CPPFLAGS'
7289 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7290 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7291 cross_compiling=$ac_cv_prog_cc_cross
7292
7293   if test x$use_isnanl = x"yes"; then
7294     for ac_func in isnanl
7295 do
7296 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7297 echo "configure:7298: checking for $ac_func" >&5
7298 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7299   echo $ac_n "(cached) $ac_c" 1>&6
7300 else
7301   cat > conftest.$ac_ext <<EOF
7302 #line 7303 "configure"
7303 #include "confdefs.h"
7304 /* System header to define __stub macros and hopefully few prototypes,
7305     which can conflict with char $ac_func(); below.  */
7306 #include <assert.h>
7307 /* Override any gcc2 internal prototype to avoid an error.  */
7308 /* We use char because int might match the return type of a gcc2
7309     builtin and then its argument prototype would still apply.  */
7310 char $ac_func();
7311
7312 int main() {
7313
7314 /* The GNU C library defines this for functions which it implements
7315     to always fail with ENOSYS.  Some functions are actually named
7316     something starting with __ and the normal name is an alias.  */
7317 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7318 choke me
7319 #else
7320 $ac_func();
7321 #endif
7322
7323 ; return 0; }
7324 EOF
7325 if { (eval echo configure:7326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7326   rm -rf conftest*
7327   eval "ac_cv_func_$ac_func=yes"
7328 else
7329   echo "configure: failed program was:" >&5
7330   cat conftest.$ac_ext >&5
7331   rm -rf conftest*
7332   eval "ac_cv_func_$ac_func=no"
7333 fi
7334 rm -f conftest*
7335 fi
7336
7337 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7338   echo "$ac_t""yes" 1>&6
7339     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7340   cat >> confdefs.h <<EOF
7341 #define $ac_tr_func 1
7342 EOF
7343
7344 else
7345   echo "$ac_t""no" 1>&6
7346 fi
7347 done
7348
7349   fi
7350
7351
7352
7353   ac_ext=C
7354 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7355 ac_cpp='$CXXCPP $CPPFLAGS'
7356 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7357 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7358 cross_compiling=$ac_cv_prog_cxx_cross
7359
7360   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
7361 echo "configure:7362: checking for isinfl declaration" >&5
7362   cat > conftest.$ac_ext <<EOF
7363 #line 7364 "configure"
7364 #include "confdefs.h"
7365 #include <math.h>
7366 int main() {
7367  isinfl(0);
7368 ; return 0; }
7369 EOF
7370 if { (eval echo configure:7371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7371   rm -rf conftest*
7372   use_isinfl=yes
7373 else
7374   echo "configure: failed program was:" >&5
7375   cat conftest.$ac_ext >&5
7376   rm -rf conftest*
7377   use_isinfl=no
7378 fi
7379 rm -f conftest*
7380   echo "$ac_t""$use_isinfl" 1>&6
7381   ac_ext=c
7382 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7383 ac_cpp='$CPP $CPPFLAGS'
7384 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7385 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7386 cross_compiling=$ac_cv_prog_cc_cross
7387
7388   if test x$use_isinfl = x"yes"; then
7389     for ac_func in isinfl
7390 do
7391 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7392 echo "configure:7393: checking for $ac_func" >&5
7393 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7394   echo $ac_n "(cached) $ac_c" 1>&6
7395 else
7396   cat > conftest.$ac_ext <<EOF
7397 #line 7398 "configure"
7398 #include "confdefs.h"
7399 /* System header to define __stub macros and hopefully few prototypes,
7400     which can conflict with char $ac_func(); below.  */
7401 #include <assert.h>
7402 /* Override any gcc2 internal prototype to avoid an error.  */
7403 /* We use char because int might match the return type of a gcc2
7404     builtin and then its argument prototype would still apply.  */
7405 char $ac_func();
7406
7407 int main() {
7408
7409 /* The GNU C library defines this for functions which it implements
7410     to always fail with ENOSYS.  Some functions are actually named
7411     something starting with __ and the normal name is an alias.  */
7412 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7413 choke me
7414 #else
7415 $ac_func();
7416 #endif
7417
7418 ; return 0; }
7419 EOF
7420 if { (eval echo configure:7421: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7421   rm -rf conftest*
7422   eval "ac_cv_func_$ac_func=yes"
7423 else
7424   echo "configure: failed program was:" >&5
7425   cat conftest.$ac_ext >&5
7426   rm -rf conftest*
7427   eval "ac_cv_func_$ac_func=no"
7428 fi
7429 rm -f conftest*
7430 fi
7431
7432 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7433   echo "$ac_t""yes" 1>&6
7434     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7435   cat >> confdefs.h <<EOF
7436 #define $ac_tr_func 1
7437 EOF
7438
7439 else
7440   echo "$ac_t""no" 1>&6
7441 fi
7442 done
7443
7444   fi
7445
7446
7447
7448   ac_ext=C
7449 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7450 ac_cpp='$CXXCPP $CPPFLAGS'
7451 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7452 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7453 cross_compiling=$ac_cv_prog_cxx_cross
7454
7455   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
7456 echo "configure:7457: checking for copysignl declaration" >&5
7457   cat > conftest.$ac_ext <<EOF
7458 #line 7459 "configure"
7459 #include "confdefs.h"
7460 #include <math.h>
7461 int main() {
7462  copysignl(0, 0);
7463 ; return 0; }
7464 EOF
7465 if { (eval echo configure:7466: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7466   rm -rf conftest*
7467   use_copysignl=yes
7468 else
7469   echo "configure: failed program was:" >&5
7470   cat conftest.$ac_ext >&5
7471   rm -rf conftest*
7472   use_copysignl=no
7473 fi
7474 rm -f conftest*
7475   echo "$ac_t""$use_copysignl" 1>&6
7476   ac_ext=c
7477 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7478 ac_cpp='$CPP $CPPFLAGS'
7479 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7480 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7481 cross_compiling=$ac_cv_prog_cc_cross
7482
7483   if test x$use_copysignl = x"yes"; then
7484     for ac_func in copysignl
7485 do
7486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7487 echo "configure:7488: checking for $ac_func" >&5
7488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7489   echo $ac_n "(cached) $ac_c" 1>&6
7490 else
7491   cat > conftest.$ac_ext <<EOF
7492 #line 7493 "configure"
7493 #include "confdefs.h"
7494 /* System header to define __stub macros and hopefully few prototypes,
7495     which can conflict with char $ac_func(); below.  */
7496 #include <assert.h>
7497 /* Override any gcc2 internal prototype to avoid an error.  */
7498 /* We use char because int might match the return type of a gcc2
7499     builtin and then its argument prototype would still apply.  */
7500 char $ac_func();
7501
7502 int main() {
7503
7504 /* The GNU C library defines this for functions which it implements
7505     to always fail with ENOSYS.  Some functions are actually named
7506     something starting with __ and the normal name is an alias.  */
7507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7508 choke me
7509 #else
7510 $ac_func();
7511 #endif
7512
7513 ; return 0; }
7514 EOF
7515 if { (eval echo configure:7516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7516   rm -rf conftest*
7517   eval "ac_cv_func_$ac_func=yes"
7518 else
7519   echo "configure: failed program was:" >&5
7520   cat conftest.$ac_ext >&5
7521   rm -rf conftest*
7522   eval "ac_cv_func_$ac_func=no"
7523 fi
7524 rm -f conftest*
7525 fi
7526
7527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7528   echo "$ac_t""yes" 1>&6
7529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7530   cat >> confdefs.h <<EOF
7531 #define $ac_tr_func 1
7532 EOF
7533
7534 else
7535   echo "$ac_t""no" 1>&6
7536 fi
7537 done
7538
7539   fi
7540
7541
7542
7543   ac_ext=C
7544 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7545 ac_cpp='$CXXCPP $CPPFLAGS'
7546 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7547 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7548 cross_compiling=$ac_cv_prog_cxx_cross
7549
7550   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
7551 echo "configure:7552: checking for acosl declaration" >&5
7552   cat > conftest.$ac_ext <<EOF
7553 #line 7554 "configure"
7554 #include "confdefs.h"
7555 #include <math.h>
7556 int main() {
7557  acosl(0);
7558 ; return 0; }
7559 EOF
7560 if { (eval echo configure:7561: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7561   rm -rf conftest*
7562   use_acosl=yes
7563 else
7564   echo "configure: failed program was:" >&5
7565   cat conftest.$ac_ext >&5
7566   rm -rf conftest*
7567   use_acosl=no
7568 fi
7569 rm -f conftest*
7570   echo "$ac_t""$use_acosl" 1>&6
7571   ac_ext=c
7572 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7573 ac_cpp='$CPP $CPPFLAGS'
7574 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7575 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7576 cross_compiling=$ac_cv_prog_cc_cross
7577
7578   if test x$use_acosl = x"yes"; then
7579     for ac_func in acosl
7580 do
7581 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7582 echo "configure:7583: checking for $ac_func" >&5
7583 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7584   echo $ac_n "(cached) $ac_c" 1>&6
7585 else
7586   cat > conftest.$ac_ext <<EOF
7587 #line 7588 "configure"
7588 #include "confdefs.h"
7589 /* System header to define __stub macros and hopefully few prototypes,
7590     which can conflict with char $ac_func(); below.  */
7591 #include <assert.h>
7592 /* Override any gcc2 internal prototype to avoid an error.  */
7593 /* We use char because int might match the return type of a gcc2
7594     builtin and then its argument prototype would still apply.  */
7595 char $ac_func();
7596
7597 int main() {
7598
7599 /* The GNU C library defines this for functions which it implements
7600     to always fail with ENOSYS.  Some functions are actually named
7601     something starting with __ and the normal name is an alias.  */
7602 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7603 choke me
7604 #else
7605 $ac_func();
7606 #endif
7607
7608 ; return 0; }
7609 EOF
7610 if { (eval echo configure:7611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7611   rm -rf conftest*
7612   eval "ac_cv_func_$ac_func=yes"
7613 else
7614   echo "configure: failed program was:" >&5
7615   cat conftest.$ac_ext >&5
7616   rm -rf conftest*
7617   eval "ac_cv_func_$ac_func=no"
7618 fi
7619 rm -f conftest*
7620 fi
7621
7622 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7623   echo "$ac_t""yes" 1>&6
7624     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7625   cat >> confdefs.h <<EOF
7626 #define $ac_tr_func 1
7627 EOF
7628
7629 else
7630   echo "$ac_t""no" 1>&6
7631 fi
7632 done
7633
7634   fi
7635
7636
7637
7638   ac_ext=C
7639 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7640 ac_cpp='$CXXCPP $CPPFLAGS'
7641 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7642 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7643 cross_compiling=$ac_cv_prog_cxx_cross
7644
7645   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
7646 echo "configure:7647: checking for asinl declaration" >&5
7647   cat > conftest.$ac_ext <<EOF
7648 #line 7649 "configure"
7649 #include "confdefs.h"
7650 #include <math.h>
7651 int main() {
7652  asinl(0);
7653 ; return 0; }
7654 EOF
7655 if { (eval echo configure:7656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7656   rm -rf conftest*
7657   use_asinl=yes
7658 else
7659   echo "configure: failed program was:" >&5
7660   cat conftest.$ac_ext >&5
7661   rm -rf conftest*
7662   use_asinl=no
7663 fi
7664 rm -f conftest*
7665   echo "$ac_t""$use_asinl" 1>&6
7666   ac_ext=c
7667 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7668 ac_cpp='$CPP $CPPFLAGS'
7669 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7670 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7671 cross_compiling=$ac_cv_prog_cc_cross
7672
7673   if test x$use_asinl = x"yes"; then
7674     for ac_func in asinl
7675 do
7676 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7677 echo "configure:7678: checking for $ac_func" >&5
7678 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7679   echo $ac_n "(cached) $ac_c" 1>&6
7680 else
7681   cat > conftest.$ac_ext <<EOF
7682 #line 7683 "configure"
7683 #include "confdefs.h"
7684 /* System header to define __stub macros and hopefully few prototypes,
7685     which can conflict with char $ac_func(); below.  */
7686 #include <assert.h>
7687 /* Override any gcc2 internal prototype to avoid an error.  */
7688 /* We use char because int might match the return type of a gcc2
7689     builtin and then its argument prototype would still apply.  */
7690 char $ac_func();
7691
7692 int main() {
7693
7694 /* The GNU C library defines this for functions which it implements
7695     to always fail with ENOSYS.  Some functions are actually named
7696     something starting with __ and the normal name is an alias.  */
7697 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7698 choke me
7699 #else
7700 $ac_func();
7701 #endif
7702
7703 ; return 0; }
7704 EOF
7705 if { (eval echo configure:7706: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7706   rm -rf conftest*
7707   eval "ac_cv_func_$ac_func=yes"
7708 else
7709   echo "configure: failed program was:" >&5
7710   cat conftest.$ac_ext >&5
7711   rm -rf conftest*
7712   eval "ac_cv_func_$ac_func=no"
7713 fi
7714 rm -f conftest*
7715 fi
7716
7717 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7718   echo "$ac_t""yes" 1>&6
7719     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7720   cat >> confdefs.h <<EOF
7721 #define $ac_tr_func 1
7722 EOF
7723
7724 else
7725   echo "$ac_t""no" 1>&6
7726 fi
7727 done
7728
7729   fi
7730
7731
7732
7733   ac_ext=C
7734 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7735 ac_cpp='$CXXCPP $CPPFLAGS'
7736 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7737 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7738 cross_compiling=$ac_cv_prog_cxx_cross
7739
7740   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
7741 echo "configure:7742: checking for atanl declaration" >&5
7742   cat > conftest.$ac_ext <<EOF
7743 #line 7744 "configure"
7744 #include "confdefs.h"
7745 #include <math.h>
7746 int main() {
7747  atanl(0);
7748 ; return 0; }
7749 EOF
7750 if { (eval echo configure:7751: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7751   rm -rf conftest*
7752   use_atanl=yes
7753 else
7754   echo "configure: failed program was:" >&5
7755   cat conftest.$ac_ext >&5
7756   rm -rf conftest*
7757   use_atanl=no
7758 fi
7759 rm -f conftest*
7760   echo "$ac_t""$use_atanl" 1>&6
7761   ac_ext=c
7762 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7763 ac_cpp='$CPP $CPPFLAGS'
7764 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7765 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7766 cross_compiling=$ac_cv_prog_cc_cross
7767
7768   if test x$use_atanl = x"yes"; then
7769     for ac_func in atanl
7770 do
7771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7772 echo "configure:7773: checking for $ac_func" >&5
7773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7774   echo $ac_n "(cached) $ac_c" 1>&6
7775 else
7776   cat > conftest.$ac_ext <<EOF
7777 #line 7778 "configure"
7778 #include "confdefs.h"
7779 /* System header to define __stub macros and hopefully few prototypes,
7780     which can conflict with char $ac_func(); below.  */
7781 #include <assert.h>
7782 /* Override any gcc2 internal prototype to avoid an error.  */
7783 /* We use char because int might match the return type of a gcc2
7784     builtin and then its argument prototype would still apply.  */
7785 char $ac_func();
7786
7787 int main() {
7788
7789 /* The GNU C library defines this for functions which it implements
7790     to always fail with ENOSYS.  Some functions are actually named
7791     something starting with __ and the normal name is an alias.  */
7792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7793 choke me
7794 #else
7795 $ac_func();
7796 #endif
7797
7798 ; return 0; }
7799 EOF
7800 if { (eval echo configure:7801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7801   rm -rf conftest*
7802   eval "ac_cv_func_$ac_func=yes"
7803 else
7804   echo "configure: failed program was:" >&5
7805   cat conftest.$ac_ext >&5
7806   rm -rf conftest*
7807   eval "ac_cv_func_$ac_func=no"
7808 fi
7809 rm -f conftest*
7810 fi
7811
7812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7813   echo "$ac_t""yes" 1>&6
7814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7815   cat >> confdefs.h <<EOF
7816 #define $ac_tr_func 1
7817 EOF
7818
7819 else
7820   echo "$ac_t""no" 1>&6
7821 fi
7822 done
7823
7824   fi
7825
7826
7827
7828   ac_ext=C
7829 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7830 ac_cpp='$CXXCPP $CPPFLAGS'
7831 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7832 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7833 cross_compiling=$ac_cv_prog_cxx_cross
7834
7835   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
7836 echo "configure:7837: checking for atan2l declaration" >&5
7837   cat > conftest.$ac_ext <<EOF
7838 #line 7839 "configure"
7839 #include "confdefs.h"
7840 #include <math.h>
7841 int main() {
7842  atan2l(0, 0);
7843 ; return 0; }
7844 EOF
7845 if { (eval echo configure:7846: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7846   rm -rf conftest*
7847   use_atan2l=yes
7848 else
7849   echo "configure: failed program was:" >&5
7850   cat conftest.$ac_ext >&5
7851   rm -rf conftest*
7852   use_atan2l=no
7853 fi
7854 rm -f conftest*
7855   echo "$ac_t""$use_atan2l" 1>&6
7856   ac_ext=c
7857 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7858 ac_cpp='$CPP $CPPFLAGS'
7859 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7860 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7861 cross_compiling=$ac_cv_prog_cc_cross
7862
7863   if test x$use_atan2l = x"yes"; then
7864     for ac_func in atan2l
7865 do
7866 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7867 echo "configure:7868: checking for $ac_func" >&5
7868 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7869   echo $ac_n "(cached) $ac_c" 1>&6
7870 else
7871   cat > conftest.$ac_ext <<EOF
7872 #line 7873 "configure"
7873 #include "confdefs.h"
7874 /* System header to define __stub macros and hopefully few prototypes,
7875     which can conflict with char $ac_func(); below.  */
7876 #include <assert.h>
7877 /* Override any gcc2 internal prototype to avoid an error.  */
7878 /* We use char because int might match the return type of a gcc2
7879     builtin and then its argument prototype would still apply.  */
7880 char $ac_func();
7881
7882 int main() {
7883
7884 /* The GNU C library defines this for functions which it implements
7885     to always fail with ENOSYS.  Some functions are actually named
7886     something starting with __ and the normal name is an alias.  */
7887 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7888 choke me
7889 #else
7890 $ac_func();
7891 #endif
7892
7893 ; return 0; }
7894 EOF
7895 if { (eval echo configure:7896: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7896   rm -rf conftest*
7897   eval "ac_cv_func_$ac_func=yes"
7898 else
7899   echo "configure: failed program was:" >&5
7900   cat conftest.$ac_ext >&5
7901   rm -rf conftest*
7902   eval "ac_cv_func_$ac_func=no"
7903 fi
7904 rm -f conftest*
7905 fi
7906
7907 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7908   echo "$ac_t""yes" 1>&6
7909     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7910   cat >> confdefs.h <<EOF
7911 #define $ac_tr_func 1
7912 EOF
7913
7914 else
7915   echo "$ac_t""no" 1>&6
7916 fi
7917 done
7918
7919   fi
7920
7921
7922
7923   ac_ext=C
7924 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7925 ac_cpp='$CXXCPP $CPPFLAGS'
7926 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7927 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7928 cross_compiling=$ac_cv_prog_cxx_cross
7929
7930   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
7931 echo "configure:7932: checking for ceill declaration" >&5
7932   cat > conftest.$ac_ext <<EOF
7933 #line 7934 "configure"
7934 #include "confdefs.h"
7935 #include <math.h>
7936 int main() {
7937  ceill(0);
7938 ; return 0; }
7939 EOF
7940 if { (eval echo configure:7941: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7941   rm -rf conftest*
7942   use_ceill=yes
7943 else
7944   echo "configure: failed program was:" >&5
7945   cat conftest.$ac_ext >&5
7946   rm -rf conftest*
7947   use_ceill=no
7948 fi
7949 rm -f conftest*
7950   echo "$ac_t""$use_ceill" 1>&6
7951   ac_ext=c
7952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7953 ac_cpp='$CPP $CPPFLAGS'
7954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7956 cross_compiling=$ac_cv_prog_cc_cross
7957
7958   if test x$use_ceill = x"yes"; then
7959     for ac_func in ceill
7960 do
7961 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7962 echo "configure:7963: checking for $ac_func" >&5
7963 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7964   echo $ac_n "(cached) $ac_c" 1>&6
7965 else
7966   cat > conftest.$ac_ext <<EOF
7967 #line 7968 "configure"
7968 #include "confdefs.h"
7969 /* System header to define __stub macros and hopefully few prototypes,
7970     which can conflict with char $ac_func(); below.  */
7971 #include <assert.h>
7972 /* Override any gcc2 internal prototype to avoid an error.  */
7973 /* We use char because int might match the return type of a gcc2
7974     builtin and then its argument prototype would still apply.  */
7975 char $ac_func();
7976
7977 int main() {
7978
7979 /* The GNU C library defines this for functions which it implements
7980     to always fail with ENOSYS.  Some functions are actually named
7981     something starting with __ and the normal name is an alias.  */
7982 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7983 choke me
7984 #else
7985 $ac_func();
7986 #endif
7987
7988 ; return 0; }
7989 EOF
7990 if { (eval echo configure:7991: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7991   rm -rf conftest*
7992   eval "ac_cv_func_$ac_func=yes"
7993 else
7994   echo "configure: failed program was:" >&5
7995   cat conftest.$ac_ext >&5
7996   rm -rf conftest*
7997   eval "ac_cv_func_$ac_func=no"
7998 fi
7999 rm -f conftest*
8000 fi
8001
8002 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8003   echo "$ac_t""yes" 1>&6
8004     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8005   cat >> confdefs.h <<EOF
8006 #define $ac_tr_func 1
8007 EOF
8008
8009 else
8010   echo "$ac_t""no" 1>&6
8011 fi
8012 done
8013
8014   fi
8015
8016
8017
8018   ac_ext=C
8019 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8020 ac_cpp='$CXXCPP $CPPFLAGS'
8021 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8022 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8023 cross_compiling=$ac_cv_prog_cxx_cross
8024
8025   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8026 echo "configure:8027: checking for cosl declaration" >&5
8027   cat > conftest.$ac_ext <<EOF
8028 #line 8029 "configure"
8029 #include "confdefs.h"
8030 #include <math.h>
8031 int main() {
8032  cosl(0);
8033 ; return 0; }
8034 EOF
8035 if { (eval echo configure:8036: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8036   rm -rf conftest*
8037   use_cosl=yes
8038 else
8039   echo "configure: failed program was:" >&5
8040   cat conftest.$ac_ext >&5
8041   rm -rf conftest*
8042   use_cosl=no
8043 fi
8044 rm -f conftest*
8045   echo "$ac_t""$use_cosl" 1>&6
8046   ac_ext=c
8047 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8048 ac_cpp='$CPP $CPPFLAGS'
8049 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8050 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8051 cross_compiling=$ac_cv_prog_cc_cross
8052
8053   if test x$use_cosl = x"yes"; then
8054     for ac_func in cosl
8055 do
8056 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8057 echo "configure:8058: checking for $ac_func" >&5
8058 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8059   echo $ac_n "(cached) $ac_c" 1>&6
8060 else
8061   cat > conftest.$ac_ext <<EOF
8062 #line 8063 "configure"
8063 #include "confdefs.h"
8064 /* System header to define __stub macros and hopefully few prototypes,
8065     which can conflict with char $ac_func(); below.  */
8066 #include <assert.h>
8067 /* Override any gcc2 internal prototype to avoid an error.  */
8068 /* We use char because int might match the return type of a gcc2
8069     builtin and then its argument prototype would still apply.  */
8070 char $ac_func();
8071
8072 int main() {
8073
8074 /* The GNU C library defines this for functions which it implements
8075     to always fail with ENOSYS.  Some functions are actually named
8076     something starting with __ and the normal name is an alias.  */
8077 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8078 choke me
8079 #else
8080 $ac_func();
8081 #endif
8082
8083 ; return 0; }
8084 EOF
8085 if { (eval echo configure:8086: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8086   rm -rf conftest*
8087   eval "ac_cv_func_$ac_func=yes"
8088 else
8089   echo "configure: failed program was:" >&5
8090   cat conftest.$ac_ext >&5
8091   rm -rf conftest*
8092   eval "ac_cv_func_$ac_func=no"
8093 fi
8094 rm -f conftest*
8095 fi
8096
8097 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8098   echo "$ac_t""yes" 1>&6
8099     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8100   cat >> confdefs.h <<EOF
8101 #define $ac_tr_func 1
8102 EOF
8103
8104 else
8105   echo "$ac_t""no" 1>&6
8106 fi
8107 done
8108
8109   fi
8110
8111
8112
8113   ac_ext=C
8114 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8115 ac_cpp='$CXXCPP $CPPFLAGS'
8116 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8117 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8118 cross_compiling=$ac_cv_prog_cxx_cross
8119
8120   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
8121 echo "configure:8122: checking for coshl declaration" >&5
8122   cat > conftest.$ac_ext <<EOF
8123 #line 8124 "configure"
8124 #include "confdefs.h"
8125 #include <math.h>
8126 int main() {
8127  coshl(0);
8128 ; return 0; }
8129 EOF
8130 if { (eval echo configure:8131: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8131   rm -rf conftest*
8132   use_coshl=yes
8133 else
8134   echo "configure: failed program was:" >&5
8135   cat conftest.$ac_ext >&5
8136   rm -rf conftest*
8137   use_coshl=no
8138 fi
8139 rm -f conftest*
8140   echo "$ac_t""$use_coshl" 1>&6
8141   ac_ext=c
8142 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8143 ac_cpp='$CPP $CPPFLAGS'
8144 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8145 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8146 cross_compiling=$ac_cv_prog_cc_cross
8147
8148   if test x$use_coshl = x"yes"; then
8149     for ac_func in coshl
8150 do
8151 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8152 echo "configure:8153: checking for $ac_func" >&5
8153 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8154   echo $ac_n "(cached) $ac_c" 1>&6
8155 else
8156   cat > conftest.$ac_ext <<EOF
8157 #line 8158 "configure"
8158 #include "confdefs.h"
8159 /* System header to define __stub macros and hopefully few prototypes,
8160     which can conflict with char $ac_func(); below.  */
8161 #include <assert.h>
8162 /* Override any gcc2 internal prototype to avoid an error.  */
8163 /* We use char because int might match the return type of a gcc2
8164     builtin and then its argument prototype would still apply.  */
8165 char $ac_func();
8166
8167 int main() {
8168
8169 /* The GNU C library defines this for functions which it implements
8170     to always fail with ENOSYS.  Some functions are actually named
8171     something starting with __ and the normal name is an alias.  */
8172 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8173 choke me
8174 #else
8175 $ac_func();
8176 #endif
8177
8178 ; return 0; }
8179 EOF
8180 if { (eval echo configure:8181: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8181   rm -rf conftest*
8182   eval "ac_cv_func_$ac_func=yes"
8183 else
8184   echo "configure: failed program was:" >&5
8185   cat conftest.$ac_ext >&5
8186   rm -rf conftest*
8187   eval "ac_cv_func_$ac_func=no"
8188 fi
8189 rm -f conftest*
8190 fi
8191
8192 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8193   echo "$ac_t""yes" 1>&6
8194     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8195   cat >> confdefs.h <<EOF
8196 #define $ac_tr_func 1
8197 EOF
8198
8199 else
8200   echo "$ac_t""no" 1>&6
8201 fi
8202 done
8203
8204   fi
8205
8206
8207
8208   ac_ext=C
8209 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8210 ac_cpp='$CXXCPP $CPPFLAGS'
8211 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8212 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8213 cross_compiling=$ac_cv_prog_cxx_cross
8214
8215   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
8216 echo "configure:8217: checking for expl declaration" >&5
8217   cat > conftest.$ac_ext <<EOF
8218 #line 8219 "configure"
8219 #include "confdefs.h"
8220 #include <math.h>
8221 int main() {
8222  expl(0);
8223 ; return 0; }
8224 EOF
8225 if { (eval echo configure:8226: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8226   rm -rf conftest*
8227   use_expl=yes
8228 else
8229   echo "configure: failed program was:" >&5
8230   cat conftest.$ac_ext >&5
8231   rm -rf conftest*
8232   use_expl=no
8233 fi
8234 rm -f conftest*
8235   echo "$ac_t""$use_expl" 1>&6
8236   ac_ext=c
8237 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8238 ac_cpp='$CPP $CPPFLAGS'
8239 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8240 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8241 cross_compiling=$ac_cv_prog_cc_cross
8242
8243   if test x$use_expl = x"yes"; then
8244     for ac_func in expl
8245 do
8246 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8247 echo "configure:8248: checking for $ac_func" >&5
8248 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8249   echo $ac_n "(cached) $ac_c" 1>&6
8250 else
8251   cat > conftest.$ac_ext <<EOF
8252 #line 8253 "configure"
8253 #include "confdefs.h"
8254 /* System header to define __stub macros and hopefully few prototypes,
8255     which can conflict with char $ac_func(); below.  */
8256 #include <assert.h>
8257 /* Override any gcc2 internal prototype to avoid an error.  */
8258 /* We use char because int might match the return type of a gcc2
8259     builtin and then its argument prototype would still apply.  */
8260 char $ac_func();
8261
8262 int main() {
8263
8264 /* The GNU C library defines this for functions which it implements
8265     to always fail with ENOSYS.  Some functions are actually named
8266     something starting with __ and the normal name is an alias.  */
8267 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8268 choke me
8269 #else
8270 $ac_func();
8271 #endif
8272
8273 ; return 0; }
8274 EOF
8275 if { (eval echo configure:8276: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8276   rm -rf conftest*
8277   eval "ac_cv_func_$ac_func=yes"
8278 else
8279   echo "configure: failed program was:" >&5
8280   cat conftest.$ac_ext >&5
8281   rm -rf conftest*
8282   eval "ac_cv_func_$ac_func=no"
8283 fi
8284 rm -f conftest*
8285 fi
8286
8287 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8288   echo "$ac_t""yes" 1>&6
8289     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8290   cat >> confdefs.h <<EOF
8291 #define $ac_tr_func 1
8292 EOF
8293
8294 else
8295   echo "$ac_t""no" 1>&6
8296 fi
8297 done
8298
8299   fi
8300
8301
8302
8303   ac_ext=C
8304 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8305 ac_cpp='$CXXCPP $CPPFLAGS'
8306 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8307 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8308 cross_compiling=$ac_cv_prog_cxx_cross
8309
8310   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
8311 echo "configure:8312: checking for fabsl declaration" >&5
8312   cat > conftest.$ac_ext <<EOF
8313 #line 8314 "configure"
8314 #include "confdefs.h"
8315 #include <math.h>
8316 int main() {
8317  fabsl(0);
8318 ; return 0; }
8319 EOF
8320 if { (eval echo configure:8321: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8321   rm -rf conftest*
8322   use_fabsl=yes
8323 else
8324   echo "configure: failed program was:" >&5
8325   cat conftest.$ac_ext >&5
8326   rm -rf conftest*
8327   use_fabsl=no
8328 fi
8329 rm -f conftest*
8330   echo "$ac_t""$use_fabsl" 1>&6
8331   ac_ext=c
8332 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8333 ac_cpp='$CPP $CPPFLAGS'
8334 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8335 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8336 cross_compiling=$ac_cv_prog_cc_cross
8337
8338   if test x$use_fabsl = x"yes"; then
8339     for ac_func in fabsl
8340 do
8341 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8342 echo "configure:8343: checking for $ac_func" >&5
8343 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8344   echo $ac_n "(cached) $ac_c" 1>&6
8345 else
8346   cat > conftest.$ac_ext <<EOF
8347 #line 8348 "configure"
8348 #include "confdefs.h"
8349 /* System header to define __stub macros and hopefully few prototypes,
8350     which can conflict with char $ac_func(); below.  */
8351 #include <assert.h>
8352 /* Override any gcc2 internal prototype to avoid an error.  */
8353 /* We use char because int might match the return type of a gcc2
8354     builtin and then its argument prototype would still apply.  */
8355 char $ac_func();
8356
8357 int main() {
8358
8359 /* The GNU C library defines this for functions which it implements
8360     to always fail with ENOSYS.  Some functions are actually named
8361     something starting with __ and the normal name is an alias.  */
8362 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8363 choke me
8364 #else
8365 $ac_func();
8366 #endif
8367
8368 ; return 0; }
8369 EOF
8370 if { (eval echo configure:8371: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8371   rm -rf conftest*
8372   eval "ac_cv_func_$ac_func=yes"
8373 else
8374   echo "configure: failed program was:" >&5
8375   cat conftest.$ac_ext >&5
8376   rm -rf conftest*
8377   eval "ac_cv_func_$ac_func=no"
8378 fi
8379 rm -f conftest*
8380 fi
8381
8382 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8383   echo "$ac_t""yes" 1>&6
8384     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8385   cat >> confdefs.h <<EOF
8386 #define $ac_tr_func 1
8387 EOF
8388
8389 else
8390   echo "$ac_t""no" 1>&6
8391 fi
8392 done
8393
8394   fi
8395
8396
8397
8398   ac_ext=C
8399 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8400 ac_cpp='$CXXCPP $CPPFLAGS'
8401 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8402 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8403 cross_compiling=$ac_cv_prog_cxx_cross
8404
8405   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
8406 echo "configure:8407: checking for floorl declaration" >&5
8407   cat > conftest.$ac_ext <<EOF
8408 #line 8409 "configure"
8409 #include "confdefs.h"
8410 #include <math.h>
8411 int main() {
8412  floorl(0);
8413 ; return 0; }
8414 EOF
8415 if { (eval echo configure:8416: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8416   rm -rf conftest*
8417   use_floorl=yes
8418 else
8419   echo "configure: failed program was:" >&5
8420   cat conftest.$ac_ext >&5
8421   rm -rf conftest*
8422   use_floorl=no
8423 fi
8424 rm -f conftest*
8425   echo "$ac_t""$use_floorl" 1>&6
8426   ac_ext=c
8427 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8428 ac_cpp='$CPP $CPPFLAGS'
8429 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8430 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8431 cross_compiling=$ac_cv_prog_cc_cross
8432
8433   if test x$use_floorl = x"yes"; then
8434     for ac_func in floorl
8435 do
8436 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8437 echo "configure:8438: checking for $ac_func" >&5
8438 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8439   echo $ac_n "(cached) $ac_c" 1>&6
8440 else
8441   cat > conftest.$ac_ext <<EOF
8442 #line 8443 "configure"
8443 #include "confdefs.h"
8444 /* System header to define __stub macros and hopefully few prototypes,
8445     which can conflict with char $ac_func(); below.  */
8446 #include <assert.h>
8447 /* Override any gcc2 internal prototype to avoid an error.  */
8448 /* We use char because int might match the return type of a gcc2
8449     builtin and then its argument prototype would still apply.  */
8450 char $ac_func();
8451
8452 int main() {
8453
8454 /* The GNU C library defines this for functions which it implements
8455     to always fail with ENOSYS.  Some functions are actually named
8456     something starting with __ and the normal name is an alias.  */
8457 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8458 choke me
8459 #else
8460 $ac_func();
8461 #endif
8462
8463 ; return 0; }
8464 EOF
8465 if { (eval echo configure:8466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8466   rm -rf conftest*
8467   eval "ac_cv_func_$ac_func=yes"
8468 else
8469   echo "configure: failed program was:" >&5
8470   cat conftest.$ac_ext >&5
8471   rm -rf conftest*
8472   eval "ac_cv_func_$ac_func=no"
8473 fi
8474 rm -f conftest*
8475 fi
8476
8477 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8478   echo "$ac_t""yes" 1>&6
8479     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8480   cat >> confdefs.h <<EOF
8481 #define $ac_tr_func 1
8482 EOF
8483
8484 else
8485   echo "$ac_t""no" 1>&6
8486 fi
8487 done
8488
8489   fi
8490
8491
8492
8493   ac_ext=C
8494 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8495 ac_cpp='$CXXCPP $CPPFLAGS'
8496 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8497 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8498 cross_compiling=$ac_cv_prog_cxx_cross
8499
8500   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
8501 echo "configure:8502: checking for fmodl declaration" >&5
8502   cat > conftest.$ac_ext <<EOF
8503 #line 8504 "configure"
8504 #include "confdefs.h"
8505 #include <math.h>
8506 int main() {
8507  fmodl(0, 0);
8508 ; return 0; }
8509 EOF
8510 if { (eval echo configure:8511: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8511   rm -rf conftest*
8512   use_fmodl=yes
8513 else
8514   echo "configure: failed program was:" >&5
8515   cat conftest.$ac_ext >&5
8516   rm -rf conftest*
8517   use_fmodl=no
8518 fi
8519 rm -f conftest*
8520   echo "$ac_t""$use_fmodl" 1>&6
8521   ac_ext=c
8522 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8523 ac_cpp='$CPP $CPPFLAGS'
8524 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8525 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8526 cross_compiling=$ac_cv_prog_cc_cross
8527
8528   if test x$use_fmodl = x"yes"; then
8529     for ac_func in fmodl
8530 do
8531 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8532 echo "configure:8533: checking for $ac_func" >&5
8533 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8534   echo $ac_n "(cached) $ac_c" 1>&6
8535 else
8536   cat > conftest.$ac_ext <<EOF
8537 #line 8538 "configure"
8538 #include "confdefs.h"
8539 /* System header to define __stub macros and hopefully few prototypes,
8540     which can conflict with char $ac_func(); below.  */
8541 #include <assert.h>
8542 /* Override any gcc2 internal prototype to avoid an error.  */
8543 /* We use char because int might match the return type of a gcc2
8544     builtin and then its argument prototype would still apply.  */
8545 char $ac_func();
8546
8547 int main() {
8548
8549 /* The GNU C library defines this for functions which it implements
8550     to always fail with ENOSYS.  Some functions are actually named
8551     something starting with __ and the normal name is an alias.  */
8552 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8553 choke me
8554 #else
8555 $ac_func();
8556 #endif
8557
8558 ; return 0; }
8559 EOF
8560 if { (eval echo configure:8561: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8561   rm -rf conftest*
8562   eval "ac_cv_func_$ac_func=yes"
8563 else
8564   echo "configure: failed program was:" >&5
8565   cat conftest.$ac_ext >&5
8566   rm -rf conftest*
8567   eval "ac_cv_func_$ac_func=no"
8568 fi
8569 rm -f conftest*
8570 fi
8571
8572 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8573   echo "$ac_t""yes" 1>&6
8574     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8575   cat >> confdefs.h <<EOF
8576 #define $ac_tr_func 1
8577 EOF
8578
8579 else
8580   echo "$ac_t""no" 1>&6
8581 fi
8582 done
8583
8584   fi
8585
8586
8587
8588   ac_ext=C
8589 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8590 ac_cpp='$CXXCPP $CPPFLAGS'
8591 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8592 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8593 cross_compiling=$ac_cv_prog_cxx_cross
8594
8595   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
8596 echo "configure:8597: checking for frexpl declaration" >&5
8597   cat > conftest.$ac_ext <<EOF
8598 #line 8599 "configure"
8599 #include "confdefs.h"
8600 #include <math.h>
8601 int main() {
8602  frexpl(0, 0);
8603 ; return 0; }
8604 EOF
8605 if { (eval echo configure:8606: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8606   rm -rf conftest*
8607   use_frexpl=yes
8608 else
8609   echo "configure: failed program was:" >&5
8610   cat conftest.$ac_ext >&5
8611   rm -rf conftest*
8612   use_frexpl=no
8613 fi
8614 rm -f conftest*
8615   echo "$ac_t""$use_frexpl" 1>&6
8616   ac_ext=c
8617 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8618 ac_cpp='$CPP $CPPFLAGS'
8619 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8620 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8621 cross_compiling=$ac_cv_prog_cc_cross
8622
8623   if test x$use_frexpl = x"yes"; then
8624     for ac_func in frexpl
8625 do
8626 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8627 echo "configure:8628: checking for $ac_func" >&5
8628 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8629   echo $ac_n "(cached) $ac_c" 1>&6
8630 else
8631   cat > conftest.$ac_ext <<EOF
8632 #line 8633 "configure"
8633 #include "confdefs.h"
8634 /* System header to define __stub macros and hopefully few prototypes,
8635     which can conflict with char $ac_func(); below.  */
8636 #include <assert.h>
8637 /* Override any gcc2 internal prototype to avoid an error.  */
8638 /* We use char because int might match the return type of a gcc2
8639     builtin and then its argument prototype would still apply.  */
8640 char $ac_func();
8641
8642 int main() {
8643
8644 /* The GNU C library defines this for functions which it implements
8645     to always fail with ENOSYS.  Some functions are actually named
8646     something starting with __ and the normal name is an alias.  */
8647 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8648 choke me
8649 #else
8650 $ac_func();
8651 #endif
8652
8653 ; return 0; }
8654 EOF
8655 if { (eval echo configure:8656: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8656   rm -rf conftest*
8657   eval "ac_cv_func_$ac_func=yes"
8658 else
8659   echo "configure: failed program was:" >&5
8660   cat conftest.$ac_ext >&5
8661   rm -rf conftest*
8662   eval "ac_cv_func_$ac_func=no"
8663 fi
8664 rm -f conftest*
8665 fi
8666
8667 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8668   echo "$ac_t""yes" 1>&6
8669     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8670   cat >> confdefs.h <<EOF
8671 #define $ac_tr_func 1
8672 EOF
8673
8674 else
8675   echo "$ac_t""no" 1>&6
8676 fi
8677 done
8678
8679   fi
8680
8681
8682
8683   ac_ext=C
8684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8685 ac_cpp='$CXXCPP $CPPFLAGS'
8686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8688 cross_compiling=$ac_cv_prog_cxx_cross
8689
8690   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
8691 echo "configure:8692: checking for ldexpl declaration" >&5
8692   cat > conftest.$ac_ext <<EOF
8693 #line 8694 "configure"
8694 #include "confdefs.h"
8695 #include <math.h>
8696 int main() {
8697  ldexpl(0, 0);
8698 ; return 0; }
8699 EOF
8700 if { (eval echo configure:8701: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8701   rm -rf conftest*
8702   use_ldexpl=yes
8703 else
8704   echo "configure: failed program was:" >&5
8705   cat conftest.$ac_ext >&5
8706   rm -rf conftest*
8707   use_ldexpl=no
8708 fi
8709 rm -f conftest*
8710   echo "$ac_t""$use_ldexpl" 1>&6
8711   ac_ext=c
8712 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8713 ac_cpp='$CPP $CPPFLAGS'
8714 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8715 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8716 cross_compiling=$ac_cv_prog_cc_cross
8717
8718   if test x$use_ldexpl = x"yes"; then
8719     for ac_func in ldexpl
8720 do
8721 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8722 echo "configure:8723: checking for $ac_func" >&5
8723 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8724   echo $ac_n "(cached) $ac_c" 1>&6
8725 else
8726   cat > conftest.$ac_ext <<EOF
8727 #line 8728 "configure"
8728 #include "confdefs.h"
8729 /* System header to define __stub macros and hopefully few prototypes,
8730     which can conflict with char $ac_func(); below.  */
8731 #include <assert.h>
8732 /* Override any gcc2 internal prototype to avoid an error.  */
8733 /* We use char because int might match the return type of a gcc2
8734     builtin and then its argument prototype would still apply.  */
8735 char $ac_func();
8736
8737 int main() {
8738
8739 /* The GNU C library defines this for functions which it implements
8740     to always fail with ENOSYS.  Some functions are actually named
8741     something starting with __ and the normal name is an alias.  */
8742 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8743 choke me
8744 #else
8745 $ac_func();
8746 #endif
8747
8748 ; return 0; }
8749 EOF
8750 if { (eval echo configure:8751: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8751   rm -rf conftest*
8752   eval "ac_cv_func_$ac_func=yes"
8753 else
8754   echo "configure: failed program was:" >&5
8755   cat conftest.$ac_ext >&5
8756   rm -rf conftest*
8757   eval "ac_cv_func_$ac_func=no"
8758 fi
8759 rm -f conftest*
8760 fi
8761
8762 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8763   echo "$ac_t""yes" 1>&6
8764     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8765   cat >> confdefs.h <<EOF
8766 #define $ac_tr_func 1
8767 EOF
8768
8769 else
8770   echo "$ac_t""no" 1>&6
8771 fi
8772 done
8773
8774   fi
8775
8776
8777
8778   ac_ext=C
8779 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8780 ac_cpp='$CXXCPP $CPPFLAGS'
8781 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8782 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8783 cross_compiling=$ac_cv_prog_cxx_cross
8784
8785   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
8786 echo "configure:8787: checking for logl declaration" >&5
8787   cat > conftest.$ac_ext <<EOF
8788 #line 8789 "configure"
8789 #include "confdefs.h"
8790 #include <math.h>
8791 int main() {
8792  logl(0);
8793 ; return 0; }
8794 EOF
8795 if { (eval echo configure:8796: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8796   rm -rf conftest*
8797   use_logl=yes
8798 else
8799   echo "configure: failed program was:" >&5
8800   cat conftest.$ac_ext >&5
8801   rm -rf conftest*
8802   use_logl=no
8803 fi
8804 rm -f conftest*
8805   echo "$ac_t""$use_logl" 1>&6
8806   ac_ext=c
8807 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8808 ac_cpp='$CPP $CPPFLAGS'
8809 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8810 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8811 cross_compiling=$ac_cv_prog_cc_cross
8812
8813   if test x$use_logl = x"yes"; then
8814     for ac_func in logl
8815 do
8816 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8817 echo "configure:8818: checking for $ac_func" >&5
8818 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8819   echo $ac_n "(cached) $ac_c" 1>&6
8820 else
8821   cat > conftest.$ac_ext <<EOF
8822 #line 8823 "configure"
8823 #include "confdefs.h"
8824 /* System header to define __stub macros and hopefully few prototypes,
8825     which can conflict with char $ac_func(); below.  */
8826 #include <assert.h>
8827 /* Override any gcc2 internal prototype to avoid an error.  */
8828 /* We use char because int might match the return type of a gcc2
8829     builtin and then its argument prototype would still apply.  */
8830 char $ac_func();
8831
8832 int main() {
8833
8834 /* The GNU C library defines this for functions which it implements
8835     to always fail with ENOSYS.  Some functions are actually named
8836     something starting with __ and the normal name is an alias.  */
8837 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8838 choke me
8839 #else
8840 $ac_func();
8841 #endif
8842
8843 ; return 0; }
8844 EOF
8845 if { (eval echo configure:8846: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8846   rm -rf conftest*
8847   eval "ac_cv_func_$ac_func=yes"
8848 else
8849   echo "configure: failed program was:" >&5
8850   cat conftest.$ac_ext >&5
8851   rm -rf conftest*
8852   eval "ac_cv_func_$ac_func=no"
8853 fi
8854 rm -f conftest*
8855 fi
8856
8857 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8858   echo "$ac_t""yes" 1>&6
8859     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8860   cat >> confdefs.h <<EOF
8861 #define $ac_tr_func 1
8862 EOF
8863
8864 else
8865   echo "$ac_t""no" 1>&6
8866 fi
8867 done
8868
8869   fi
8870
8871
8872
8873   ac_ext=C
8874 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8875 ac_cpp='$CXXCPP $CPPFLAGS'
8876 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8877 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8878 cross_compiling=$ac_cv_prog_cxx_cross
8879
8880   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
8881 echo "configure:8882: checking for log10l declaration" >&5
8882   cat > conftest.$ac_ext <<EOF
8883 #line 8884 "configure"
8884 #include "confdefs.h"
8885 #include <math.h>
8886 int main() {
8887  log10l(0);
8888 ; return 0; }
8889 EOF
8890 if { (eval echo configure:8891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8891   rm -rf conftest*
8892   use_log10l=yes
8893 else
8894   echo "configure: failed program was:" >&5
8895   cat conftest.$ac_ext >&5
8896   rm -rf conftest*
8897   use_log10l=no
8898 fi
8899 rm -f conftest*
8900   echo "$ac_t""$use_log10l" 1>&6
8901   ac_ext=c
8902 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8903 ac_cpp='$CPP $CPPFLAGS'
8904 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8905 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8906 cross_compiling=$ac_cv_prog_cc_cross
8907
8908   if test x$use_log10l = x"yes"; then
8909     for ac_func in log10l
8910 do
8911 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8912 echo "configure:8913: checking for $ac_func" >&5
8913 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8914   echo $ac_n "(cached) $ac_c" 1>&6
8915 else
8916   cat > conftest.$ac_ext <<EOF
8917 #line 8918 "configure"
8918 #include "confdefs.h"
8919 /* System header to define __stub macros and hopefully few prototypes,
8920     which can conflict with char $ac_func(); below.  */
8921 #include <assert.h>
8922 /* Override any gcc2 internal prototype to avoid an error.  */
8923 /* We use char because int might match the return type of a gcc2
8924     builtin and then its argument prototype would still apply.  */
8925 char $ac_func();
8926
8927 int main() {
8928
8929 /* The GNU C library defines this for functions which it implements
8930     to always fail with ENOSYS.  Some functions are actually named
8931     something starting with __ and the normal name is an alias.  */
8932 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8933 choke me
8934 #else
8935 $ac_func();
8936 #endif
8937
8938 ; return 0; }
8939 EOF
8940 if { (eval echo configure:8941: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8941   rm -rf conftest*
8942   eval "ac_cv_func_$ac_func=yes"
8943 else
8944   echo "configure: failed program was:" >&5
8945   cat conftest.$ac_ext >&5
8946   rm -rf conftest*
8947   eval "ac_cv_func_$ac_func=no"
8948 fi
8949 rm -f conftest*
8950 fi
8951
8952 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8953   echo "$ac_t""yes" 1>&6
8954     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8955   cat >> confdefs.h <<EOF
8956 #define $ac_tr_func 1
8957 EOF
8958
8959 else
8960   echo "$ac_t""no" 1>&6
8961 fi
8962 done
8963
8964   fi
8965
8966
8967
8968   ac_ext=C
8969 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8970 ac_cpp='$CXXCPP $CPPFLAGS'
8971 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8972 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8973 cross_compiling=$ac_cv_prog_cxx_cross
8974
8975   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
8976 echo "configure:8977: checking for modfl declaration" >&5
8977   cat > conftest.$ac_ext <<EOF
8978 #line 8979 "configure"
8979 #include "confdefs.h"
8980 #include <math.h>
8981 int main() {
8982  modfl(0, 0);
8983 ; return 0; }
8984 EOF
8985 if { (eval echo configure:8986: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8986   rm -rf conftest*
8987   use_modfl=yes
8988 else
8989   echo "configure: failed program was:" >&5
8990   cat conftest.$ac_ext >&5
8991   rm -rf conftest*
8992   use_modfl=no
8993 fi
8994 rm -f conftest*
8995   echo "$ac_t""$use_modfl" 1>&6
8996   ac_ext=c
8997 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8998 ac_cpp='$CPP $CPPFLAGS'
8999 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9000 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9001 cross_compiling=$ac_cv_prog_cc_cross
9002
9003   if test x$use_modfl = x"yes"; then
9004     for ac_func in modfl
9005 do
9006 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9007 echo "configure:9008: checking for $ac_func" >&5
9008 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9009   echo $ac_n "(cached) $ac_c" 1>&6
9010 else
9011   cat > conftest.$ac_ext <<EOF
9012 #line 9013 "configure"
9013 #include "confdefs.h"
9014 /* System header to define __stub macros and hopefully few prototypes,
9015     which can conflict with char $ac_func(); below.  */
9016 #include <assert.h>
9017 /* Override any gcc2 internal prototype to avoid an error.  */
9018 /* We use char because int might match the return type of a gcc2
9019     builtin and then its argument prototype would still apply.  */
9020 char $ac_func();
9021
9022 int main() {
9023
9024 /* The GNU C library defines this for functions which it implements
9025     to always fail with ENOSYS.  Some functions are actually named
9026     something starting with __ and the normal name is an alias.  */
9027 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9028 choke me
9029 #else
9030 $ac_func();
9031 #endif
9032
9033 ; return 0; }
9034 EOF
9035 if { (eval echo configure:9036: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9036   rm -rf conftest*
9037   eval "ac_cv_func_$ac_func=yes"
9038 else
9039   echo "configure: failed program was:" >&5
9040   cat conftest.$ac_ext >&5
9041   rm -rf conftest*
9042   eval "ac_cv_func_$ac_func=no"
9043 fi
9044 rm -f conftest*
9045 fi
9046
9047 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9048   echo "$ac_t""yes" 1>&6
9049     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9050   cat >> confdefs.h <<EOF
9051 #define $ac_tr_func 1
9052 EOF
9053
9054 else
9055   echo "$ac_t""no" 1>&6
9056 fi
9057 done
9058
9059   fi
9060
9061
9062
9063   ac_ext=C
9064 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9065 ac_cpp='$CXXCPP $CPPFLAGS'
9066 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9067 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9068 cross_compiling=$ac_cv_prog_cxx_cross
9069
9070   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
9071 echo "configure:9072: checking for powl declaration" >&5
9072   cat > conftest.$ac_ext <<EOF
9073 #line 9074 "configure"
9074 #include "confdefs.h"
9075 #include <math.h>
9076 int main() {
9077  powl(0, 0);
9078 ; return 0; }
9079 EOF
9080 if { (eval echo configure:9081: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9081   rm -rf conftest*
9082   use_powl=yes
9083 else
9084   echo "configure: failed program was:" >&5
9085   cat conftest.$ac_ext >&5
9086   rm -rf conftest*
9087   use_powl=no
9088 fi
9089 rm -f conftest*
9090   echo "$ac_t""$use_powl" 1>&6
9091   ac_ext=c
9092 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9093 ac_cpp='$CPP $CPPFLAGS'
9094 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9095 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9096 cross_compiling=$ac_cv_prog_cc_cross
9097
9098   if test x$use_powl = x"yes"; then
9099     for ac_func in powl
9100 do
9101 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9102 echo "configure:9103: checking for $ac_func" >&5
9103 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9104   echo $ac_n "(cached) $ac_c" 1>&6
9105 else
9106   cat > conftest.$ac_ext <<EOF
9107 #line 9108 "configure"
9108 #include "confdefs.h"
9109 /* System header to define __stub macros and hopefully few prototypes,
9110     which can conflict with char $ac_func(); below.  */
9111 #include <assert.h>
9112 /* Override any gcc2 internal prototype to avoid an error.  */
9113 /* We use char because int might match the return type of a gcc2
9114     builtin and then its argument prototype would still apply.  */
9115 char $ac_func();
9116
9117 int main() {
9118
9119 /* The GNU C library defines this for functions which it implements
9120     to always fail with ENOSYS.  Some functions are actually named
9121     something starting with __ and the normal name is an alias.  */
9122 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9123 choke me
9124 #else
9125 $ac_func();
9126 #endif
9127
9128 ; return 0; }
9129 EOF
9130 if { (eval echo configure:9131: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9131   rm -rf conftest*
9132   eval "ac_cv_func_$ac_func=yes"
9133 else
9134   echo "configure: failed program was:" >&5
9135   cat conftest.$ac_ext >&5
9136   rm -rf conftest*
9137   eval "ac_cv_func_$ac_func=no"
9138 fi
9139 rm -f conftest*
9140 fi
9141
9142 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9143   echo "$ac_t""yes" 1>&6
9144     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9145   cat >> confdefs.h <<EOF
9146 #define $ac_tr_func 1
9147 EOF
9148
9149 else
9150   echo "$ac_t""no" 1>&6
9151 fi
9152 done
9153
9154   fi
9155
9156
9157
9158   ac_ext=C
9159 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9160 ac_cpp='$CXXCPP $CPPFLAGS'
9161 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9162 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9163 cross_compiling=$ac_cv_prog_cxx_cross
9164
9165   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
9166 echo "configure:9167: checking for sinl declaration" >&5
9167   cat > conftest.$ac_ext <<EOF
9168 #line 9169 "configure"
9169 #include "confdefs.h"
9170 #include <math.h>
9171 int main() {
9172  sinl(0);
9173 ; return 0; }
9174 EOF
9175 if { (eval echo configure:9176: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9176   rm -rf conftest*
9177   use_sinl=yes
9178 else
9179   echo "configure: failed program was:" >&5
9180   cat conftest.$ac_ext >&5
9181   rm -rf conftest*
9182   use_sinl=no
9183 fi
9184 rm -f conftest*
9185   echo "$ac_t""$use_sinl" 1>&6
9186   ac_ext=c
9187 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9188 ac_cpp='$CPP $CPPFLAGS'
9189 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9190 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9191 cross_compiling=$ac_cv_prog_cc_cross
9192
9193   if test x$use_sinl = x"yes"; then
9194     for ac_func in sinl
9195 do
9196 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9197 echo "configure:9198: checking for $ac_func" >&5
9198 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9199   echo $ac_n "(cached) $ac_c" 1>&6
9200 else
9201   cat > conftest.$ac_ext <<EOF
9202 #line 9203 "configure"
9203 #include "confdefs.h"
9204 /* System header to define __stub macros and hopefully few prototypes,
9205     which can conflict with char $ac_func(); below.  */
9206 #include <assert.h>
9207 /* Override any gcc2 internal prototype to avoid an error.  */
9208 /* We use char because int might match the return type of a gcc2
9209     builtin and then its argument prototype would still apply.  */
9210 char $ac_func();
9211
9212 int main() {
9213
9214 /* The GNU C library defines this for functions which it implements
9215     to always fail with ENOSYS.  Some functions are actually named
9216     something starting with __ and the normal name is an alias.  */
9217 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9218 choke me
9219 #else
9220 $ac_func();
9221 #endif
9222
9223 ; return 0; }
9224 EOF
9225 if { (eval echo configure:9226: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9226   rm -rf conftest*
9227   eval "ac_cv_func_$ac_func=yes"
9228 else
9229   echo "configure: failed program was:" >&5
9230   cat conftest.$ac_ext >&5
9231   rm -rf conftest*
9232   eval "ac_cv_func_$ac_func=no"
9233 fi
9234 rm -f conftest*
9235 fi
9236
9237 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9238   echo "$ac_t""yes" 1>&6
9239     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9240   cat >> confdefs.h <<EOF
9241 #define $ac_tr_func 1
9242 EOF
9243
9244 else
9245   echo "$ac_t""no" 1>&6
9246 fi
9247 done
9248
9249   fi
9250
9251
9252
9253   ac_ext=C
9254 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9255 ac_cpp='$CXXCPP $CPPFLAGS'
9256 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9257 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9258 cross_compiling=$ac_cv_prog_cxx_cross
9259
9260   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
9261 echo "configure:9262: checking for sinhl declaration" >&5
9262   cat > conftest.$ac_ext <<EOF
9263 #line 9264 "configure"
9264 #include "confdefs.h"
9265 #include <math.h>
9266 int main() {
9267  sinhl(0);
9268 ; return 0; }
9269 EOF
9270 if { (eval echo configure:9271: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9271   rm -rf conftest*
9272   use_sinhl=yes
9273 else
9274   echo "configure: failed program was:" >&5
9275   cat conftest.$ac_ext >&5
9276   rm -rf conftest*
9277   use_sinhl=no
9278 fi
9279 rm -f conftest*
9280   echo "$ac_t""$use_sinhl" 1>&6
9281   ac_ext=c
9282 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9283 ac_cpp='$CPP $CPPFLAGS'
9284 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9285 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9286 cross_compiling=$ac_cv_prog_cc_cross
9287
9288   if test x$use_sinhl = x"yes"; then
9289     for ac_func in sinhl
9290 do
9291 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9292 echo "configure:9293: checking for $ac_func" >&5
9293 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9294   echo $ac_n "(cached) $ac_c" 1>&6
9295 else
9296   cat > conftest.$ac_ext <<EOF
9297 #line 9298 "configure"
9298 #include "confdefs.h"
9299 /* System header to define __stub macros and hopefully few prototypes,
9300     which can conflict with char $ac_func(); below.  */
9301 #include <assert.h>
9302 /* Override any gcc2 internal prototype to avoid an error.  */
9303 /* We use char because int might match the return type of a gcc2
9304     builtin and then its argument prototype would still apply.  */
9305 char $ac_func();
9306
9307 int main() {
9308
9309 /* The GNU C library defines this for functions which it implements
9310     to always fail with ENOSYS.  Some functions are actually named
9311     something starting with __ and the normal name is an alias.  */
9312 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9313 choke me
9314 #else
9315 $ac_func();
9316 #endif
9317
9318 ; return 0; }
9319 EOF
9320 if { (eval echo configure:9321: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9321   rm -rf conftest*
9322   eval "ac_cv_func_$ac_func=yes"
9323 else
9324   echo "configure: failed program was:" >&5
9325   cat conftest.$ac_ext >&5
9326   rm -rf conftest*
9327   eval "ac_cv_func_$ac_func=no"
9328 fi
9329 rm -f conftest*
9330 fi
9331
9332 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9333   echo "$ac_t""yes" 1>&6
9334     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9335   cat >> confdefs.h <<EOF
9336 #define $ac_tr_func 1
9337 EOF
9338
9339 else
9340   echo "$ac_t""no" 1>&6
9341 fi
9342 done
9343
9344   fi
9345
9346
9347
9348   ac_ext=C
9349 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9350 ac_cpp='$CXXCPP $CPPFLAGS'
9351 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9352 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9353 cross_compiling=$ac_cv_prog_cxx_cross
9354
9355   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
9356 echo "configure:9357: checking for sqrtl declaration" >&5
9357   cat > conftest.$ac_ext <<EOF
9358 #line 9359 "configure"
9359 #include "confdefs.h"
9360 #include <math.h>
9361 int main() {
9362  sqrtl(0);
9363 ; return 0; }
9364 EOF
9365 if { (eval echo configure:9366: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9366   rm -rf conftest*
9367   use_sqrtl=yes
9368 else
9369   echo "configure: failed program was:" >&5
9370   cat conftest.$ac_ext >&5
9371   rm -rf conftest*
9372   use_sqrtl=no
9373 fi
9374 rm -f conftest*
9375   echo "$ac_t""$use_sqrtl" 1>&6
9376   ac_ext=c
9377 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9378 ac_cpp='$CPP $CPPFLAGS'
9379 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9380 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9381 cross_compiling=$ac_cv_prog_cc_cross
9382
9383   if test x$use_sqrtl = x"yes"; then
9384     for ac_func in sqrtl
9385 do
9386 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9387 echo "configure:9388: checking for $ac_func" >&5
9388 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9389   echo $ac_n "(cached) $ac_c" 1>&6
9390 else
9391   cat > conftest.$ac_ext <<EOF
9392 #line 9393 "configure"
9393 #include "confdefs.h"
9394 /* System header to define __stub macros and hopefully few prototypes,
9395     which can conflict with char $ac_func(); below.  */
9396 #include <assert.h>
9397 /* Override any gcc2 internal prototype to avoid an error.  */
9398 /* We use char because int might match the return type of a gcc2
9399     builtin and then its argument prototype would still apply.  */
9400 char $ac_func();
9401
9402 int main() {
9403
9404 /* The GNU C library defines this for functions which it implements
9405     to always fail with ENOSYS.  Some functions are actually named
9406     something starting with __ and the normal name is an alias.  */
9407 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9408 choke me
9409 #else
9410 $ac_func();
9411 #endif
9412
9413 ; return 0; }
9414 EOF
9415 if { (eval echo configure:9416: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9416   rm -rf conftest*
9417   eval "ac_cv_func_$ac_func=yes"
9418 else
9419   echo "configure: failed program was:" >&5
9420   cat conftest.$ac_ext >&5
9421   rm -rf conftest*
9422   eval "ac_cv_func_$ac_func=no"
9423 fi
9424 rm -f conftest*
9425 fi
9426
9427 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9428   echo "$ac_t""yes" 1>&6
9429     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9430   cat >> confdefs.h <<EOF
9431 #define $ac_tr_func 1
9432 EOF
9433
9434 else
9435   echo "$ac_t""no" 1>&6
9436 fi
9437 done
9438
9439   fi
9440
9441
9442
9443   ac_ext=C
9444 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9445 ac_cpp='$CXXCPP $CPPFLAGS'
9446 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9447 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9448 cross_compiling=$ac_cv_prog_cxx_cross
9449
9450   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
9451 echo "configure:9452: checking for tanl declaration" >&5
9452   cat > conftest.$ac_ext <<EOF
9453 #line 9454 "configure"
9454 #include "confdefs.h"
9455 #include <math.h>
9456 int main() {
9457  tanl(0);
9458 ; return 0; }
9459 EOF
9460 if { (eval echo configure:9461: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9461   rm -rf conftest*
9462   use_tanl=yes
9463 else
9464   echo "configure: failed program was:" >&5
9465   cat conftest.$ac_ext >&5
9466   rm -rf conftest*
9467   use_tanl=no
9468 fi
9469 rm -f conftest*
9470   echo "$ac_t""$use_tanl" 1>&6
9471   ac_ext=c
9472 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9473 ac_cpp='$CPP $CPPFLAGS'
9474 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9475 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9476 cross_compiling=$ac_cv_prog_cc_cross
9477
9478   if test x$use_tanl = x"yes"; then
9479     for ac_func in tanl
9480 do
9481 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9482 echo "configure:9483: checking for $ac_func" >&5
9483 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9484   echo $ac_n "(cached) $ac_c" 1>&6
9485 else
9486   cat > conftest.$ac_ext <<EOF
9487 #line 9488 "configure"
9488 #include "confdefs.h"
9489 /* System header to define __stub macros and hopefully few prototypes,
9490     which can conflict with char $ac_func(); below.  */
9491 #include <assert.h>
9492 /* Override any gcc2 internal prototype to avoid an error.  */
9493 /* We use char because int might match the return type of a gcc2
9494     builtin and then its argument prototype would still apply.  */
9495 char $ac_func();
9496
9497 int main() {
9498
9499 /* The GNU C library defines this for functions which it implements
9500     to always fail with ENOSYS.  Some functions are actually named
9501     something starting with __ and the normal name is an alias.  */
9502 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9503 choke me
9504 #else
9505 $ac_func();
9506 #endif
9507
9508 ; return 0; }
9509 EOF
9510 if { (eval echo configure:9511: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9511   rm -rf conftest*
9512   eval "ac_cv_func_$ac_func=yes"
9513 else
9514   echo "configure: failed program was:" >&5
9515   cat conftest.$ac_ext >&5
9516   rm -rf conftest*
9517   eval "ac_cv_func_$ac_func=no"
9518 fi
9519 rm -f conftest*
9520 fi
9521
9522 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9523   echo "$ac_t""yes" 1>&6
9524     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9525   cat >> confdefs.h <<EOF
9526 #define $ac_tr_func 1
9527 EOF
9528
9529 else
9530   echo "$ac_t""no" 1>&6
9531 fi
9532 done
9533
9534   fi
9535
9536
9537
9538   ac_ext=C
9539 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9540 ac_cpp='$CXXCPP $CPPFLAGS'
9541 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9542 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9543 cross_compiling=$ac_cv_prog_cxx_cross
9544
9545   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
9546 echo "configure:9547: checking for tanhl declaration" >&5
9547   cat > conftest.$ac_ext <<EOF
9548 #line 9549 "configure"
9549 #include "confdefs.h"
9550 #include <math.h>
9551 int main() {
9552  tanhl(0);
9553 ; return 0; }
9554 EOF
9555 if { (eval echo configure:9556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9556   rm -rf conftest*
9557   use_tanhl=yes
9558 else
9559   echo "configure: failed program was:" >&5
9560   cat conftest.$ac_ext >&5
9561   rm -rf conftest*
9562   use_tanhl=no
9563 fi
9564 rm -f conftest*
9565   echo "$ac_t""$use_tanhl" 1>&6
9566   ac_ext=c
9567 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9568 ac_cpp='$CPP $CPPFLAGS'
9569 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9570 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9571 cross_compiling=$ac_cv_prog_cc_cross
9572
9573   if test x$use_tanhl = x"yes"; then
9574     for ac_func in tanhl
9575 do
9576 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9577 echo "configure:9578: checking for $ac_func" >&5
9578 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9579   echo $ac_n "(cached) $ac_c" 1>&6
9580 else
9581   cat > conftest.$ac_ext <<EOF
9582 #line 9583 "configure"
9583 #include "confdefs.h"
9584 /* System header to define __stub macros and hopefully few prototypes,
9585     which can conflict with char $ac_func(); below.  */
9586 #include <assert.h>
9587 /* Override any gcc2 internal prototype to avoid an error.  */
9588 /* We use char because int might match the return type of a gcc2
9589     builtin and then its argument prototype would still apply.  */
9590 char $ac_func();
9591
9592 int main() {
9593
9594 /* The GNU C library defines this for functions which it implements
9595     to always fail with ENOSYS.  Some functions are actually named
9596     something starting with __ and the normal name is an alias.  */
9597 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9598 choke me
9599 #else
9600 $ac_func();
9601 #endif
9602
9603 ; return 0; }
9604 EOF
9605 if { (eval echo configure:9606: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9606   rm -rf conftest*
9607   eval "ac_cv_func_$ac_func=yes"
9608 else
9609   echo "configure: failed program was:" >&5
9610   cat conftest.$ac_ext >&5
9611   rm -rf conftest*
9612   eval "ac_cv_func_$ac_func=no"
9613 fi
9614 rm -f conftest*
9615 fi
9616
9617 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9618   echo "$ac_t""yes" 1>&6
9619     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9620   cat >> confdefs.h <<EOF
9621 #define $ac_tr_func 1
9622 EOF
9623
9624 else
9625   echo "$ac_t""no" 1>&6
9626 fi
9627 done
9628
9629   fi
9630
9631
9632
9633   ac_ext=C
9634 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9635 ac_cpp='$CXXCPP $CPPFLAGS'
9636 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9637 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9638 cross_compiling=$ac_cv_prog_cxx_cross
9639
9640   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
9641 echo "configure:9642: checking for sincosl declaration" >&5
9642   cat > conftest.$ac_ext <<EOF
9643 #line 9644 "configure"
9644 #include "confdefs.h"
9645 #include <math.h>
9646 int main() {
9647  sincosl(0, 0, 0);
9648 ; return 0; }
9649 EOF
9650 if { (eval echo configure:9651: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9651   rm -rf conftest*
9652   use_sincosl=yes
9653 else
9654   echo "configure: failed program was:" >&5
9655   cat conftest.$ac_ext >&5
9656   rm -rf conftest*
9657   use_sincosl=no
9658 fi
9659 rm -f conftest*
9660   echo "$ac_t""$use_sincosl" 1>&6
9661   ac_ext=c
9662 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9663 ac_cpp='$CPP $CPPFLAGS'
9664 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9665 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9666 cross_compiling=$ac_cv_prog_cc_cross
9667
9668   if test x$use_sincosl = x"yes"; then
9669     for ac_func in sincosl
9670 do
9671 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9672 echo "configure:9673: checking for $ac_func" >&5
9673 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9674   echo $ac_n "(cached) $ac_c" 1>&6
9675 else
9676   cat > conftest.$ac_ext <<EOF
9677 #line 9678 "configure"
9678 #include "confdefs.h"
9679 /* System header to define __stub macros and hopefully few prototypes,
9680     which can conflict with char $ac_func(); below.  */
9681 #include <assert.h>
9682 /* Override any gcc2 internal prototype to avoid an error.  */
9683 /* We use char because int might match the return type of a gcc2
9684     builtin and then its argument prototype would still apply.  */
9685 char $ac_func();
9686
9687 int main() {
9688
9689 /* The GNU C library defines this for functions which it implements
9690     to always fail with ENOSYS.  Some functions are actually named
9691     something starting with __ and the normal name is an alias.  */
9692 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9693 choke me
9694 #else
9695 $ac_func();
9696 #endif
9697
9698 ; return 0; }
9699 EOF
9700 if { (eval echo configure:9701: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9701   rm -rf conftest*
9702   eval "ac_cv_func_$ac_func=yes"
9703 else
9704   echo "configure: failed program was:" >&5
9705   cat conftest.$ac_ext >&5
9706   rm -rf conftest*
9707   eval "ac_cv_func_$ac_func=no"
9708 fi
9709 rm -f conftest*
9710 fi
9711
9712 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9713   echo "$ac_t""yes" 1>&6
9714     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9715   cat >> confdefs.h <<EOF
9716 #define $ac_tr_func 1
9717 EOF
9718
9719 else
9720   echo "$ac_t""no" 1>&6
9721 fi
9722 done
9723
9724   fi
9725
9726
9727
9728   ac_ext=C
9729 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9730 ac_cpp='$CXXCPP $CPPFLAGS'
9731 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9732 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9733 cross_compiling=$ac_cv_prog_cxx_cross
9734
9735   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
9736 echo "configure:9737: checking for finitel declaration" >&5
9737   cat > conftest.$ac_ext <<EOF
9738 #line 9739 "configure"
9739 #include "confdefs.h"
9740 #include <math.h>
9741 int main() {
9742  finitel(0);
9743 ; return 0; }
9744 EOF
9745 if { (eval echo configure:9746: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9746   rm -rf conftest*
9747   use_finitel=yes
9748 else
9749   echo "configure: failed program was:" >&5
9750   cat conftest.$ac_ext >&5
9751   rm -rf conftest*
9752   use_finitel=no
9753 fi
9754 rm -f conftest*
9755   echo "$ac_t""$use_finitel" 1>&6
9756   ac_ext=c
9757 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9758 ac_cpp='$CPP $CPPFLAGS'
9759 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9760 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9761 cross_compiling=$ac_cv_prog_cc_cross
9762
9763   if test x$use_finitel = x"yes"; then
9764     for ac_func in finitel
9765 do
9766 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9767 echo "configure:9768: checking for $ac_func" >&5
9768 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9769   echo $ac_n "(cached) $ac_c" 1>&6
9770 else
9771   cat > conftest.$ac_ext <<EOF
9772 #line 9773 "configure"
9773 #include "confdefs.h"
9774 /* System header to define __stub macros and hopefully few prototypes,
9775     which can conflict with char $ac_func(); below.  */
9776 #include <assert.h>
9777 /* Override any gcc2 internal prototype to avoid an error.  */
9778 /* We use char because int might match the return type of a gcc2
9779     builtin and then its argument prototype would still apply.  */
9780 char $ac_func();
9781
9782 int main() {
9783
9784 /* The GNU C library defines this for functions which it implements
9785     to always fail with ENOSYS.  Some functions are actually named
9786     something starting with __ and the normal name is an alias.  */
9787 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9788 choke me
9789 #else
9790 $ac_func();
9791 #endif
9792
9793 ; return 0; }
9794 EOF
9795 if { (eval echo configure:9796: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9796   rm -rf conftest*
9797   eval "ac_cv_func_$ac_func=yes"
9798 else
9799   echo "configure: failed program was:" >&5
9800   cat conftest.$ac_ext >&5
9801   rm -rf conftest*
9802   eval "ac_cv_func_$ac_func=no"
9803 fi
9804 rm -f conftest*
9805 fi
9806
9807 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9808   echo "$ac_t""yes" 1>&6
9809     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9810   cat >> confdefs.h <<EOF
9811 #define $ac_tr_func 1
9812 EOF
9813
9814 else
9815   echo "$ac_t""no" 1>&6
9816 fi
9817 done
9818
9819   fi
9820
9821
9822
9823
9824   ac_ext=C
9825 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9826 ac_cpp='$CXXCPP $CPPFLAGS'
9827 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9828 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9829 cross_compiling=$ac_cv_prog_cxx_cross
9830
9831   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
9832 echo "configure:9833: checking for _isinf declaration" >&5
9833   cat > conftest.$ac_ext <<EOF
9834 #line 9835 "configure"
9835 #include "confdefs.h"
9836 #include <math.h>
9837 int main() {
9838  _isinf(0);
9839 ; return 0; }
9840 EOF
9841 if { (eval echo configure:9842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9842   rm -rf conftest*
9843   use__isinf=yes
9844 else
9845   echo "configure: failed program was:" >&5
9846   cat conftest.$ac_ext >&5
9847   rm -rf conftest*
9848   use__isinf=no
9849 fi
9850 rm -f conftest*
9851   echo "$ac_t""$use__isinf" 1>&6
9852   ac_ext=c
9853 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9854 ac_cpp='$CPP $CPPFLAGS'
9855 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9856 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9857 cross_compiling=$ac_cv_prog_cc_cross
9858
9859   if test x$use__isinf = x"yes"; then
9860     for ac_func in _isinf
9861 do
9862 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9863 echo "configure:9864: checking for $ac_func" >&5
9864 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9865   echo $ac_n "(cached) $ac_c" 1>&6
9866 else
9867   cat > conftest.$ac_ext <<EOF
9868 #line 9869 "configure"
9869 #include "confdefs.h"
9870 /* System header to define __stub macros and hopefully few prototypes,
9871     which can conflict with char $ac_func(); below.  */
9872 #include <assert.h>
9873 /* Override any gcc2 internal prototype to avoid an error.  */
9874 /* We use char because int might match the return type of a gcc2
9875     builtin and then its argument prototype would still apply.  */
9876 char $ac_func();
9877
9878 int main() {
9879
9880 /* The GNU C library defines this for functions which it implements
9881     to always fail with ENOSYS.  Some functions are actually named
9882     something starting with __ and the normal name is an alias.  */
9883 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9884 choke me
9885 #else
9886 $ac_func();
9887 #endif
9888
9889 ; return 0; }
9890 EOF
9891 if { (eval echo configure:9892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9892   rm -rf conftest*
9893   eval "ac_cv_func_$ac_func=yes"
9894 else
9895   echo "configure: failed program was:" >&5
9896   cat conftest.$ac_ext >&5
9897   rm -rf conftest*
9898   eval "ac_cv_func_$ac_func=no"
9899 fi
9900 rm -f conftest*
9901 fi
9902
9903 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9904   echo "$ac_t""yes" 1>&6
9905     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9906   cat >> confdefs.h <<EOF
9907 #define $ac_tr_func 1
9908 EOF
9909
9910 else
9911   echo "$ac_t""no" 1>&6
9912 fi
9913 done
9914
9915   fi
9916
9917
9918
9919   ac_ext=C
9920 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9921 ac_cpp='$CXXCPP $CPPFLAGS'
9922 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9923 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9924 cross_compiling=$ac_cv_prog_cxx_cross
9925
9926   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
9927 echo "configure:9928: checking for _isnan declaration" >&5
9928   cat > conftest.$ac_ext <<EOF
9929 #line 9930 "configure"
9930 #include "confdefs.h"
9931 #include <math.h>
9932 int main() {
9933  _isnan(0);
9934 ; return 0; }
9935 EOF
9936 if { (eval echo configure:9937: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9937   rm -rf conftest*
9938   use__isnan=yes
9939 else
9940   echo "configure: failed program was:" >&5
9941   cat conftest.$ac_ext >&5
9942   rm -rf conftest*
9943   use__isnan=no
9944 fi
9945 rm -f conftest*
9946   echo "$ac_t""$use__isnan" 1>&6
9947   ac_ext=c
9948 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9949 ac_cpp='$CPP $CPPFLAGS'
9950 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9951 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9952 cross_compiling=$ac_cv_prog_cc_cross
9953
9954   if test x$use__isnan = x"yes"; then
9955     for ac_func in _isnan
9956 do
9957 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9958 echo "configure:9959: checking for $ac_func" >&5
9959 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9960   echo $ac_n "(cached) $ac_c" 1>&6
9961 else
9962   cat > conftest.$ac_ext <<EOF
9963 #line 9964 "configure"
9964 #include "confdefs.h"
9965 /* System header to define __stub macros and hopefully few prototypes,
9966     which can conflict with char $ac_func(); below.  */
9967 #include <assert.h>
9968 /* Override any gcc2 internal prototype to avoid an error.  */
9969 /* We use char because int might match the return type of a gcc2
9970     builtin and then its argument prototype would still apply.  */
9971 char $ac_func();
9972
9973 int main() {
9974
9975 /* The GNU C library defines this for functions which it implements
9976     to always fail with ENOSYS.  Some functions are actually named
9977     something starting with __ and the normal name is an alias.  */
9978 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9979 choke me
9980 #else
9981 $ac_func();
9982 #endif
9983
9984 ; return 0; }
9985 EOF
9986 if { (eval echo configure:9987: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9987   rm -rf conftest*
9988   eval "ac_cv_func_$ac_func=yes"
9989 else
9990   echo "configure: failed program was:" >&5
9991   cat conftest.$ac_ext >&5
9992   rm -rf conftest*
9993   eval "ac_cv_func_$ac_func=no"
9994 fi
9995 rm -f conftest*
9996 fi
9997
9998 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9999   echo "$ac_t""yes" 1>&6
10000     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10001   cat >> confdefs.h <<EOF
10002 #define $ac_tr_func 1
10003 EOF
10004
10005 else
10006   echo "$ac_t""no" 1>&6
10007 fi
10008 done
10009
10010   fi
10011
10012
10013
10014   ac_ext=C
10015 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10016 ac_cpp='$CXXCPP $CPPFLAGS'
10017 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10018 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10019 cross_compiling=$ac_cv_prog_cxx_cross
10020
10021   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
10022 echo "configure:10023: checking for _finite declaration" >&5
10023   cat > conftest.$ac_ext <<EOF
10024 #line 10025 "configure"
10025 #include "confdefs.h"
10026 #include <math.h>
10027 int main() {
10028  _finite(0);
10029 ; return 0; }
10030 EOF
10031 if { (eval echo configure:10032: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10032   rm -rf conftest*
10033   use__finite=yes
10034 else
10035   echo "configure: failed program was:" >&5
10036   cat conftest.$ac_ext >&5
10037   rm -rf conftest*
10038   use__finite=no
10039 fi
10040 rm -f conftest*
10041   echo "$ac_t""$use__finite" 1>&6
10042   ac_ext=c
10043 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10044 ac_cpp='$CPP $CPPFLAGS'
10045 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10046 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10047 cross_compiling=$ac_cv_prog_cc_cross
10048
10049   if test x$use__finite = x"yes"; then
10050     for ac_func in _finite
10051 do
10052 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10053 echo "configure:10054: checking for $ac_func" >&5
10054 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10055   echo $ac_n "(cached) $ac_c" 1>&6
10056 else
10057   cat > conftest.$ac_ext <<EOF
10058 #line 10059 "configure"
10059 #include "confdefs.h"
10060 /* System header to define __stub macros and hopefully few prototypes,
10061     which can conflict with char $ac_func(); below.  */
10062 #include <assert.h>
10063 /* Override any gcc2 internal prototype to avoid an error.  */
10064 /* We use char because int might match the return type of a gcc2
10065     builtin and then its argument prototype would still apply.  */
10066 char $ac_func();
10067
10068 int main() {
10069
10070 /* The GNU C library defines this for functions which it implements
10071     to always fail with ENOSYS.  Some functions are actually named
10072     something starting with __ and the normal name is an alias.  */
10073 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10074 choke me
10075 #else
10076 $ac_func();
10077 #endif
10078
10079 ; return 0; }
10080 EOF
10081 if { (eval echo configure:10082: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10082   rm -rf conftest*
10083   eval "ac_cv_func_$ac_func=yes"
10084 else
10085   echo "configure: failed program was:" >&5
10086   cat conftest.$ac_ext >&5
10087   rm -rf conftest*
10088   eval "ac_cv_func_$ac_func=no"
10089 fi
10090 rm -f conftest*
10091 fi
10092
10093 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10094   echo "$ac_t""yes" 1>&6
10095     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10096   cat >> confdefs.h <<EOF
10097 #define $ac_tr_func 1
10098 EOF
10099
10100 else
10101   echo "$ac_t""no" 1>&6
10102 fi
10103 done
10104
10105   fi
10106
10107
10108
10109   ac_ext=C
10110 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10111 ac_cpp='$CXXCPP $CPPFLAGS'
10112 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10113 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10114 cross_compiling=$ac_cv_prog_cxx_cross
10115
10116   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
10117 echo "configure:10118: checking for _copysign declaration" >&5
10118   cat > conftest.$ac_ext <<EOF
10119 #line 10120 "configure"
10120 #include "confdefs.h"
10121 #include <math.h>
10122 int main() {
10123  _copysign(0, 0);
10124 ; return 0; }
10125 EOF
10126 if { (eval echo configure:10127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10127   rm -rf conftest*
10128   use__copysign=yes
10129 else
10130   echo "configure: failed program was:" >&5
10131   cat conftest.$ac_ext >&5
10132   rm -rf conftest*
10133   use__copysign=no
10134 fi
10135 rm -f conftest*
10136   echo "$ac_t""$use__copysign" 1>&6
10137   ac_ext=c
10138 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10139 ac_cpp='$CPP $CPPFLAGS'
10140 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10141 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10142 cross_compiling=$ac_cv_prog_cc_cross
10143
10144   if test x$use__copysign = x"yes"; then
10145     for ac_func in _copysign
10146 do
10147 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10148 echo "configure:10149: checking for $ac_func" >&5
10149 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10150   echo $ac_n "(cached) $ac_c" 1>&6
10151 else
10152   cat > conftest.$ac_ext <<EOF
10153 #line 10154 "configure"
10154 #include "confdefs.h"
10155 /* System header to define __stub macros and hopefully few prototypes,
10156     which can conflict with char $ac_func(); below.  */
10157 #include <assert.h>
10158 /* Override any gcc2 internal prototype to avoid an error.  */
10159 /* We use char because int might match the return type of a gcc2
10160     builtin and then its argument prototype would still apply.  */
10161 char $ac_func();
10162
10163 int main() {
10164
10165 /* The GNU C library defines this for functions which it implements
10166     to always fail with ENOSYS.  Some functions are actually named
10167     something starting with __ and the normal name is an alias.  */
10168 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10169 choke me
10170 #else
10171 $ac_func();
10172 #endif
10173
10174 ; return 0; }
10175 EOF
10176 if { (eval echo configure:10177: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10177   rm -rf conftest*
10178   eval "ac_cv_func_$ac_func=yes"
10179 else
10180   echo "configure: failed program was:" >&5
10181   cat conftest.$ac_ext >&5
10182   rm -rf conftest*
10183   eval "ac_cv_func_$ac_func=no"
10184 fi
10185 rm -f conftest*
10186 fi
10187
10188 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10189   echo "$ac_t""yes" 1>&6
10190     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10191   cat >> confdefs.h <<EOF
10192 #define $ac_tr_func 1
10193 EOF
10194
10195 else
10196   echo "$ac_t""no" 1>&6
10197 fi
10198 done
10199
10200   fi
10201
10202
10203
10204   ac_ext=C
10205 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10206 ac_cpp='$CXXCPP $CPPFLAGS'
10207 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10208 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10209 cross_compiling=$ac_cv_prog_cxx_cross
10210
10211   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
10212 echo "configure:10213: checking for _sincos declaration" >&5
10213   cat > conftest.$ac_ext <<EOF
10214 #line 10215 "configure"
10215 #include "confdefs.h"
10216 #include <math.h>
10217 int main() {
10218  _sincos(0, 0, 0);
10219 ; return 0; }
10220 EOF
10221 if { (eval echo configure:10222: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10222   rm -rf conftest*
10223   use__sincos=yes
10224 else
10225   echo "configure: failed program was:" >&5
10226   cat conftest.$ac_ext >&5
10227   rm -rf conftest*
10228   use__sincos=no
10229 fi
10230 rm -f conftest*
10231   echo "$ac_t""$use__sincos" 1>&6
10232   ac_ext=c
10233 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10234 ac_cpp='$CPP $CPPFLAGS'
10235 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10236 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10237 cross_compiling=$ac_cv_prog_cc_cross
10238
10239   if test x$use__sincos = x"yes"; then
10240     for ac_func in _sincos
10241 do
10242 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10243 echo "configure:10244: checking for $ac_func" >&5
10244 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10245   echo $ac_n "(cached) $ac_c" 1>&6
10246 else
10247   cat > conftest.$ac_ext <<EOF
10248 #line 10249 "configure"
10249 #include "confdefs.h"
10250 /* System header to define __stub macros and hopefully few prototypes,
10251     which can conflict with char $ac_func(); below.  */
10252 #include <assert.h>
10253 /* Override any gcc2 internal prototype to avoid an error.  */
10254 /* We use char because int might match the return type of a gcc2
10255     builtin and then its argument prototype would still apply.  */
10256 char $ac_func();
10257
10258 int main() {
10259
10260 /* The GNU C library defines this for functions which it implements
10261     to always fail with ENOSYS.  Some functions are actually named
10262     something starting with __ and the normal name is an alias.  */
10263 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10264 choke me
10265 #else
10266 $ac_func();
10267 #endif
10268
10269 ; return 0; }
10270 EOF
10271 if { (eval echo configure:10272: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10272   rm -rf conftest*
10273   eval "ac_cv_func_$ac_func=yes"
10274 else
10275   echo "configure: failed program was:" >&5
10276   cat conftest.$ac_ext >&5
10277   rm -rf conftest*
10278   eval "ac_cv_func_$ac_func=no"
10279 fi
10280 rm -f conftest*
10281 fi
10282
10283 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10284   echo "$ac_t""yes" 1>&6
10285     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10286   cat >> confdefs.h <<EOF
10287 #define $ac_tr_func 1
10288 EOF
10289
10290 else
10291   echo "$ac_t""no" 1>&6
10292 fi
10293 done
10294
10295   fi
10296
10297
10298
10299   ac_ext=C
10300 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10301 ac_cpp='$CXXCPP $CPPFLAGS'
10302 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10303 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10304 cross_compiling=$ac_cv_prog_cxx_cross
10305
10306   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
10307 echo "configure:10308: checking for _fpclass declaration" >&5
10308   cat > conftest.$ac_ext <<EOF
10309 #line 10310 "configure"
10310 #include "confdefs.h"
10311 #include <math.h>
10312 int main() {
10313  _fpclass(0);
10314 ; return 0; }
10315 EOF
10316 if { (eval echo configure:10317: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10317   rm -rf conftest*
10318   use__fpclass=yes
10319 else
10320   echo "configure: failed program was:" >&5
10321   cat conftest.$ac_ext >&5
10322   rm -rf conftest*
10323   use__fpclass=no
10324 fi
10325 rm -f conftest*
10326   echo "$ac_t""$use__fpclass" 1>&6
10327   ac_ext=c
10328 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10329 ac_cpp='$CPP $CPPFLAGS'
10330 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10331 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10332 cross_compiling=$ac_cv_prog_cc_cross
10333
10334   if test x$use__fpclass = x"yes"; then
10335     for ac_func in _fpclass
10336 do
10337 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10338 echo "configure:10339: checking for $ac_func" >&5
10339 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10340   echo $ac_n "(cached) $ac_c" 1>&6
10341 else
10342   cat > conftest.$ac_ext <<EOF
10343 #line 10344 "configure"
10344 #include "confdefs.h"
10345 /* System header to define __stub macros and hopefully few prototypes,
10346     which can conflict with char $ac_func(); below.  */
10347 #include <assert.h>
10348 /* Override any gcc2 internal prototype to avoid an error.  */
10349 /* We use char because int might match the return type of a gcc2
10350     builtin and then its argument prototype would still apply.  */
10351 char $ac_func();
10352
10353 int main() {
10354
10355 /* The GNU C library defines this for functions which it implements
10356     to always fail with ENOSYS.  Some functions are actually named
10357     something starting with __ and the normal name is an alias.  */
10358 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10359 choke me
10360 #else
10361 $ac_func();
10362 #endif
10363
10364 ; return 0; }
10365 EOF
10366 if { (eval echo configure:10367: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10367   rm -rf conftest*
10368   eval "ac_cv_func_$ac_func=yes"
10369 else
10370   echo "configure: failed program was:" >&5
10371   cat conftest.$ac_ext >&5
10372   rm -rf conftest*
10373   eval "ac_cv_func_$ac_func=no"
10374 fi
10375 rm -f conftest*
10376 fi
10377
10378 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10379   echo "$ac_t""yes" 1>&6
10380     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10381   cat >> confdefs.h <<EOF
10382 #define $ac_tr_func 1
10383 EOF
10384
10385 else
10386   echo "$ac_t""no" 1>&6
10387 fi
10388 done
10389
10390   fi
10391
10392
10393
10394   ac_ext=C
10395 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10396 ac_cpp='$CXXCPP $CPPFLAGS'
10397 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10398 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10399 cross_compiling=$ac_cv_prog_cxx_cross
10400
10401   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
10402 echo "configure:10403: checking for _qfpclass declaration" >&5
10403   cat > conftest.$ac_ext <<EOF
10404 #line 10405 "configure"
10405 #include "confdefs.h"
10406 #include <math.h>
10407 int main() {
10408  _qfpclass(0);
10409 ; return 0; }
10410 EOF
10411 if { (eval echo configure:10412: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10412   rm -rf conftest*
10413   use__qfpclass=yes
10414 else
10415   echo "configure: failed program was:" >&5
10416   cat conftest.$ac_ext >&5
10417   rm -rf conftest*
10418   use__qfpclass=no
10419 fi
10420 rm -f conftest*
10421   echo "$ac_t""$use__qfpclass" 1>&6
10422   ac_ext=c
10423 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10424 ac_cpp='$CPP $CPPFLAGS'
10425 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10426 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10427 cross_compiling=$ac_cv_prog_cc_cross
10428
10429   if test x$use__qfpclass = x"yes"; then
10430     for ac_func in _qfpclass
10431 do
10432 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10433 echo "configure:10434: checking for $ac_func" >&5
10434 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10435   echo $ac_n "(cached) $ac_c" 1>&6
10436 else
10437   cat > conftest.$ac_ext <<EOF
10438 #line 10439 "configure"
10439 #include "confdefs.h"
10440 /* System header to define __stub macros and hopefully few prototypes,
10441     which can conflict with char $ac_func(); below.  */
10442 #include <assert.h>
10443 /* Override any gcc2 internal prototype to avoid an error.  */
10444 /* We use char because int might match the return type of a gcc2
10445     builtin and then its argument prototype would still apply.  */
10446 char $ac_func();
10447
10448 int main() {
10449
10450 /* The GNU C library defines this for functions which it implements
10451     to always fail with ENOSYS.  Some functions are actually named
10452     something starting with __ and the normal name is an alias.  */
10453 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10454 choke me
10455 #else
10456 $ac_func();
10457 #endif
10458
10459 ; return 0; }
10460 EOF
10461 if { (eval echo configure:10462: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10462   rm -rf conftest*
10463   eval "ac_cv_func_$ac_func=yes"
10464 else
10465   echo "configure: failed program was:" >&5
10466   cat conftest.$ac_ext >&5
10467   rm -rf conftest*
10468   eval "ac_cv_func_$ac_func=no"
10469 fi
10470 rm -f conftest*
10471 fi
10472
10473 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10474   echo "$ac_t""yes" 1>&6
10475     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10476   cat >> confdefs.h <<EOF
10477 #define $ac_tr_func 1
10478 EOF
10479
10480 else
10481   echo "$ac_t""no" 1>&6
10482 fi
10483 done
10484
10485   fi
10486
10487
10488
10489
10490   ac_ext=C
10491 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10492 ac_cpp='$CXXCPP $CPPFLAGS'
10493 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10494 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10495 cross_compiling=$ac_cv_prog_cxx_cross
10496
10497   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
10498 echo "configure:10499: checking for _isnanf declaration" >&5
10499   cat > conftest.$ac_ext <<EOF
10500 #line 10501 "configure"
10501 #include "confdefs.h"
10502 #include <math.h>
10503 int main() {
10504  _isnanf(0);
10505 ; return 0; }
10506 EOF
10507 if { (eval echo configure:10508: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10508   rm -rf conftest*
10509   use__isnanf=yes
10510 else
10511   echo "configure: failed program was:" >&5
10512   cat conftest.$ac_ext >&5
10513   rm -rf conftest*
10514   use__isnanf=no
10515 fi
10516 rm -f conftest*
10517   echo "$ac_t""$use__isnanf" 1>&6
10518   ac_ext=c
10519 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10520 ac_cpp='$CPP $CPPFLAGS'
10521 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10522 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10523 cross_compiling=$ac_cv_prog_cc_cross
10524
10525   if test x$use__isnanf = x"yes"; then
10526     for ac_func in _isnanf
10527 do
10528 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10529 echo "configure:10530: checking for $ac_func" >&5
10530 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10531   echo $ac_n "(cached) $ac_c" 1>&6
10532 else
10533   cat > conftest.$ac_ext <<EOF
10534 #line 10535 "configure"
10535 #include "confdefs.h"
10536 /* System header to define __stub macros and hopefully few prototypes,
10537     which can conflict with char $ac_func(); below.  */
10538 #include <assert.h>
10539 /* Override any gcc2 internal prototype to avoid an error.  */
10540 /* We use char because int might match the return type of a gcc2
10541     builtin and then its argument prototype would still apply.  */
10542 char $ac_func();
10543
10544 int main() {
10545
10546 /* The GNU C library defines this for functions which it implements
10547     to always fail with ENOSYS.  Some functions are actually named
10548     something starting with __ and the normal name is an alias.  */
10549 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10550 choke me
10551 #else
10552 $ac_func();
10553 #endif
10554
10555 ; return 0; }
10556 EOF
10557 if { (eval echo configure:10558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10558   rm -rf conftest*
10559   eval "ac_cv_func_$ac_func=yes"
10560 else
10561   echo "configure: failed program was:" >&5
10562   cat conftest.$ac_ext >&5
10563   rm -rf conftest*
10564   eval "ac_cv_func_$ac_func=no"
10565 fi
10566 rm -f conftest*
10567 fi
10568
10569 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10570   echo "$ac_t""yes" 1>&6
10571     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10572   cat >> confdefs.h <<EOF
10573 #define $ac_tr_func 1
10574 EOF
10575
10576 else
10577   echo "$ac_t""no" 1>&6
10578 fi
10579 done
10580
10581   fi
10582
10583
10584
10585   ac_ext=C
10586 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10587 ac_cpp='$CXXCPP $CPPFLAGS'
10588 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10589 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10590 cross_compiling=$ac_cv_prog_cxx_cross
10591
10592   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
10593 echo "configure:10594: checking for _isinff declaration" >&5
10594   cat > conftest.$ac_ext <<EOF
10595 #line 10596 "configure"
10596 #include "confdefs.h"
10597 #include <math.h>
10598 int main() {
10599  _isinff(0);
10600 ; return 0; }
10601 EOF
10602 if { (eval echo configure:10603: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10603   rm -rf conftest*
10604   use__isinff=yes
10605 else
10606   echo "configure: failed program was:" >&5
10607   cat conftest.$ac_ext >&5
10608   rm -rf conftest*
10609   use__isinff=no
10610 fi
10611 rm -f conftest*
10612   echo "$ac_t""$use__isinff" 1>&6
10613   ac_ext=c
10614 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10615 ac_cpp='$CPP $CPPFLAGS'
10616 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10617 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10618 cross_compiling=$ac_cv_prog_cc_cross
10619
10620   if test x$use__isinff = x"yes"; then
10621     for ac_func in _isinff
10622 do
10623 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10624 echo "configure:10625: checking for $ac_func" >&5
10625 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10626   echo $ac_n "(cached) $ac_c" 1>&6
10627 else
10628   cat > conftest.$ac_ext <<EOF
10629 #line 10630 "configure"
10630 #include "confdefs.h"
10631 /* System header to define __stub macros and hopefully few prototypes,
10632     which can conflict with char $ac_func(); below.  */
10633 #include <assert.h>
10634 /* Override any gcc2 internal prototype to avoid an error.  */
10635 /* We use char because int might match the return type of a gcc2
10636     builtin and then its argument prototype would still apply.  */
10637 char $ac_func();
10638
10639 int main() {
10640
10641 /* The GNU C library defines this for functions which it implements
10642     to always fail with ENOSYS.  Some functions are actually named
10643     something starting with __ and the normal name is an alias.  */
10644 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10645 choke me
10646 #else
10647 $ac_func();
10648 #endif
10649
10650 ; return 0; }
10651 EOF
10652 if { (eval echo configure:10653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10653   rm -rf conftest*
10654   eval "ac_cv_func_$ac_func=yes"
10655 else
10656   echo "configure: failed program was:" >&5
10657   cat conftest.$ac_ext >&5
10658   rm -rf conftest*
10659   eval "ac_cv_func_$ac_func=no"
10660 fi
10661 rm -f conftest*
10662 fi
10663
10664 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10665   echo "$ac_t""yes" 1>&6
10666     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10667   cat >> confdefs.h <<EOF
10668 #define $ac_tr_func 1
10669 EOF
10670
10671 else
10672   echo "$ac_t""no" 1>&6
10673 fi
10674 done
10675
10676   fi
10677
10678
10679
10680   ac_ext=C
10681 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10682 ac_cpp='$CXXCPP $CPPFLAGS'
10683 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10684 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10685 cross_compiling=$ac_cv_prog_cxx_cross
10686
10687   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
10688 echo "configure:10689: checking for _acosf declaration" >&5
10689   cat > conftest.$ac_ext <<EOF
10690 #line 10691 "configure"
10691 #include "confdefs.h"
10692 #include <math.h>
10693 int main() {
10694  _acosf(0);
10695 ; return 0; }
10696 EOF
10697 if { (eval echo configure:10698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10698   rm -rf conftest*
10699   use__acosf=yes
10700 else
10701   echo "configure: failed program was:" >&5
10702   cat conftest.$ac_ext >&5
10703   rm -rf conftest*
10704   use__acosf=no
10705 fi
10706 rm -f conftest*
10707   echo "$ac_t""$use__acosf" 1>&6
10708   ac_ext=c
10709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10710 ac_cpp='$CPP $CPPFLAGS'
10711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10713 cross_compiling=$ac_cv_prog_cc_cross
10714
10715   if test x$use__acosf = x"yes"; then
10716     for ac_func in _acosf
10717 do
10718 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10719 echo "configure:10720: checking for $ac_func" >&5
10720 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10721   echo $ac_n "(cached) $ac_c" 1>&6
10722 else
10723   cat > conftest.$ac_ext <<EOF
10724 #line 10725 "configure"
10725 #include "confdefs.h"
10726 /* System header to define __stub macros and hopefully few prototypes,
10727     which can conflict with char $ac_func(); below.  */
10728 #include <assert.h>
10729 /* Override any gcc2 internal prototype to avoid an error.  */
10730 /* We use char because int might match the return type of a gcc2
10731     builtin and then its argument prototype would still apply.  */
10732 char $ac_func();
10733
10734 int main() {
10735
10736 /* The GNU C library defines this for functions which it implements
10737     to always fail with ENOSYS.  Some functions are actually named
10738     something starting with __ and the normal name is an alias.  */
10739 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10740 choke me
10741 #else
10742 $ac_func();
10743 #endif
10744
10745 ; return 0; }
10746 EOF
10747 if { (eval echo configure:10748: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10748   rm -rf conftest*
10749   eval "ac_cv_func_$ac_func=yes"
10750 else
10751   echo "configure: failed program was:" >&5
10752   cat conftest.$ac_ext >&5
10753   rm -rf conftest*
10754   eval "ac_cv_func_$ac_func=no"
10755 fi
10756 rm -f conftest*
10757 fi
10758
10759 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10760   echo "$ac_t""yes" 1>&6
10761     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10762   cat >> confdefs.h <<EOF
10763 #define $ac_tr_func 1
10764 EOF
10765
10766 else
10767   echo "$ac_t""no" 1>&6
10768 fi
10769 done
10770
10771   fi
10772
10773
10774
10775   ac_ext=C
10776 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10777 ac_cpp='$CXXCPP $CPPFLAGS'
10778 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10779 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10780 cross_compiling=$ac_cv_prog_cxx_cross
10781
10782   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
10783 echo "configure:10784: checking for _asinf declaration" >&5
10784   cat > conftest.$ac_ext <<EOF
10785 #line 10786 "configure"
10786 #include "confdefs.h"
10787 #include <math.h>
10788 int main() {
10789  _asinf(0);
10790 ; return 0; }
10791 EOF
10792 if { (eval echo configure:10793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10793   rm -rf conftest*
10794   use__asinf=yes
10795 else
10796   echo "configure: failed program was:" >&5
10797   cat conftest.$ac_ext >&5
10798   rm -rf conftest*
10799   use__asinf=no
10800 fi
10801 rm -f conftest*
10802   echo "$ac_t""$use__asinf" 1>&6
10803   ac_ext=c
10804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10805 ac_cpp='$CPP $CPPFLAGS'
10806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10808 cross_compiling=$ac_cv_prog_cc_cross
10809
10810   if test x$use__asinf = x"yes"; then
10811     for ac_func in _asinf
10812 do
10813 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10814 echo "configure:10815: checking for $ac_func" >&5
10815 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10816   echo $ac_n "(cached) $ac_c" 1>&6
10817 else
10818   cat > conftest.$ac_ext <<EOF
10819 #line 10820 "configure"
10820 #include "confdefs.h"
10821 /* System header to define __stub macros and hopefully few prototypes,
10822     which can conflict with char $ac_func(); below.  */
10823 #include <assert.h>
10824 /* Override any gcc2 internal prototype to avoid an error.  */
10825 /* We use char because int might match the return type of a gcc2
10826     builtin and then its argument prototype would still apply.  */
10827 char $ac_func();
10828
10829 int main() {
10830
10831 /* The GNU C library defines this for functions which it implements
10832     to always fail with ENOSYS.  Some functions are actually named
10833     something starting with __ and the normal name is an alias.  */
10834 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10835 choke me
10836 #else
10837 $ac_func();
10838 #endif
10839
10840 ; return 0; }
10841 EOF
10842 if { (eval echo configure:10843: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10843   rm -rf conftest*
10844   eval "ac_cv_func_$ac_func=yes"
10845 else
10846   echo "configure: failed program was:" >&5
10847   cat conftest.$ac_ext >&5
10848   rm -rf conftest*
10849   eval "ac_cv_func_$ac_func=no"
10850 fi
10851 rm -f conftest*
10852 fi
10853
10854 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10855   echo "$ac_t""yes" 1>&6
10856     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10857   cat >> confdefs.h <<EOF
10858 #define $ac_tr_func 1
10859 EOF
10860
10861 else
10862   echo "$ac_t""no" 1>&6
10863 fi
10864 done
10865
10866   fi
10867
10868
10869
10870   ac_ext=C
10871 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10872 ac_cpp='$CXXCPP $CPPFLAGS'
10873 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10874 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10875 cross_compiling=$ac_cv_prog_cxx_cross
10876
10877   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
10878 echo "configure:10879: checking for _atanf declaration" >&5
10879   cat > conftest.$ac_ext <<EOF
10880 #line 10881 "configure"
10881 #include "confdefs.h"
10882 #include <math.h>
10883 int main() {
10884  _atanf(0);
10885 ; return 0; }
10886 EOF
10887 if { (eval echo configure:10888: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10888   rm -rf conftest*
10889   use__atanf=yes
10890 else
10891   echo "configure: failed program was:" >&5
10892   cat conftest.$ac_ext >&5
10893   rm -rf conftest*
10894   use__atanf=no
10895 fi
10896 rm -f conftest*
10897   echo "$ac_t""$use__atanf" 1>&6
10898   ac_ext=c
10899 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10900 ac_cpp='$CPP $CPPFLAGS'
10901 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10902 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10903 cross_compiling=$ac_cv_prog_cc_cross
10904
10905   if test x$use__atanf = x"yes"; then
10906     for ac_func in _atanf
10907 do
10908 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10909 echo "configure:10910: checking for $ac_func" >&5
10910 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10911   echo $ac_n "(cached) $ac_c" 1>&6
10912 else
10913   cat > conftest.$ac_ext <<EOF
10914 #line 10915 "configure"
10915 #include "confdefs.h"
10916 /* System header to define __stub macros and hopefully few prototypes,
10917     which can conflict with char $ac_func(); below.  */
10918 #include <assert.h>
10919 /* Override any gcc2 internal prototype to avoid an error.  */
10920 /* We use char because int might match the return type of a gcc2
10921     builtin and then its argument prototype would still apply.  */
10922 char $ac_func();
10923
10924 int main() {
10925
10926 /* The GNU C library defines this for functions which it implements
10927     to always fail with ENOSYS.  Some functions are actually named
10928     something starting with __ and the normal name is an alias.  */
10929 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10930 choke me
10931 #else
10932 $ac_func();
10933 #endif
10934
10935 ; return 0; }
10936 EOF
10937 if { (eval echo configure:10938: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10938   rm -rf conftest*
10939   eval "ac_cv_func_$ac_func=yes"
10940 else
10941   echo "configure: failed program was:" >&5
10942   cat conftest.$ac_ext >&5
10943   rm -rf conftest*
10944   eval "ac_cv_func_$ac_func=no"
10945 fi
10946 rm -f conftest*
10947 fi
10948
10949 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10950   echo "$ac_t""yes" 1>&6
10951     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10952   cat >> confdefs.h <<EOF
10953 #define $ac_tr_func 1
10954 EOF
10955
10956 else
10957   echo "$ac_t""no" 1>&6
10958 fi
10959 done
10960
10961   fi
10962
10963
10964
10965   ac_ext=C
10966 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10967 ac_cpp='$CXXCPP $CPPFLAGS'
10968 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10969 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10970 cross_compiling=$ac_cv_prog_cxx_cross
10971
10972   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
10973 echo "configure:10974: checking for _atan2f declaration" >&5
10974   cat > conftest.$ac_ext <<EOF
10975 #line 10976 "configure"
10976 #include "confdefs.h"
10977 #include <math.h>
10978 int main() {
10979  _atan2f(0, 0);
10980 ; return 0; }
10981 EOF
10982 if { (eval echo configure:10983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10983   rm -rf conftest*
10984   use__atan2f=yes
10985 else
10986   echo "configure: failed program was:" >&5
10987   cat conftest.$ac_ext >&5
10988   rm -rf conftest*
10989   use__atan2f=no
10990 fi
10991 rm -f conftest*
10992   echo "$ac_t""$use__atan2f" 1>&6
10993   ac_ext=c
10994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10995 ac_cpp='$CPP $CPPFLAGS'
10996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10998 cross_compiling=$ac_cv_prog_cc_cross
10999
11000   if test x$use__atan2f = x"yes"; then
11001     for ac_func in _atan2f
11002 do
11003 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11004 echo "configure:11005: checking for $ac_func" >&5
11005 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11006   echo $ac_n "(cached) $ac_c" 1>&6
11007 else
11008   cat > conftest.$ac_ext <<EOF
11009 #line 11010 "configure"
11010 #include "confdefs.h"
11011 /* System header to define __stub macros and hopefully few prototypes,
11012     which can conflict with char $ac_func(); below.  */
11013 #include <assert.h>
11014 /* Override any gcc2 internal prototype to avoid an error.  */
11015 /* We use char because int might match the return type of a gcc2
11016     builtin and then its argument prototype would still apply.  */
11017 char $ac_func();
11018
11019 int main() {
11020
11021 /* The GNU C library defines this for functions which it implements
11022     to always fail with ENOSYS.  Some functions are actually named
11023     something starting with __ and the normal name is an alias.  */
11024 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11025 choke me
11026 #else
11027 $ac_func();
11028 #endif
11029
11030 ; return 0; }
11031 EOF
11032 if { (eval echo configure:11033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11033   rm -rf conftest*
11034   eval "ac_cv_func_$ac_func=yes"
11035 else
11036   echo "configure: failed program was:" >&5
11037   cat conftest.$ac_ext >&5
11038   rm -rf conftest*
11039   eval "ac_cv_func_$ac_func=no"
11040 fi
11041 rm -f conftest*
11042 fi
11043
11044 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11045   echo "$ac_t""yes" 1>&6
11046     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11047   cat >> confdefs.h <<EOF
11048 #define $ac_tr_func 1
11049 EOF
11050
11051 else
11052   echo "$ac_t""no" 1>&6
11053 fi
11054 done
11055
11056   fi
11057
11058
11059
11060   ac_ext=C
11061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11062 ac_cpp='$CXXCPP $CPPFLAGS'
11063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11065 cross_compiling=$ac_cv_prog_cxx_cross
11066
11067   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
11068 echo "configure:11069: checking for _ceilf declaration" >&5
11069   cat > conftest.$ac_ext <<EOF
11070 #line 11071 "configure"
11071 #include "confdefs.h"
11072 #include <math.h>
11073 int main() {
11074  _ceilf(0);
11075 ; return 0; }
11076 EOF
11077 if { (eval echo configure:11078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11078   rm -rf conftest*
11079   use__ceilf=yes
11080 else
11081   echo "configure: failed program was:" >&5
11082   cat conftest.$ac_ext >&5
11083   rm -rf conftest*
11084   use__ceilf=no
11085 fi
11086 rm -f conftest*
11087   echo "$ac_t""$use__ceilf" 1>&6
11088   ac_ext=c
11089 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11090 ac_cpp='$CPP $CPPFLAGS'
11091 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11092 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11093 cross_compiling=$ac_cv_prog_cc_cross
11094
11095   if test x$use__ceilf = x"yes"; then
11096     for ac_func in _ceilf
11097 do
11098 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11099 echo "configure:11100: checking for $ac_func" >&5
11100 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11101   echo $ac_n "(cached) $ac_c" 1>&6
11102 else
11103   cat > conftest.$ac_ext <<EOF
11104 #line 11105 "configure"
11105 #include "confdefs.h"
11106 /* System header to define __stub macros and hopefully few prototypes,
11107     which can conflict with char $ac_func(); below.  */
11108 #include <assert.h>
11109 /* Override any gcc2 internal prototype to avoid an error.  */
11110 /* We use char because int might match the return type of a gcc2
11111     builtin and then its argument prototype would still apply.  */
11112 char $ac_func();
11113
11114 int main() {
11115
11116 /* The GNU C library defines this for functions which it implements
11117     to always fail with ENOSYS.  Some functions are actually named
11118     something starting with __ and the normal name is an alias.  */
11119 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11120 choke me
11121 #else
11122 $ac_func();
11123 #endif
11124
11125 ; return 0; }
11126 EOF
11127 if { (eval echo configure:11128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11128   rm -rf conftest*
11129   eval "ac_cv_func_$ac_func=yes"
11130 else
11131   echo "configure: failed program was:" >&5
11132   cat conftest.$ac_ext >&5
11133   rm -rf conftest*
11134   eval "ac_cv_func_$ac_func=no"
11135 fi
11136 rm -f conftest*
11137 fi
11138
11139 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11140   echo "$ac_t""yes" 1>&6
11141     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11142   cat >> confdefs.h <<EOF
11143 #define $ac_tr_func 1
11144 EOF
11145
11146 else
11147   echo "$ac_t""no" 1>&6
11148 fi
11149 done
11150
11151   fi
11152
11153
11154
11155   ac_ext=C
11156 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11157 ac_cpp='$CXXCPP $CPPFLAGS'
11158 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11159 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11160 cross_compiling=$ac_cv_prog_cxx_cross
11161
11162   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
11163 echo "configure:11164: checking for _cosf declaration" >&5
11164   cat > conftest.$ac_ext <<EOF
11165 #line 11166 "configure"
11166 #include "confdefs.h"
11167 #include <math.h>
11168 int main() {
11169  _cosf(0);
11170 ; return 0; }
11171 EOF
11172 if { (eval echo configure:11173: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11173   rm -rf conftest*
11174   use__cosf=yes
11175 else
11176   echo "configure: failed program was:" >&5
11177   cat conftest.$ac_ext >&5
11178   rm -rf conftest*
11179   use__cosf=no
11180 fi
11181 rm -f conftest*
11182   echo "$ac_t""$use__cosf" 1>&6
11183   ac_ext=c
11184 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11185 ac_cpp='$CPP $CPPFLAGS'
11186 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11187 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11188 cross_compiling=$ac_cv_prog_cc_cross
11189
11190   if test x$use__cosf = x"yes"; then
11191     for ac_func in _cosf
11192 do
11193 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11194 echo "configure:11195: checking for $ac_func" >&5
11195 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11196   echo $ac_n "(cached) $ac_c" 1>&6
11197 else
11198   cat > conftest.$ac_ext <<EOF
11199 #line 11200 "configure"
11200 #include "confdefs.h"
11201 /* System header to define __stub macros and hopefully few prototypes,
11202     which can conflict with char $ac_func(); below.  */
11203 #include <assert.h>
11204 /* Override any gcc2 internal prototype to avoid an error.  */
11205 /* We use char because int might match the return type of a gcc2
11206     builtin and then its argument prototype would still apply.  */
11207 char $ac_func();
11208
11209 int main() {
11210
11211 /* The GNU C library defines this for functions which it implements
11212     to always fail with ENOSYS.  Some functions are actually named
11213     something starting with __ and the normal name is an alias.  */
11214 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11215 choke me
11216 #else
11217 $ac_func();
11218 #endif
11219
11220 ; return 0; }
11221 EOF
11222 if { (eval echo configure:11223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11223   rm -rf conftest*
11224   eval "ac_cv_func_$ac_func=yes"
11225 else
11226   echo "configure: failed program was:" >&5
11227   cat conftest.$ac_ext >&5
11228   rm -rf conftest*
11229   eval "ac_cv_func_$ac_func=no"
11230 fi
11231 rm -f conftest*
11232 fi
11233
11234 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11235   echo "$ac_t""yes" 1>&6
11236     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11237   cat >> confdefs.h <<EOF
11238 #define $ac_tr_func 1
11239 EOF
11240
11241 else
11242   echo "$ac_t""no" 1>&6
11243 fi
11244 done
11245
11246   fi
11247
11248
11249
11250   ac_ext=C
11251 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11252 ac_cpp='$CXXCPP $CPPFLAGS'
11253 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11254 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11255 cross_compiling=$ac_cv_prog_cxx_cross
11256
11257   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
11258 echo "configure:11259: checking for _coshf declaration" >&5
11259   cat > conftest.$ac_ext <<EOF
11260 #line 11261 "configure"
11261 #include "confdefs.h"
11262 #include <math.h>
11263 int main() {
11264  _coshf(0);
11265 ; return 0; }
11266 EOF
11267 if { (eval echo configure:11268: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11268   rm -rf conftest*
11269   use__coshf=yes
11270 else
11271   echo "configure: failed program was:" >&5
11272   cat conftest.$ac_ext >&5
11273   rm -rf conftest*
11274   use__coshf=no
11275 fi
11276 rm -f conftest*
11277   echo "$ac_t""$use__coshf" 1>&6
11278   ac_ext=c
11279 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11280 ac_cpp='$CPP $CPPFLAGS'
11281 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11282 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11283 cross_compiling=$ac_cv_prog_cc_cross
11284
11285   if test x$use__coshf = x"yes"; then
11286     for ac_func in _coshf
11287 do
11288 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11289 echo "configure:11290: checking for $ac_func" >&5
11290 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11291   echo $ac_n "(cached) $ac_c" 1>&6
11292 else
11293   cat > conftest.$ac_ext <<EOF
11294 #line 11295 "configure"
11295 #include "confdefs.h"
11296 /* System header to define __stub macros and hopefully few prototypes,
11297     which can conflict with char $ac_func(); below.  */
11298 #include <assert.h>
11299 /* Override any gcc2 internal prototype to avoid an error.  */
11300 /* We use char because int might match the return type of a gcc2
11301     builtin and then its argument prototype would still apply.  */
11302 char $ac_func();
11303
11304 int main() {
11305
11306 /* The GNU C library defines this for functions which it implements
11307     to always fail with ENOSYS.  Some functions are actually named
11308     something starting with __ and the normal name is an alias.  */
11309 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11310 choke me
11311 #else
11312 $ac_func();
11313 #endif
11314
11315 ; return 0; }
11316 EOF
11317 if { (eval echo configure:11318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11318   rm -rf conftest*
11319   eval "ac_cv_func_$ac_func=yes"
11320 else
11321   echo "configure: failed program was:" >&5
11322   cat conftest.$ac_ext >&5
11323   rm -rf conftest*
11324   eval "ac_cv_func_$ac_func=no"
11325 fi
11326 rm -f conftest*
11327 fi
11328
11329 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11330   echo "$ac_t""yes" 1>&6
11331     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11332   cat >> confdefs.h <<EOF
11333 #define $ac_tr_func 1
11334 EOF
11335
11336 else
11337   echo "$ac_t""no" 1>&6
11338 fi
11339 done
11340
11341   fi
11342
11343
11344
11345   ac_ext=C
11346 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11347 ac_cpp='$CXXCPP $CPPFLAGS'
11348 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11349 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11350 cross_compiling=$ac_cv_prog_cxx_cross
11351
11352   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
11353 echo "configure:11354: checking for _expf declaration" >&5
11354   cat > conftest.$ac_ext <<EOF
11355 #line 11356 "configure"
11356 #include "confdefs.h"
11357 #include <math.h>
11358 int main() {
11359  _expf(0);
11360 ; return 0; }
11361 EOF
11362 if { (eval echo configure:11363: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11363   rm -rf conftest*
11364   use__expf=yes
11365 else
11366   echo "configure: failed program was:" >&5
11367   cat conftest.$ac_ext >&5
11368   rm -rf conftest*
11369   use__expf=no
11370 fi
11371 rm -f conftest*
11372   echo "$ac_t""$use__expf" 1>&6
11373   ac_ext=c
11374 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11375 ac_cpp='$CPP $CPPFLAGS'
11376 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11377 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11378 cross_compiling=$ac_cv_prog_cc_cross
11379
11380   if test x$use__expf = x"yes"; then
11381     for ac_func in _expf
11382 do
11383 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11384 echo "configure:11385: checking for $ac_func" >&5
11385 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11386   echo $ac_n "(cached) $ac_c" 1>&6
11387 else
11388   cat > conftest.$ac_ext <<EOF
11389 #line 11390 "configure"
11390 #include "confdefs.h"
11391 /* System header to define __stub macros and hopefully few prototypes,
11392     which can conflict with char $ac_func(); below.  */
11393 #include <assert.h>
11394 /* Override any gcc2 internal prototype to avoid an error.  */
11395 /* We use char because int might match the return type of a gcc2
11396     builtin and then its argument prototype would still apply.  */
11397 char $ac_func();
11398
11399 int main() {
11400
11401 /* The GNU C library defines this for functions which it implements
11402     to always fail with ENOSYS.  Some functions are actually named
11403     something starting with __ and the normal name is an alias.  */
11404 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11405 choke me
11406 #else
11407 $ac_func();
11408 #endif
11409
11410 ; return 0; }
11411 EOF
11412 if { (eval echo configure:11413: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11413   rm -rf conftest*
11414   eval "ac_cv_func_$ac_func=yes"
11415 else
11416   echo "configure: failed program was:" >&5
11417   cat conftest.$ac_ext >&5
11418   rm -rf conftest*
11419   eval "ac_cv_func_$ac_func=no"
11420 fi
11421 rm -f conftest*
11422 fi
11423
11424 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11425   echo "$ac_t""yes" 1>&6
11426     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11427   cat >> confdefs.h <<EOF
11428 #define $ac_tr_func 1
11429 EOF
11430
11431 else
11432   echo "$ac_t""no" 1>&6
11433 fi
11434 done
11435
11436   fi
11437
11438
11439
11440   ac_ext=C
11441 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11442 ac_cpp='$CXXCPP $CPPFLAGS'
11443 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11444 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11445 cross_compiling=$ac_cv_prog_cxx_cross
11446
11447   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
11448 echo "configure:11449: checking for _fabsf declaration" >&5
11449   cat > conftest.$ac_ext <<EOF
11450 #line 11451 "configure"
11451 #include "confdefs.h"
11452 #include <math.h>
11453 int main() {
11454  _fabsf(0);
11455 ; return 0; }
11456 EOF
11457 if { (eval echo configure:11458: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11458   rm -rf conftest*
11459   use__fabsf=yes
11460 else
11461   echo "configure: failed program was:" >&5
11462   cat conftest.$ac_ext >&5
11463   rm -rf conftest*
11464   use__fabsf=no
11465 fi
11466 rm -f conftest*
11467   echo "$ac_t""$use__fabsf" 1>&6
11468   ac_ext=c
11469 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11470 ac_cpp='$CPP $CPPFLAGS'
11471 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11472 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11473 cross_compiling=$ac_cv_prog_cc_cross
11474
11475   if test x$use__fabsf = x"yes"; then
11476     for ac_func in _fabsf
11477 do
11478 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11479 echo "configure:11480: checking for $ac_func" >&5
11480 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11481   echo $ac_n "(cached) $ac_c" 1>&6
11482 else
11483   cat > conftest.$ac_ext <<EOF
11484 #line 11485 "configure"
11485 #include "confdefs.h"
11486 /* System header to define __stub macros and hopefully few prototypes,
11487     which can conflict with char $ac_func(); below.  */
11488 #include <assert.h>
11489 /* Override any gcc2 internal prototype to avoid an error.  */
11490 /* We use char because int might match the return type of a gcc2
11491     builtin and then its argument prototype would still apply.  */
11492 char $ac_func();
11493
11494 int main() {
11495
11496 /* The GNU C library defines this for functions which it implements
11497     to always fail with ENOSYS.  Some functions are actually named
11498     something starting with __ and the normal name is an alias.  */
11499 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11500 choke me
11501 #else
11502 $ac_func();
11503 #endif
11504
11505 ; return 0; }
11506 EOF
11507 if { (eval echo configure:11508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11508   rm -rf conftest*
11509   eval "ac_cv_func_$ac_func=yes"
11510 else
11511   echo "configure: failed program was:" >&5
11512   cat conftest.$ac_ext >&5
11513   rm -rf conftest*
11514   eval "ac_cv_func_$ac_func=no"
11515 fi
11516 rm -f conftest*
11517 fi
11518
11519 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11520   echo "$ac_t""yes" 1>&6
11521     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11522   cat >> confdefs.h <<EOF
11523 #define $ac_tr_func 1
11524 EOF
11525
11526 else
11527   echo "$ac_t""no" 1>&6
11528 fi
11529 done
11530
11531   fi
11532
11533
11534
11535   ac_ext=C
11536 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11537 ac_cpp='$CXXCPP $CPPFLAGS'
11538 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11539 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11540 cross_compiling=$ac_cv_prog_cxx_cross
11541
11542   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
11543 echo "configure:11544: checking for _floorf declaration" >&5
11544   cat > conftest.$ac_ext <<EOF
11545 #line 11546 "configure"
11546 #include "confdefs.h"
11547 #include <math.h>
11548 int main() {
11549  _floorf(0);
11550 ; return 0; }
11551 EOF
11552 if { (eval echo configure:11553: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11553   rm -rf conftest*
11554   use__floorf=yes
11555 else
11556   echo "configure: failed program was:" >&5
11557   cat conftest.$ac_ext >&5
11558   rm -rf conftest*
11559   use__floorf=no
11560 fi
11561 rm -f conftest*
11562   echo "$ac_t""$use__floorf" 1>&6
11563   ac_ext=c
11564 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11565 ac_cpp='$CPP $CPPFLAGS'
11566 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11567 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11568 cross_compiling=$ac_cv_prog_cc_cross
11569
11570   if test x$use__floorf = x"yes"; then
11571     for ac_func in _floorf
11572 do
11573 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11574 echo "configure:11575: checking for $ac_func" >&5
11575 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11576   echo $ac_n "(cached) $ac_c" 1>&6
11577 else
11578   cat > conftest.$ac_ext <<EOF
11579 #line 11580 "configure"
11580 #include "confdefs.h"
11581 /* System header to define __stub macros and hopefully few prototypes,
11582     which can conflict with char $ac_func(); below.  */
11583 #include <assert.h>
11584 /* Override any gcc2 internal prototype to avoid an error.  */
11585 /* We use char because int might match the return type of a gcc2
11586     builtin and then its argument prototype would still apply.  */
11587 char $ac_func();
11588
11589 int main() {
11590
11591 /* The GNU C library defines this for functions which it implements
11592     to always fail with ENOSYS.  Some functions are actually named
11593     something starting with __ and the normal name is an alias.  */
11594 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11595 choke me
11596 #else
11597 $ac_func();
11598 #endif
11599
11600 ; return 0; }
11601 EOF
11602 if { (eval echo configure:11603: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11603   rm -rf conftest*
11604   eval "ac_cv_func_$ac_func=yes"
11605 else
11606   echo "configure: failed program was:" >&5
11607   cat conftest.$ac_ext >&5
11608   rm -rf conftest*
11609   eval "ac_cv_func_$ac_func=no"
11610 fi
11611 rm -f conftest*
11612 fi
11613
11614 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11615   echo "$ac_t""yes" 1>&6
11616     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11617   cat >> confdefs.h <<EOF
11618 #define $ac_tr_func 1
11619 EOF
11620
11621 else
11622   echo "$ac_t""no" 1>&6
11623 fi
11624 done
11625
11626   fi
11627
11628
11629
11630   ac_ext=C
11631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11632 ac_cpp='$CXXCPP $CPPFLAGS'
11633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11635 cross_compiling=$ac_cv_prog_cxx_cross
11636
11637   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
11638 echo "configure:11639: checking for _fmodf declaration" >&5
11639   cat > conftest.$ac_ext <<EOF
11640 #line 11641 "configure"
11641 #include "confdefs.h"
11642 #include <math.h>
11643 int main() {
11644  _fmodf(0, 0);
11645 ; return 0; }
11646 EOF
11647 if { (eval echo configure:11648: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11648   rm -rf conftest*
11649   use__fmodf=yes
11650 else
11651   echo "configure: failed program was:" >&5
11652   cat conftest.$ac_ext >&5
11653   rm -rf conftest*
11654   use__fmodf=no
11655 fi
11656 rm -f conftest*
11657   echo "$ac_t""$use__fmodf" 1>&6
11658   ac_ext=c
11659 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11660 ac_cpp='$CPP $CPPFLAGS'
11661 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11662 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11663 cross_compiling=$ac_cv_prog_cc_cross
11664
11665   if test x$use__fmodf = x"yes"; then
11666     for ac_func in _fmodf
11667 do
11668 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11669 echo "configure:11670: checking for $ac_func" >&5
11670 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11671   echo $ac_n "(cached) $ac_c" 1>&6
11672 else
11673   cat > conftest.$ac_ext <<EOF
11674 #line 11675 "configure"
11675 #include "confdefs.h"
11676 /* System header to define __stub macros and hopefully few prototypes,
11677     which can conflict with char $ac_func(); below.  */
11678 #include <assert.h>
11679 /* Override any gcc2 internal prototype to avoid an error.  */
11680 /* We use char because int might match the return type of a gcc2
11681     builtin and then its argument prototype would still apply.  */
11682 char $ac_func();
11683
11684 int main() {
11685
11686 /* The GNU C library defines this for functions which it implements
11687     to always fail with ENOSYS.  Some functions are actually named
11688     something starting with __ and the normal name is an alias.  */
11689 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11690 choke me
11691 #else
11692 $ac_func();
11693 #endif
11694
11695 ; return 0; }
11696 EOF
11697 if { (eval echo configure:11698: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11698   rm -rf conftest*
11699   eval "ac_cv_func_$ac_func=yes"
11700 else
11701   echo "configure: failed program was:" >&5
11702   cat conftest.$ac_ext >&5
11703   rm -rf conftest*
11704   eval "ac_cv_func_$ac_func=no"
11705 fi
11706 rm -f conftest*
11707 fi
11708
11709 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11710   echo "$ac_t""yes" 1>&6
11711     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11712   cat >> confdefs.h <<EOF
11713 #define $ac_tr_func 1
11714 EOF
11715
11716 else
11717   echo "$ac_t""no" 1>&6
11718 fi
11719 done
11720
11721   fi
11722
11723
11724
11725   ac_ext=C
11726 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11727 ac_cpp='$CXXCPP $CPPFLAGS'
11728 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11729 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11730 cross_compiling=$ac_cv_prog_cxx_cross
11731
11732   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
11733 echo "configure:11734: checking for _frexpf declaration" >&5
11734   cat > conftest.$ac_ext <<EOF
11735 #line 11736 "configure"
11736 #include "confdefs.h"
11737 #include <math.h>
11738 int main() {
11739  _frexpf(0, 0);
11740 ; return 0; }
11741 EOF
11742 if { (eval echo configure:11743: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11743   rm -rf conftest*
11744   use__frexpf=yes
11745 else
11746   echo "configure: failed program was:" >&5
11747   cat conftest.$ac_ext >&5
11748   rm -rf conftest*
11749   use__frexpf=no
11750 fi
11751 rm -f conftest*
11752   echo "$ac_t""$use__frexpf" 1>&6
11753   ac_ext=c
11754 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11755 ac_cpp='$CPP $CPPFLAGS'
11756 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11757 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11758 cross_compiling=$ac_cv_prog_cc_cross
11759
11760   if test x$use__frexpf = x"yes"; then
11761     for ac_func in _frexpf
11762 do
11763 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11764 echo "configure:11765: checking for $ac_func" >&5
11765 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11766   echo $ac_n "(cached) $ac_c" 1>&6
11767 else
11768   cat > conftest.$ac_ext <<EOF
11769 #line 11770 "configure"
11770 #include "confdefs.h"
11771 /* System header to define __stub macros and hopefully few prototypes,
11772     which can conflict with char $ac_func(); below.  */
11773 #include <assert.h>
11774 /* Override any gcc2 internal prototype to avoid an error.  */
11775 /* We use char because int might match the return type of a gcc2
11776     builtin and then its argument prototype would still apply.  */
11777 char $ac_func();
11778
11779 int main() {
11780
11781 /* The GNU C library defines this for functions which it implements
11782     to always fail with ENOSYS.  Some functions are actually named
11783     something starting with __ and the normal name is an alias.  */
11784 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11785 choke me
11786 #else
11787 $ac_func();
11788 #endif
11789
11790 ; return 0; }
11791 EOF
11792 if { (eval echo configure:11793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11793   rm -rf conftest*
11794   eval "ac_cv_func_$ac_func=yes"
11795 else
11796   echo "configure: failed program was:" >&5
11797   cat conftest.$ac_ext >&5
11798   rm -rf conftest*
11799   eval "ac_cv_func_$ac_func=no"
11800 fi
11801 rm -f conftest*
11802 fi
11803
11804 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11805   echo "$ac_t""yes" 1>&6
11806     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11807   cat >> confdefs.h <<EOF
11808 #define $ac_tr_func 1
11809 EOF
11810
11811 else
11812   echo "$ac_t""no" 1>&6
11813 fi
11814 done
11815
11816   fi
11817
11818
11819
11820   ac_ext=C
11821 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11822 ac_cpp='$CXXCPP $CPPFLAGS'
11823 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11824 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11825 cross_compiling=$ac_cv_prog_cxx_cross
11826
11827   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
11828 echo "configure:11829: checking for _ldexpf declaration" >&5
11829   cat > conftest.$ac_ext <<EOF
11830 #line 11831 "configure"
11831 #include "confdefs.h"
11832 #include <math.h>
11833 int main() {
11834  _ldexpf(0, 0);
11835 ; return 0; }
11836 EOF
11837 if { (eval echo configure:11838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11838   rm -rf conftest*
11839   use__ldexpf=yes
11840 else
11841   echo "configure: failed program was:" >&5
11842   cat conftest.$ac_ext >&5
11843   rm -rf conftest*
11844   use__ldexpf=no
11845 fi
11846 rm -f conftest*
11847   echo "$ac_t""$use__ldexpf" 1>&6
11848   ac_ext=c
11849 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11850 ac_cpp='$CPP $CPPFLAGS'
11851 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11852 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11853 cross_compiling=$ac_cv_prog_cc_cross
11854
11855   if test x$use__ldexpf = x"yes"; then
11856     for ac_func in _ldexpf
11857 do
11858 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11859 echo "configure:11860: checking for $ac_func" >&5
11860 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11861   echo $ac_n "(cached) $ac_c" 1>&6
11862 else
11863   cat > conftest.$ac_ext <<EOF
11864 #line 11865 "configure"
11865 #include "confdefs.h"
11866 /* System header to define __stub macros and hopefully few prototypes,
11867     which can conflict with char $ac_func(); below.  */
11868 #include <assert.h>
11869 /* Override any gcc2 internal prototype to avoid an error.  */
11870 /* We use char because int might match the return type of a gcc2
11871     builtin and then its argument prototype would still apply.  */
11872 char $ac_func();
11873
11874 int main() {
11875
11876 /* The GNU C library defines this for functions which it implements
11877     to always fail with ENOSYS.  Some functions are actually named
11878     something starting with __ and the normal name is an alias.  */
11879 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11880 choke me
11881 #else
11882 $ac_func();
11883 #endif
11884
11885 ; return 0; }
11886 EOF
11887 if { (eval echo configure:11888: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11888   rm -rf conftest*
11889   eval "ac_cv_func_$ac_func=yes"
11890 else
11891   echo "configure: failed program was:" >&5
11892   cat conftest.$ac_ext >&5
11893   rm -rf conftest*
11894   eval "ac_cv_func_$ac_func=no"
11895 fi
11896 rm -f conftest*
11897 fi
11898
11899 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11900   echo "$ac_t""yes" 1>&6
11901     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11902   cat >> confdefs.h <<EOF
11903 #define $ac_tr_func 1
11904 EOF
11905
11906 else
11907   echo "$ac_t""no" 1>&6
11908 fi
11909 done
11910
11911   fi
11912
11913
11914
11915   ac_ext=C
11916 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11917 ac_cpp='$CXXCPP $CPPFLAGS'
11918 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11919 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11920 cross_compiling=$ac_cv_prog_cxx_cross
11921
11922   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
11923 echo "configure:11924: checking for _logf declaration" >&5
11924   cat > conftest.$ac_ext <<EOF
11925 #line 11926 "configure"
11926 #include "confdefs.h"
11927 #include <math.h>
11928 int main() {
11929  _logf(0);
11930 ; return 0; }
11931 EOF
11932 if { (eval echo configure:11933: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11933   rm -rf conftest*
11934   use__logf=yes
11935 else
11936   echo "configure: failed program was:" >&5
11937   cat conftest.$ac_ext >&5
11938   rm -rf conftest*
11939   use__logf=no
11940 fi
11941 rm -f conftest*
11942   echo "$ac_t""$use__logf" 1>&6
11943   ac_ext=c
11944 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11945 ac_cpp='$CPP $CPPFLAGS'
11946 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11947 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11948 cross_compiling=$ac_cv_prog_cc_cross
11949
11950   if test x$use__logf = x"yes"; then
11951     for ac_func in _logf
11952 do
11953 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11954 echo "configure:11955: checking for $ac_func" >&5
11955 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11956   echo $ac_n "(cached) $ac_c" 1>&6
11957 else
11958   cat > conftest.$ac_ext <<EOF
11959 #line 11960 "configure"
11960 #include "confdefs.h"
11961 /* System header to define __stub macros and hopefully few prototypes,
11962     which can conflict with char $ac_func(); below.  */
11963 #include <assert.h>
11964 /* Override any gcc2 internal prototype to avoid an error.  */
11965 /* We use char because int might match the return type of a gcc2
11966     builtin and then its argument prototype would still apply.  */
11967 char $ac_func();
11968
11969 int main() {
11970
11971 /* The GNU C library defines this for functions which it implements
11972     to always fail with ENOSYS.  Some functions are actually named
11973     something starting with __ and the normal name is an alias.  */
11974 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11975 choke me
11976 #else
11977 $ac_func();
11978 #endif
11979
11980 ; return 0; }
11981 EOF
11982 if { (eval echo configure:11983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11983   rm -rf conftest*
11984   eval "ac_cv_func_$ac_func=yes"
11985 else
11986   echo "configure: failed program was:" >&5
11987   cat conftest.$ac_ext >&5
11988   rm -rf conftest*
11989   eval "ac_cv_func_$ac_func=no"
11990 fi
11991 rm -f conftest*
11992 fi
11993
11994 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11995   echo "$ac_t""yes" 1>&6
11996     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11997   cat >> confdefs.h <<EOF
11998 #define $ac_tr_func 1
11999 EOF
12000
12001 else
12002   echo "$ac_t""no" 1>&6
12003 fi
12004 done
12005
12006   fi
12007
12008
12009
12010   ac_ext=C
12011 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12012 ac_cpp='$CXXCPP $CPPFLAGS'
12013 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12014 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12015 cross_compiling=$ac_cv_prog_cxx_cross
12016
12017   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
12018 echo "configure:12019: checking for _log10f declaration" >&5
12019   cat > conftest.$ac_ext <<EOF
12020 #line 12021 "configure"
12021 #include "confdefs.h"
12022 #include <math.h>
12023 int main() {
12024  _log10f(0);
12025 ; return 0; }
12026 EOF
12027 if { (eval echo configure:12028: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12028   rm -rf conftest*
12029   use__log10f=yes
12030 else
12031   echo "configure: failed program was:" >&5
12032   cat conftest.$ac_ext >&5
12033   rm -rf conftest*
12034   use__log10f=no
12035 fi
12036 rm -f conftest*
12037   echo "$ac_t""$use__log10f" 1>&6
12038   ac_ext=c
12039 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12040 ac_cpp='$CPP $CPPFLAGS'
12041 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12042 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12043 cross_compiling=$ac_cv_prog_cc_cross
12044
12045   if test x$use__log10f = x"yes"; then
12046     for ac_func in _log10f
12047 do
12048 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12049 echo "configure:12050: checking for $ac_func" >&5
12050 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12051   echo $ac_n "(cached) $ac_c" 1>&6
12052 else
12053   cat > conftest.$ac_ext <<EOF
12054 #line 12055 "configure"
12055 #include "confdefs.h"
12056 /* System header to define __stub macros and hopefully few prototypes,
12057     which can conflict with char $ac_func(); below.  */
12058 #include <assert.h>
12059 /* Override any gcc2 internal prototype to avoid an error.  */
12060 /* We use char because int might match the return type of a gcc2
12061     builtin and then its argument prototype would still apply.  */
12062 char $ac_func();
12063
12064 int main() {
12065
12066 /* The GNU C library defines this for functions which it implements
12067     to always fail with ENOSYS.  Some functions are actually named
12068     something starting with __ and the normal name is an alias.  */
12069 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12070 choke me
12071 #else
12072 $ac_func();
12073 #endif
12074
12075 ; return 0; }
12076 EOF
12077 if { (eval echo configure:12078: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12078   rm -rf conftest*
12079   eval "ac_cv_func_$ac_func=yes"
12080 else
12081   echo "configure: failed program was:" >&5
12082   cat conftest.$ac_ext >&5
12083   rm -rf conftest*
12084   eval "ac_cv_func_$ac_func=no"
12085 fi
12086 rm -f conftest*
12087 fi
12088
12089 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12090   echo "$ac_t""yes" 1>&6
12091     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12092   cat >> confdefs.h <<EOF
12093 #define $ac_tr_func 1
12094 EOF
12095
12096 else
12097   echo "$ac_t""no" 1>&6
12098 fi
12099 done
12100
12101   fi
12102
12103
12104
12105   ac_ext=C
12106 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12107 ac_cpp='$CXXCPP $CPPFLAGS'
12108 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12109 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12110 cross_compiling=$ac_cv_prog_cxx_cross
12111
12112   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
12113 echo "configure:12114: checking for _modff declaration" >&5
12114   cat > conftest.$ac_ext <<EOF
12115 #line 12116 "configure"
12116 #include "confdefs.h"
12117 #include <math.h>
12118 int main() {
12119  _modff(0, 0);
12120 ; return 0; }
12121 EOF
12122 if { (eval echo configure:12123: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12123   rm -rf conftest*
12124   use__modff=yes
12125 else
12126   echo "configure: failed program was:" >&5
12127   cat conftest.$ac_ext >&5
12128   rm -rf conftest*
12129   use__modff=no
12130 fi
12131 rm -f conftest*
12132   echo "$ac_t""$use__modff" 1>&6
12133   ac_ext=c
12134 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12135 ac_cpp='$CPP $CPPFLAGS'
12136 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12137 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12138 cross_compiling=$ac_cv_prog_cc_cross
12139
12140   if test x$use__modff = x"yes"; then
12141     for ac_func in _modff
12142 do
12143 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12144 echo "configure:12145: checking for $ac_func" >&5
12145 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12146   echo $ac_n "(cached) $ac_c" 1>&6
12147 else
12148   cat > conftest.$ac_ext <<EOF
12149 #line 12150 "configure"
12150 #include "confdefs.h"
12151 /* System header to define __stub macros and hopefully few prototypes,
12152     which can conflict with char $ac_func(); below.  */
12153 #include <assert.h>
12154 /* Override any gcc2 internal prototype to avoid an error.  */
12155 /* We use char because int might match the return type of a gcc2
12156     builtin and then its argument prototype would still apply.  */
12157 char $ac_func();
12158
12159 int main() {
12160
12161 /* The GNU C library defines this for functions which it implements
12162     to always fail with ENOSYS.  Some functions are actually named
12163     something starting with __ and the normal name is an alias.  */
12164 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12165 choke me
12166 #else
12167 $ac_func();
12168 #endif
12169
12170 ; return 0; }
12171 EOF
12172 if { (eval echo configure:12173: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12173   rm -rf conftest*
12174   eval "ac_cv_func_$ac_func=yes"
12175 else
12176   echo "configure: failed program was:" >&5
12177   cat conftest.$ac_ext >&5
12178   rm -rf conftest*
12179   eval "ac_cv_func_$ac_func=no"
12180 fi
12181 rm -f conftest*
12182 fi
12183
12184 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12185   echo "$ac_t""yes" 1>&6
12186     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12187   cat >> confdefs.h <<EOF
12188 #define $ac_tr_func 1
12189 EOF
12190
12191 else
12192   echo "$ac_t""no" 1>&6
12193 fi
12194 done
12195
12196   fi
12197
12198
12199
12200   ac_ext=C
12201 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12202 ac_cpp='$CXXCPP $CPPFLAGS'
12203 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12204 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12205 cross_compiling=$ac_cv_prog_cxx_cross
12206
12207   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
12208 echo "configure:12209: checking for _powf declaration" >&5
12209   cat > conftest.$ac_ext <<EOF
12210 #line 12211 "configure"
12211 #include "confdefs.h"
12212 #include <math.h>
12213 int main() {
12214  _powf(0, 0);
12215 ; return 0; }
12216 EOF
12217 if { (eval echo configure:12218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12218   rm -rf conftest*
12219   use__powf=yes
12220 else
12221   echo "configure: failed program was:" >&5
12222   cat conftest.$ac_ext >&5
12223   rm -rf conftest*
12224   use__powf=no
12225 fi
12226 rm -f conftest*
12227   echo "$ac_t""$use__powf" 1>&6
12228   ac_ext=c
12229 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12230 ac_cpp='$CPP $CPPFLAGS'
12231 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12232 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12233 cross_compiling=$ac_cv_prog_cc_cross
12234
12235   if test x$use__powf = x"yes"; then
12236     for ac_func in _powf
12237 do
12238 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12239 echo "configure:12240: checking for $ac_func" >&5
12240 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12241   echo $ac_n "(cached) $ac_c" 1>&6
12242 else
12243   cat > conftest.$ac_ext <<EOF
12244 #line 12245 "configure"
12245 #include "confdefs.h"
12246 /* System header to define __stub macros and hopefully few prototypes,
12247     which can conflict with char $ac_func(); below.  */
12248 #include <assert.h>
12249 /* Override any gcc2 internal prototype to avoid an error.  */
12250 /* We use char because int might match the return type of a gcc2
12251     builtin and then its argument prototype would still apply.  */
12252 char $ac_func();
12253
12254 int main() {
12255
12256 /* The GNU C library defines this for functions which it implements
12257     to always fail with ENOSYS.  Some functions are actually named
12258     something starting with __ and the normal name is an alias.  */
12259 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12260 choke me
12261 #else
12262 $ac_func();
12263 #endif
12264
12265 ; return 0; }
12266 EOF
12267 if { (eval echo configure:12268: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12268   rm -rf conftest*
12269   eval "ac_cv_func_$ac_func=yes"
12270 else
12271   echo "configure: failed program was:" >&5
12272   cat conftest.$ac_ext >&5
12273   rm -rf conftest*
12274   eval "ac_cv_func_$ac_func=no"
12275 fi
12276 rm -f conftest*
12277 fi
12278
12279 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12280   echo "$ac_t""yes" 1>&6
12281     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12282   cat >> confdefs.h <<EOF
12283 #define $ac_tr_func 1
12284 EOF
12285
12286 else
12287   echo "$ac_t""no" 1>&6
12288 fi
12289 done
12290
12291   fi
12292
12293
12294
12295   ac_ext=C
12296 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12297 ac_cpp='$CXXCPP $CPPFLAGS'
12298 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12299 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12300 cross_compiling=$ac_cv_prog_cxx_cross
12301
12302   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
12303 echo "configure:12304: checking for _sinf declaration" >&5
12304   cat > conftest.$ac_ext <<EOF
12305 #line 12306 "configure"
12306 #include "confdefs.h"
12307 #include <math.h>
12308 int main() {
12309  _sinf(0);
12310 ; return 0; }
12311 EOF
12312 if { (eval echo configure:12313: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12313   rm -rf conftest*
12314   use__sinf=yes
12315 else
12316   echo "configure: failed program was:" >&5
12317   cat conftest.$ac_ext >&5
12318   rm -rf conftest*
12319   use__sinf=no
12320 fi
12321 rm -f conftest*
12322   echo "$ac_t""$use__sinf" 1>&6
12323   ac_ext=c
12324 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12325 ac_cpp='$CPP $CPPFLAGS'
12326 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12327 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12328 cross_compiling=$ac_cv_prog_cc_cross
12329
12330   if test x$use__sinf = x"yes"; then
12331     for ac_func in _sinf
12332 do
12333 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12334 echo "configure:12335: checking for $ac_func" >&5
12335 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12336   echo $ac_n "(cached) $ac_c" 1>&6
12337 else
12338   cat > conftest.$ac_ext <<EOF
12339 #line 12340 "configure"
12340 #include "confdefs.h"
12341 /* System header to define __stub macros and hopefully few prototypes,
12342     which can conflict with char $ac_func(); below.  */
12343 #include <assert.h>
12344 /* Override any gcc2 internal prototype to avoid an error.  */
12345 /* We use char because int might match the return type of a gcc2
12346     builtin and then its argument prototype would still apply.  */
12347 char $ac_func();
12348
12349 int main() {
12350
12351 /* The GNU C library defines this for functions which it implements
12352     to always fail with ENOSYS.  Some functions are actually named
12353     something starting with __ and the normal name is an alias.  */
12354 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12355 choke me
12356 #else
12357 $ac_func();
12358 #endif
12359
12360 ; return 0; }
12361 EOF
12362 if { (eval echo configure:12363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12363   rm -rf conftest*
12364   eval "ac_cv_func_$ac_func=yes"
12365 else
12366   echo "configure: failed program was:" >&5
12367   cat conftest.$ac_ext >&5
12368   rm -rf conftest*
12369   eval "ac_cv_func_$ac_func=no"
12370 fi
12371 rm -f conftest*
12372 fi
12373
12374 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12375   echo "$ac_t""yes" 1>&6
12376     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12377   cat >> confdefs.h <<EOF
12378 #define $ac_tr_func 1
12379 EOF
12380
12381 else
12382   echo "$ac_t""no" 1>&6
12383 fi
12384 done
12385
12386   fi
12387
12388
12389
12390   ac_ext=C
12391 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12392 ac_cpp='$CXXCPP $CPPFLAGS'
12393 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12394 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12395 cross_compiling=$ac_cv_prog_cxx_cross
12396
12397   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
12398 echo "configure:12399: checking for _sinhf declaration" >&5
12399   cat > conftest.$ac_ext <<EOF
12400 #line 12401 "configure"
12401 #include "confdefs.h"
12402 #include <math.h>
12403 int main() {
12404  _sinhf(0);
12405 ; return 0; }
12406 EOF
12407 if { (eval echo configure:12408: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12408   rm -rf conftest*
12409   use__sinhf=yes
12410 else
12411   echo "configure: failed program was:" >&5
12412   cat conftest.$ac_ext >&5
12413   rm -rf conftest*
12414   use__sinhf=no
12415 fi
12416 rm -f conftest*
12417   echo "$ac_t""$use__sinhf" 1>&6
12418   ac_ext=c
12419 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12420 ac_cpp='$CPP $CPPFLAGS'
12421 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12422 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12423 cross_compiling=$ac_cv_prog_cc_cross
12424
12425   if test x$use__sinhf = x"yes"; then
12426     for ac_func in _sinhf
12427 do
12428 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12429 echo "configure:12430: checking for $ac_func" >&5
12430 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12431   echo $ac_n "(cached) $ac_c" 1>&6
12432 else
12433   cat > conftest.$ac_ext <<EOF
12434 #line 12435 "configure"
12435 #include "confdefs.h"
12436 /* System header to define __stub macros and hopefully few prototypes,
12437     which can conflict with char $ac_func(); below.  */
12438 #include <assert.h>
12439 /* Override any gcc2 internal prototype to avoid an error.  */
12440 /* We use char because int might match the return type of a gcc2
12441     builtin and then its argument prototype would still apply.  */
12442 char $ac_func();
12443
12444 int main() {
12445
12446 /* The GNU C library defines this for functions which it implements
12447     to always fail with ENOSYS.  Some functions are actually named
12448     something starting with __ and the normal name is an alias.  */
12449 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12450 choke me
12451 #else
12452 $ac_func();
12453 #endif
12454
12455 ; return 0; }
12456 EOF
12457 if { (eval echo configure:12458: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12458   rm -rf conftest*
12459   eval "ac_cv_func_$ac_func=yes"
12460 else
12461   echo "configure: failed program was:" >&5
12462   cat conftest.$ac_ext >&5
12463   rm -rf conftest*
12464   eval "ac_cv_func_$ac_func=no"
12465 fi
12466 rm -f conftest*
12467 fi
12468
12469 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12470   echo "$ac_t""yes" 1>&6
12471     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12472   cat >> confdefs.h <<EOF
12473 #define $ac_tr_func 1
12474 EOF
12475
12476 else
12477   echo "$ac_t""no" 1>&6
12478 fi
12479 done
12480
12481   fi
12482
12483
12484
12485   ac_ext=C
12486 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12487 ac_cpp='$CXXCPP $CPPFLAGS'
12488 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12489 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12490 cross_compiling=$ac_cv_prog_cxx_cross
12491
12492   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
12493 echo "configure:12494: checking for _sqrtf declaration" >&5
12494   cat > conftest.$ac_ext <<EOF
12495 #line 12496 "configure"
12496 #include "confdefs.h"
12497 #include <math.h>
12498 int main() {
12499  _sqrtf(0);
12500 ; return 0; }
12501 EOF
12502 if { (eval echo configure:12503: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12503   rm -rf conftest*
12504   use__sqrtf=yes
12505 else
12506   echo "configure: failed program was:" >&5
12507   cat conftest.$ac_ext >&5
12508   rm -rf conftest*
12509   use__sqrtf=no
12510 fi
12511 rm -f conftest*
12512   echo "$ac_t""$use__sqrtf" 1>&6
12513   ac_ext=c
12514 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12515 ac_cpp='$CPP $CPPFLAGS'
12516 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12517 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12518 cross_compiling=$ac_cv_prog_cc_cross
12519
12520   if test x$use__sqrtf = x"yes"; then
12521     for ac_func in _sqrtf
12522 do
12523 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12524 echo "configure:12525: checking for $ac_func" >&5
12525 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12526   echo $ac_n "(cached) $ac_c" 1>&6
12527 else
12528   cat > conftest.$ac_ext <<EOF
12529 #line 12530 "configure"
12530 #include "confdefs.h"
12531 /* System header to define __stub macros and hopefully few prototypes,
12532     which can conflict with char $ac_func(); below.  */
12533 #include <assert.h>
12534 /* Override any gcc2 internal prototype to avoid an error.  */
12535 /* We use char because int might match the return type of a gcc2
12536     builtin and then its argument prototype would still apply.  */
12537 char $ac_func();
12538
12539 int main() {
12540
12541 /* The GNU C library defines this for functions which it implements
12542     to always fail with ENOSYS.  Some functions are actually named
12543     something starting with __ and the normal name is an alias.  */
12544 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12545 choke me
12546 #else
12547 $ac_func();
12548 #endif
12549
12550 ; return 0; }
12551 EOF
12552 if { (eval echo configure:12553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12553   rm -rf conftest*
12554   eval "ac_cv_func_$ac_func=yes"
12555 else
12556   echo "configure: failed program was:" >&5
12557   cat conftest.$ac_ext >&5
12558   rm -rf conftest*
12559   eval "ac_cv_func_$ac_func=no"
12560 fi
12561 rm -f conftest*
12562 fi
12563
12564 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12565   echo "$ac_t""yes" 1>&6
12566     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12567   cat >> confdefs.h <<EOF
12568 #define $ac_tr_func 1
12569 EOF
12570
12571 else
12572   echo "$ac_t""no" 1>&6
12573 fi
12574 done
12575
12576   fi
12577
12578
12579
12580   ac_ext=C
12581 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12582 ac_cpp='$CXXCPP $CPPFLAGS'
12583 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12584 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12585 cross_compiling=$ac_cv_prog_cxx_cross
12586
12587   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
12588 echo "configure:12589: checking for _tanf declaration" >&5
12589   cat > conftest.$ac_ext <<EOF
12590 #line 12591 "configure"
12591 #include "confdefs.h"
12592 #include <math.h>
12593 int main() {
12594  _tanf(0);
12595 ; return 0; }
12596 EOF
12597 if { (eval echo configure:12598: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12598   rm -rf conftest*
12599   use__tanf=yes
12600 else
12601   echo "configure: failed program was:" >&5
12602   cat conftest.$ac_ext >&5
12603   rm -rf conftest*
12604   use__tanf=no
12605 fi
12606 rm -f conftest*
12607   echo "$ac_t""$use__tanf" 1>&6
12608   ac_ext=c
12609 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12610 ac_cpp='$CPP $CPPFLAGS'
12611 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12612 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12613 cross_compiling=$ac_cv_prog_cc_cross
12614
12615   if test x$use__tanf = x"yes"; then
12616     for ac_func in _tanf
12617 do
12618 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12619 echo "configure:12620: checking for $ac_func" >&5
12620 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12621   echo $ac_n "(cached) $ac_c" 1>&6
12622 else
12623   cat > conftest.$ac_ext <<EOF
12624 #line 12625 "configure"
12625 #include "confdefs.h"
12626 /* System header to define __stub macros and hopefully few prototypes,
12627     which can conflict with char $ac_func(); below.  */
12628 #include <assert.h>
12629 /* Override any gcc2 internal prototype to avoid an error.  */
12630 /* We use char because int might match the return type of a gcc2
12631     builtin and then its argument prototype would still apply.  */
12632 char $ac_func();
12633
12634 int main() {
12635
12636 /* The GNU C library defines this for functions which it implements
12637     to always fail with ENOSYS.  Some functions are actually named
12638     something starting with __ and the normal name is an alias.  */
12639 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12640 choke me
12641 #else
12642 $ac_func();
12643 #endif
12644
12645 ; return 0; }
12646 EOF
12647 if { (eval echo configure:12648: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12648   rm -rf conftest*
12649   eval "ac_cv_func_$ac_func=yes"
12650 else
12651   echo "configure: failed program was:" >&5
12652   cat conftest.$ac_ext >&5
12653   rm -rf conftest*
12654   eval "ac_cv_func_$ac_func=no"
12655 fi
12656 rm -f conftest*
12657 fi
12658
12659 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12660   echo "$ac_t""yes" 1>&6
12661     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12662   cat >> confdefs.h <<EOF
12663 #define $ac_tr_func 1
12664 EOF
12665
12666 else
12667   echo "$ac_t""no" 1>&6
12668 fi
12669 done
12670
12671   fi
12672
12673
12674
12675   ac_ext=C
12676 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12677 ac_cpp='$CXXCPP $CPPFLAGS'
12678 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12679 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12680 cross_compiling=$ac_cv_prog_cxx_cross
12681
12682   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
12683 echo "configure:12684: checking for _tanhf declaration" >&5
12684   cat > conftest.$ac_ext <<EOF
12685 #line 12686 "configure"
12686 #include "confdefs.h"
12687 #include <math.h>
12688 int main() {
12689  _tanhf(0);
12690 ; return 0; }
12691 EOF
12692 if { (eval echo configure:12693: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12693   rm -rf conftest*
12694   use__tanhf=yes
12695 else
12696   echo "configure: failed program was:" >&5
12697   cat conftest.$ac_ext >&5
12698   rm -rf conftest*
12699   use__tanhf=no
12700 fi
12701 rm -f conftest*
12702   echo "$ac_t""$use__tanhf" 1>&6
12703   ac_ext=c
12704 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12705 ac_cpp='$CPP $CPPFLAGS'
12706 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12707 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12708 cross_compiling=$ac_cv_prog_cc_cross
12709
12710   if test x$use__tanhf = x"yes"; then
12711     for ac_func in _tanhf
12712 do
12713 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12714 echo "configure:12715: checking for $ac_func" >&5
12715 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12716   echo $ac_n "(cached) $ac_c" 1>&6
12717 else
12718   cat > conftest.$ac_ext <<EOF
12719 #line 12720 "configure"
12720 #include "confdefs.h"
12721 /* System header to define __stub macros and hopefully few prototypes,
12722     which can conflict with char $ac_func(); below.  */
12723 #include <assert.h>
12724 /* Override any gcc2 internal prototype to avoid an error.  */
12725 /* We use char because int might match the return type of a gcc2
12726     builtin and then its argument prototype would still apply.  */
12727 char $ac_func();
12728
12729 int main() {
12730
12731 /* The GNU C library defines this for functions which it implements
12732     to always fail with ENOSYS.  Some functions are actually named
12733     something starting with __ and the normal name is an alias.  */
12734 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12735 choke me
12736 #else
12737 $ac_func();
12738 #endif
12739
12740 ; return 0; }
12741 EOF
12742 if { (eval echo configure:12743: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12743   rm -rf conftest*
12744   eval "ac_cv_func_$ac_func=yes"
12745 else
12746   echo "configure: failed program was:" >&5
12747   cat conftest.$ac_ext >&5
12748   rm -rf conftest*
12749   eval "ac_cv_func_$ac_func=no"
12750 fi
12751 rm -f conftest*
12752 fi
12753
12754 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12755   echo "$ac_t""yes" 1>&6
12756     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12757   cat >> confdefs.h <<EOF
12758 #define $ac_tr_func 1
12759 EOF
12760
12761 else
12762   echo "$ac_t""no" 1>&6
12763 fi
12764 done
12765
12766   fi
12767
12768
12769
12770   ac_ext=C
12771 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12772 ac_cpp='$CXXCPP $CPPFLAGS'
12773 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12774 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12775 cross_compiling=$ac_cv_prog_cxx_cross
12776
12777   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
12778 echo "configure:12779: checking for _sincosf declaration" >&5
12779   cat > conftest.$ac_ext <<EOF
12780 #line 12781 "configure"
12781 #include "confdefs.h"
12782 #include <math.h>
12783 int main() {
12784  _sincosf(0, 0, 0);
12785 ; return 0; }
12786 EOF
12787 if { (eval echo configure:12788: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12788   rm -rf conftest*
12789   use__sincosf=yes
12790 else
12791   echo "configure: failed program was:" >&5
12792   cat conftest.$ac_ext >&5
12793   rm -rf conftest*
12794   use__sincosf=no
12795 fi
12796 rm -f conftest*
12797   echo "$ac_t""$use__sincosf" 1>&6
12798   ac_ext=c
12799 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12800 ac_cpp='$CPP $CPPFLAGS'
12801 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12802 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12803 cross_compiling=$ac_cv_prog_cc_cross
12804
12805   if test x$use__sincosf = x"yes"; then
12806     for ac_func in _sincosf
12807 do
12808 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12809 echo "configure:12810: checking for $ac_func" >&5
12810 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12811   echo $ac_n "(cached) $ac_c" 1>&6
12812 else
12813   cat > conftest.$ac_ext <<EOF
12814 #line 12815 "configure"
12815 #include "confdefs.h"
12816 /* System header to define __stub macros and hopefully few prototypes,
12817     which can conflict with char $ac_func(); below.  */
12818 #include <assert.h>
12819 /* Override any gcc2 internal prototype to avoid an error.  */
12820 /* We use char because int might match the return type of a gcc2
12821     builtin and then its argument prototype would still apply.  */
12822 char $ac_func();
12823
12824 int main() {
12825
12826 /* The GNU C library defines this for functions which it implements
12827     to always fail with ENOSYS.  Some functions are actually named
12828     something starting with __ and the normal name is an alias.  */
12829 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12830 choke me
12831 #else
12832 $ac_func();
12833 #endif
12834
12835 ; return 0; }
12836 EOF
12837 if { (eval echo configure:12838: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12838   rm -rf conftest*
12839   eval "ac_cv_func_$ac_func=yes"
12840 else
12841   echo "configure: failed program was:" >&5
12842   cat conftest.$ac_ext >&5
12843   rm -rf conftest*
12844   eval "ac_cv_func_$ac_func=no"
12845 fi
12846 rm -f conftest*
12847 fi
12848
12849 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12850   echo "$ac_t""yes" 1>&6
12851     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12852   cat >> confdefs.h <<EOF
12853 #define $ac_tr_func 1
12854 EOF
12855
12856 else
12857   echo "$ac_t""no" 1>&6
12858 fi
12859 done
12860
12861   fi
12862
12863
12864
12865   ac_ext=C
12866 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12867 ac_cpp='$CXXCPP $CPPFLAGS'
12868 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12869 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12870 cross_compiling=$ac_cv_prog_cxx_cross
12871
12872   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
12873 echo "configure:12874: checking for _finitef declaration" >&5
12874   cat > conftest.$ac_ext <<EOF
12875 #line 12876 "configure"
12876 #include "confdefs.h"
12877 #include <math.h>
12878 int main() {
12879  _finitef(0);
12880 ; return 0; }
12881 EOF
12882 if { (eval echo configure:12883: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12883   rm -rf conftest*
12884   use__finitef=yes
12885 else
12886   echo "configure: failed program was:" >&5
12887   cat conftest.$ac_ext >&5
12888   rm -rf conftest*
12889   use__finitef=no
12890 fi
12891 rm -f conftest*
12892   echo "$ac_t""$use__finitef" 1>&6
12893   ac_ext=c
12894 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12895 ac_cpp='$CPP $CPPFLAGS'
12896 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12897 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12898 cross_compiling=$ac_cv_prog_cc_cross
12899
12900   if test x$use__finitef = x"yes"; then
12901     for ac_func in _finitef
12902 do
12903 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12904 echo "configure:12905: checking for $ac_func" >&5
12905 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12906   echo $ac_n "(cached) $ac_c" 1>&6
12907 else
12908   cat > conftest.$ac_ext <<EOF
12909 #line 12910 "configure"
12910 #include "confdefs.h"
12911 /* System header to define __stub macros and hopefully few prototypes,
12912     which can conflict with char $ac_func(); below.  */
12913 #include <assert.h>
12914 /* Override any gcc2 internal prototype to avoid an error.  */
12915 /* We use char because int might match the return type of a gcc2
12916     builtin and then its argument prototype would still apply.  */
12917 char $ac_func();
12918
12919 int main() {
12920
12921 /* The GNU C library defines this for functions which it implements
12922     to always fail with ENOSYS.  Some functions are actually named
12923     something starting with __ and the normal name is an alias.  */
12924 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12925 choke me
12926 #else
12927 $ac_func();
12928 #endif
12929
12930 ; return 0; }
12931 EOF
12932 if { (eval echo configure:12933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12933   rm -rf conftest*
12934   eval "ac_cv_func_$ac_func=yes"
12935 else
12936   echo "configure: failed program was:" >&5
12937   cat conftest.$ac_ext >&5
12938   rm -rf conftest*
12939   eval "ac_cv_func_$ac_func=no"
12940 fi
12941 rm -f conftest*
12942 fi
12943
12944 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12945   echo "$ac_t""yes" 1>&6
12946     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12947   cat >> confdefs.h <<EOF
12948 #define $ac_tr_func 1
12949 EOF
12950
12951 else
12952   echo "$ac_t""no" 1>&6
12953 fi
12954 done
12955
12956   fi
12957
12958
12959
12960
12961   ac_ext=C
12962 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12963 ac_cpp='$CXXCPP $CPPFLAGS'
12964 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12965 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12966 cross_compiling=$ac_cv_prog_cxx_cross
12967
12968   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
12969 echo "configure:12970: checking for _isnanl declaration" >&5
12970   cat > conftest.$ac_ext <<EOF
12971 #line 12972 "configure"
12972 #include "confdefs.h"
12973 #include <math.h>
12974 int main() {
12975  _isnanl(0);
12976 ; return 0; }
12977 EOF
12978 if { (eval echo configure:12979: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12979   rm -rf conftest*
12980   use__isnanl=yes
12981 else
12982   echo "configure: failed program was:" >&5
12983   cat conftest.$ac_ext >&5
12984   rm -rf conftest*
12985   use__isnanl=no
12986 fi
12987 rm -f conftest*
12988   echo "$ac_t""$use__isnanl" 1>&6
12989   ac_ext=c
12990 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12991 ac_cpp='$CPP $CPPFLAGS'
12992 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12993 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12994 cross_compiling=$ac_cv_prog_cc_cross
12995
12996   if test x$use__isnanl = x"yes"; then
12997     for ac_func in _isnanl
12998 do
12999 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13000 echo "configure:13001: checking for $ac_func" >&5
13001 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13002   echo $ac_n "(cached) $ac_c" 1>&6
13003 else
13004   cat > conftest.$ac_ext <<EOF
13005 #line 13006 "configure"
13006 #include "confdefs.h"
13007 /* System header to define __stub macros and hopefully few prototypes,
13008     which can conflict with char $ac_func(); below.  */
13009 #include <assert.h>
13010 /* Override any gcc2 internal prototype to avoid an error.  */
13011 /* We use char because int might match the return type of a gcc2
13012     builtin and then its argument prototype would still apply.  */
13013 char $ac_func();
13014
13015 int main() {
13016
13017 /* The GNU C library defines this for functions which it implements
13018     to always fail with ENOSYS.  Some functions are actually named
13019     something starting with __ and the normal name is an alias.  */
13020 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13021 choke me
13022 #else
13023 $ac_func();
13024 #endif
13025
13026 ; return 0; }
13027 EOF
13028 if { (eval echo configure:13029: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13029   rm -rf conftest*
13030   eval "ac_cv_func_$ac_func=yes"
13031 else
13032   echo "configure: failed program was:" >&5
13033   cat conftest.$ac_ext >&5
13034   rm -rf conftest*
13035   eval "ac_cv_func_$ac_func=no"
13036 fi
13037 rm -f conftest*
13038 fi
13039
13040 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13041   echo "$ac_t""yes" 1>&6
13042     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13043   cat >> confdefs.h <<EOF
13044 #define $ac_tr_func 1
13045 EOF
13046
13047 else
13048   echo "$ac_t""no" 1>&6
13049 fi
13050 done
13051
13052   fi
13053
13054
13055
13056   ac_ext=C
13057 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13058 ac_cpp='$CXXCPP $CPPFLAGS'
13059 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13060 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13061 cross_compiling=$ac_cv_prog_cxx_cross
13062
13063   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
13064 echo "configure:13065: checking for _isinfl declaration" >&5
13065   cat > conftest.$ac_ext <<EOF
13066 #line 13067 "configure"
13067 #include "confdefs.h"
13068 #include <math.h>
13069 int main() {
13070  _isinfl(0);
13071 ; return 0; }
13072 EOF
13073 if { (eval echo configure:13074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13074   rm -rf conftest*
13075   use__isinfl=yes
13076 else
13077   echo "configure: failed program was:" >&5
13078   cat conftest.$ac_ext >&5
13079   rm -rf conftest*
13080   use__isinfl=no
13081 fi
13082 rm -f conftest*
13083   echo "$ac_t""$use__isinfl" 1>&6
13084   ac_ext=c
13085 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13086 ac_cpp='$CPP $CPPFLAGS'
13087 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13088 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13089 cross_compiling=$ac_cv_prog_cc_cross
13090
13091   if test x$use__isinfl = x"yes"; then
13092     for ac_func in _isinfl
13093 do
13094 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13095 echo "configure:13096: checking for $ac_func" >&5
13096 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13097   echo $ac_n "(cached) $ac_c" 1>&6
13098 else
13099   cat > conftest.$ac_ext <<EOF
13100 #line 13101 "configure"
13101 #include "confdefs.h"
13102 /* System header to define __stub macros and hopefully few prototypes,
13103     which can conflict with char $ac_func(); below.  */
13104 #include <assert.h>
13105 /* Override any gcc2 internal prototype to avoid an error.  */
13106 /* We use char because int might match the return type of a gcc2
13107     builtin and then its argument prototype would still apply.  */
13108 char $ac_func();
13109
13110 int main() {
13111
13112 /* The GNU C library defines this for functions which it implements
13113     to always fail with ENOSYS.  Some functions are actually named
13114     something starting with __ and the normal name is an alias.  */
13115 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13116 choke me
13117 #else
13118 $ac_func();
13119 #endif
13120
13121 ; return 0; }
13122 EOF
13123 if { (eval echo configure:13124: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13124   rm -rf conftest*
13125   eval "ac_cv_func_$ac_func=yes"
13126 else
13127   echo "configure: failed program was:" >&5
13128   cat conftest.$ac_ext >&5
13129   rm -rf conftest*
13130   eval "ac_cv_func_$ac_func=no"
13131 fi
13132 rm -f conftest*
13133 fi
13134
13135 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13136   echo "$ac_t""yes" 1>&6
13137     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13138   cat >> confdefs.h <<EOF
13139 #define $ac_tr_func 1
13140 EOF
13141
13142 else
13143   echo "$ac_t""no" 1>&6
13144 fi
13145 done
13146
13147   fi
13148
13149
13150
13151   ac_ext=C
13152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13153 ac_cpp='$CXXCPP $CPPFLAGS'
13154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13156 cross_compiling=$ac_cv_prog_cxx_cross
13157
13158   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
13159 echo "configure:13160: checking for _copysignl declaration" >&5
13160   cat > conftest.$ac_ext <<EOF
13161 #line 13162 "configure"
13162 #include "confdefs.h"
13163 #include <math.h>
13164 int main() {
13165  _copysignl(0, 0);
13166 ; return 0; }
13167 EOF
13168 if { (eval echo configure:13169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13169   rm -rf conftest*
13170   use__copysignl=yes
13171 else
13172   echo "configure: failed program was:" >&5
13173   cat conftest.$ac_ext >&5
13174   rm -rf conftest*
13175   use__copysignl=no
13176 fi
13177 rm -f conftest*
13178   echo "$ac_t""$use__copysignl" 1>&6
13179   ac_ext=c
13180 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13181 ac_cpp='$CPP $CPPFLAGS'
13182 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13183 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13184 cross_compiling=$ac_cv_prog_cc_cross
13185
13186   if test x$use__copysignl = x"yes"; then
13187     for ac_func in _copysignl
13188 do
13189 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13190 echo "configure:13191: checking for $ac_func" >&5
13191 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13192   echo $ac_n "(cached) $ac_c" 1>&6
13193 else
13194   cat > conftest.$ac_ext <<EOF
13195 #line 13196 "configure"
13196 #include "confdefs.h"
13197 /* System header to define __stub macros and hopefully few prototypes,
13198     which can conflict with char $ac_func(); below.  */
13199 #include <assert.h>
13200 /* Override any gcc2 internal prototype to avoid an error.  */
13201 /* We use char because int might match the return type of a gcc2
13202     builtin and then its argument prototype would still apply.  */
13203 char $ac_func();
13204
13205 int main() {
13206
13207 /* The GNU C library defines this for functions which it implements
13208     to always fail with ENOSYS.  Some functions are actually named
13209     something starting with __ and the normal name is an alias.  */
13210 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13211 choke me
13212 #else
13213 $ac_func();
13214 #endif
13215
13216 ; return 0; }
13217 EOF
13218 if { (eval echo configure:13219: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13219   rm -rf conftest*
13220   eval "ac_cv_func_$ac_func=yes"
13221 else
13222   echo "configure: failed program was:" >&5
13223   cat conftest.$ac_ext >&5
13224   rm -rf conftest*
13225   eval "ac_cv_func_$ac_func=no"
13226 fi
13227 rm -f conftest*
13228 fi
13229
13230 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13231   echo "$ac_t""yes" 1>&6
13232     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13233   cat >> confdefs.h <<EOF
13234 #define $ac_tr_func 1
13235 EOF
13236
13237 else
13238   echo "$ac_t""no" 1>&6
13239 fi
13240 done
13241
13242   fi
13243
13244
13245
13246   ac_ext=C
13247 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13248 ac_cpp='$CXXCPP $CPPFLAGS'
13249 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13250 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13251 cross_compiling=$ac_cv_prog_cxx_cross
13252
13253   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
13254 echo "configure:13255: checking for _acosl declaration" >&5
13255   cat > conftest.$ac_ext <<EOF
13256 #line 13257 "configure"
13257 #include "confdefs.h"
13258 #include <math.h>
13259 int main() {
13260  _acosl(0);
13261 ; return 0; }
13262 EOF
13263 if { (eval echo configure:13264: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13264   rm -rf conftest*
13265   use__acosl=yes
13266 else
13267   echo "configure: failed program was:" >&5
13268   cat conftest.$ac_ext >&5
13269   rm -rf conftest*
13270   use__acosl=no
13271 fi
13272 rm -f conftest*
13273   echo "$ac_t""$use__acosl" 1>&6
13274   ac_ext=c
13275 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13276 ac_cpp='$CPP $CPPFLAGS'
13277 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13278 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13279 cross_compiling=$ac_cv_prog_cc_cross
13280
13281   if test x$use__acosl = x"yes"; then
13282     for ac_func in _acosl
13283 do
13284 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13285 echo "configure:13286: checking for $ac_func" >&5
13286 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13287   echo $ac_n "(cached) $ac_c" 1>&6
13288 else
13289   cat > conftest.$ac_ext <<EOF
13290 #line 13291 "configure"
13291 #include "confdefs.h"
13292 /* System header to define __stub macros and hopefully few prototypes,
13293     which can conflict with char $ac_func(); below.  */
13294 #include <assert.h>
13295 /* Override any gcc2 internal prototype to avoid an error.  */
13296 /* We use char because int might match the return type of a gcc2
13297     builtin and then its argument prototype would still apply.  */
13298 char $ac_func();
13299
13300 int main() {
13301
13302 /* The GNU C library defines this for functions which it implements
13303     to always fail with ENOSYS.  Some functions are actually named
13304     something starting with __ and the normal name is an alias.  */
13305 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13306 choke me
13307 #else
13308 $ac_func();
13309 #endif
13310
13311 ; return 0; }
13312 EOF
13313 if { (eval echo configure:13314: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13314   rm -rf conftest*
13315   eval "ac_cv_func_$ac_func=yes"
13316 else
13317   echo "configure: failed program was:" >&5
13318   cat conftest.$ac_ext >&5
13319   rm -rf conftest*
13320   eval "ac_cv_func_$ac_func=no"
13321 fi
13322 rm -f conftest*
13323 fi
13324
13325 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13326   echo "$ac_t""yes" 1>&6
13327     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13328   cat >> confdefs.h <<EOF
13329 #define $ac_tr_func 1
13330 EOF
13331
13332 else
13333   echo "$ac_t""no" 1>&6
13334 fi
13335 done
13336
13337   fi
13338
13339
13340
13341   ac_ext=C
13342 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13343 ac_cpp='$CXXCPP $CPPFLAGS'
13344 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13345 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13346 cross_compiling=$ac_cv_prog_cxx_cross
13347
13348   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
13349 echo "configure:13350: checking for _asinl declaration" >&5
13350   cat > conftest.$ac_ext <<EOF
13351 #line 13352 "configure"
13352 #include "confdefs.h"
13353 #include <math.h>
13354 int main() {
13355  _asinl(0);
13356 ; return 0; }
13357 EOF
13358 if { (eval echo configure:13359: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13359   rm -rf conftest*
13360   use__asinl=yes
13361 else
13362   echo "configure: failed program was:" >&5
13363   cat conftest.$ac_ext >&5
13364   rm -rf conftest*
13365   use__asinl=no
13366 fi
13367 rm -f conftest*
13368   echo "$ac_t""$use__asinl" 1>&6
13369   ac_ext=c
13370 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13371 ac_cpp='$CPP $CPPFLAGS'
13372 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13373 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13374 cross_compiling=$ac_cv_prog_cc_cross
13375
13376   if test x$use__asinl = x"yes"; then
13377     for ac_func in _asinl
13378 do
13379 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13380 echo "configure:13381: checking for $ac_func" >&5
13381 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13382   echo $ac_n "(cached) $ac_c" 1>&6
13383 else
13384   cat > conftest.$ac_ext <<EOF
13385 #line 13386 "configure"
13386 #include "confdefs.h"
13387 /* System header to define __stub macros and hopefully few prototypes,
13388     which can conflict with char $ac_func(); below.  */
13389 #include <assert.h>
13390 /* Override any gcc2 internal prototype to avoid an error.  */
13391 /* We use char because int might match the return type of a gcc2
13392     builtin and then its argument prototype would still apply.  */
13393 char $ac_func();
13394
13395 int main() {
13396
13397 /* The GNU C library defines this for functions which it implements
13398     to always fail with ENOSYS.  Some functions are actually named
13399     something starting with __ and the normal name is an alias.  */
13400 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13401 choke me
13402 #else
13403 $ac_func();
13404 #endif
13405
13406 ; return 0; }
13407 EOF
13408 if { (eval echo configure:13409: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13409   rm -rf conftest*
13410   eval "ac_cv_func_$ac_func=yes"
13411 else
13412   echo "configure: failed program was:" >&5
13413   cat conftest.$ac_ext >&5
13414   rm -rf conftest*
13415   eval "ac_cv_func_$ac_func=no"
13416 fi
13417 rm -f conftest*
13418 fi
13419
13420 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13421   echo "$ac_t""yes" 1>&6
13422     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13423   cat >> confdefs.h <<EOF
13424 #define $ac_tr_func 1
13425 EOF
13426
13427 else
13428   echo "$ac_t""no" 1>&6
13429 fi
13430 done
13431
13432   fi
13433
13434
13435
13436   ac_ext=C
13437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13438 ac_cpp='$CXXCPP $CPPFLAGS'
13439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13441 cross_compiling=$ac_cv_prog_cxx_cross
13442
13443   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
13444 echo "configure:13445: checking for _atanl declaration" >&5
13445   cat > conftest.$ac_ext <<EOF
13446 #line 13447 "configure"
13447 #include "confdefs.h"
13448 #include <math.h>
13449 int main() {
13450  _atanl(0);
13451 ; return 0; }
13452 EOF
13453 if { (eval echo configure:13454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13454   rm -rf conftest*
13455   use__atanl=yes
13456 else
13457   echo "configure: failed program was:" >&5
13458   cat conftest.$ac_ext >&5
13459   rm -rf conftest*
13460   use__atanl=no
13461 fi
13462 rm -f conftest*
13463   echo "$ac_t""$use__atanl" 1>&6
13464   ac_ext=c
13465 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13466 ac_cpp='$CPP $CPPFLAGS'
13467 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13468 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13469 cross_compiling=$ac_cv_prog_cc_cross
13470
13471   if test x$use__atanl = x"yes"; then
13472     for ac_func in _atanl
13473 do
13474 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13475 echo "configure:13476: checking for $ac_func" >&5
13476 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13477   echo $ac_n "(cached) $ac_c" 1>&6
13478 else
13479   cat > conftest.$ac_ext <<EOF
13480 #line 13481 "configure"
13481 #include "confdefs.h"
13482 /* System header to define __stub macros and hopefully few prototypes,
13483     which can conflict with char $ac_func(); below.  */
13484 #include <assert.h>
13485 /* Override any gcc2 internal prototype to avoid an error.  */
13486 /* We use char because int might match the return type of a gcc2
13487     builtin and then its argument prototype would still apply.  */
13488 char $ac_func();
13489
13490 int main() {
13491
13492 /* The GNU C library defines this for functions which it implements
13493     to always fail with ENOSYS.  Some functions are actually named
13494     something starting with __ and the normal name is an alias.  */
13495 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13496 choke me
13497 #else
13498 $ac_func();
13499 #endif
13500
13501 ; return 0; }
13502 EOF
13503 if { (eval echo configure:13504: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13504   rm -rf conftest*
13505   eval "ac_cv_func_$ac_func=yes"
13506 else
13507   echo "configure: failed program was:" >&5
13508   cat conftest.$ac_ext >&5
13509   rm -rf conftest*
13510   eval "ac_cv_func_$ac_func=no"
13511 fi
13512 rm -f conftest*
13513 fi
13514
13515 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13516   echo "$ac_t""yes" 1>&6
13517     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13518   cat >> confdefs.h <<EOF
13519 #define $ac_tr_func 1
13520 EOF
13521
13522 else
13523   echo "$ac_t""no" 1>&6
13524 fi
13525 done
13526
13527   fi
13528
13529
13530
13531   ac_ext=C
13532 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13533 ac_cpp='$CXXCPP $CPPFLAGS'
13534 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13535 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13536 cross_compiling=$ac_cv_prog_cxx_cross
13537
13538   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
13539 echo "configure:13540: checking for _atan2l declaration" >&5
13540   cat > conftest.$ac_ext <<EOF
13541 #line 13542 "configure"
13542 #include "confdefs.h"
13543 #include <math.h>
13544 int main() {
13545  _atan2l(0, 0);
13546 ; return 0; }
13547 EOF
13548 if { (eval echo configure:13549: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13549   rm -rf conftest*
13550   use__atan2l=yes
13551 else
13552   echo "configure: failed program was:" >&5
13553   cat conftest.$ac_ext >&5
13554   rm -rf conftest*
13555   use__atan2l=no
13556 fi
13557 rm -f conftest*
13558   echo "$ac_t""$use__atan2l" 1>&6
13559   ac_ext=c
13560 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13561 ac_cpp='$CPP $CPPFLAGS'
13562 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13563 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13564 cross_compiling=$ac_cv_prog_cc_cross
13565
13566   if test x$use__atan2l = x"yes"; then
13567     for ac_func in _atan2l
13568 do
13569 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13570 echo "configure:13571: checking for $ac_func" >&5
13571 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13572   echo $ac_n "(cached) $ac_c" 1>&6
13573 else
13574   cat > conftest.$ac_ext <<EOF
13575 #line 13576 "configure"
13576 #include "confdefs.h"
13577 /* System header to define __stub macros and hopefully few prototypes,
13578     which can conflict with char $ac_func(); below.  */
13579 #include <assert.h>
13580 /* Override any gcc2 internal prototype to avoid an error.  */
13581 /* We use char because int might match the return type of a gcc2
13582     builtin and then its argument prototype would still apply.  */
13583 char $ac_func();
13584
13585 int main() {
13586
13587 /* The GNU C library defines this for functions which it implements
13588     to always fail with ENOSYS.  Some functions are actually named
13589     something starting with __ and the normal name is an alias.  */
13590 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13591 choke me
13592 #else
13593 $ac_func();
13594 #endif
13595
13596 ; return 0; }
13597 EOF
13598 if { (eval echo configure:13599: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13599   rm -rf conftest*
13600   eval "ac_cv_func_$ac_func=yes"
13601 else
13602   echo "configure: failed program was:" >&5
13603   cat conftest.$ac_ext >&5
13604   rm -rf conftest*
13605   eval "ac_cv_func_$ac_func=no"
13606 fi
13607 rm -f conftest*
13608 fi
13609
13610 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13611   echo "$ac_t""yes" 1>&6
13612     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13613   cat >> confdefs.h <<EOF
13614 #define $ac_tr_func 1
13615 EOF
13616
13617 else
13618   echo "$ac_t""no" 1>&6
13619 fi
13620 done
13621
13622   fi
13623
13624
13625
13626   ac_ext=C
13627 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13628 ac_cpp='$CXXCPP $CPPFLAGS'
13629 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13630 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13631 cross_compiling=$ac_cv_prog_cxx_cross
13632
13633   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
13634 echo "configure:13635: checking for _ceill declaration" >&5
13635   cat > conftest.$ac_ext <<EOF
13636 #line 13637 "configure"
13637 #include "confdefs.h"
13638 #include <math.h>
13639 int main() {
13640  _ceill(0);
13641 ; return 0; }
13642 EOF
13643 if { (eval echo configure:13644: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13644   rm -rf conftest*
13645   use__ceill=yes
13646 else
13647   echo "configure: failed program was:" >&5
13648   cat conftest.$ac_ext >&5
13649   rm -rf conftest*
13650   use__ceill=no
13651 fi
13652 rm -f conftest*
13653   echo "$ac_t""$use__ceill" 1>&6
13654   ac_ext=c
13655 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13656 ac_cpp='$CPP $CPPFLAGS'
13657 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13658 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13659 cross_compiling=$ac_cv_prog_cc_cross
13660
13661   if test x$use__ceill = x"yes"; then
13662     for ac_func in _ceill
13663 do
13664 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13665 echo "configure:13666: checking for $ac_func" >&5
13666 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13667   echo $ac_n "(cached) $ac_c" 1>&6
13668 else
13669   cat > conftest.$ac_ext <<EOF
13670 #line 13671 "configure"
13671 #include "confdefs.h"
13672 /* System header to define __stub macros and hopefully few prototypes,
13673     which can conflict with char $ac_func(); below.  */
13674 #include <assert.h>
13675 /* Override any gcc2 internal prototype to avoid an error.  */
13676 /* We use char because int might match the return type of a gcc2
13677     builtin and then its argument prototype would still apply.  */
13678 char $ac_func();
13679
13680 int main() {
13681
13682 /* The GNU C library defines this for functions which it implements
13683     to always fail with ENOSYS.  Some functions are actually named
13684     something starting with __ and the normal name is an alias.  */
13685 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13686 choke me
13687 #else
13688 $ac_func();
13689 #endif
13690
13691 ; return 0; }
13692 EOF
13693 if { (eval echo configure:13694: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13694   rm -rf conftest*
13695   eval "ac_cv_func_$ac_func=yes"
13696 else
13697   echo "configure: failed program was:" >&5
13698   cat conftest.$ac_ext >&5
13699   rm -rf conftest*
13700   eval "ac_cv_func_$ac_func=no"
13701 fi
13702 rm -f conftest*
13703 fi
13704
13705 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13706   echo "$ac_t""yes" 1>&6
13707     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13708   cat >> confdefs.h <<EOF
13709 #define $ac_tr_func 1
13710 EOF
13711
13712 else
13713   echo "$ac_t""no" 1>&6
13714 fi
13715 done
13716
13717   fi
13718
13719
13720
13721   ac_ext=C
13722 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13723 ac_cpp='$CXXCPP $CPPFLAGS'
13724 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13725 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13726 cross_compiling=$ac_cv_prog_cxx_cross
13727
13728   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
13729 echo "configure:13730: checking for _cosl declaration" >&5
13730   cat > conftest.$ac_ext <<EOF
13731 #line 13732 "configure"
13732 #include "confdefs.h"
13733 #include <math.h>
13734 int main() {
13735  _cosl(0);
13736 ; return 0; }
13737 EOF
13738 if { (eval echo configure:13739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13739   rm -rf conftest*
13740   use__cosl=yes
13741 else
13742   echo "configure: failed program was:" >&5
13743   cat conftest.$ac_ext >&5
13744   rm -rf conftest*
13745   use__cosl=no
13746 fi
13747 rm -f conftest*
13748   echo "$ac_t""$use__cosl" 1>&6
13749   ac_ext=c
13750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13751 ac_cpp='$CPP $CPPFLAGS'
13752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13754 cross_compiling=$ac_cv_prog_cc_cross
13755
13756   if test x$use__cosl = x"yes"; then
13757     for ac_func in _cosl
13758 do
13759 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13760 echo "configure:13761: checking for $ac_func" >&5
13761 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13762   echo $ac_n "(cached) $ac_c" 1>&6
13763 else
13764   cat > conftest.$ac_ext <<EOF
13765 #line 13766 "configure"
13766 #include "confdefs.h"
13767 /* System header to define __stub macros and hopefully few prototypes,
13768     which can conflict with char $ac_func(); below.  */
13769 #include <assert.h>
13770 /* Override any gcc2 internal prototype to avoid an error.  */
13771 /* We use char because int might match the return type of a gcc2
13772     builtin and then its argument prototype would still apply.  */
13773 char $ac_func();
13774
13775 int main() {
13776
13777 /* The GNU C library defines this for functions which it implements
13778     to always fail with ENOSYS.  Some functions are actually named
13779     something starting with __ and the normal name is an alias.  */
13780 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13781 choke me
13782 #else
13783 $ac_func();
13784 #endif
13785
13786 ; return 0; }
13787 EOF
13788 if { (eval echo configure:13789: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13789   rm -rf conftest*
13790   eval "ac_cv_func_$ac_func=yes"
13791 else
13792   echo "configure: failed program was:" >&5
13793   cat conftest.$ac_ext >&5
13794   rm -rf conftest*
13795   eval "ac_cv_func_$ac_func=no"
13796 fi
13797 rm -f conftest*
13798 fi
13799
13800 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13801   echo "$ac_t""yes" 1>&6
13802     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13803   cat >> confdefs.h <<EOF
13804 #define $ac_tr_func 1
13805 EOF
13806
13807 else
13808   echo "$ac_t""no" 1>&6
13809 fi
13810 done
13811
13812   fi
13813
13814
13815
13816   ac_ext=C
13817 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13818 ac_cpp='$CXXCPP $CPPFLAGS'
13819 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13820 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13821 cross_compiling=$ac_cv_prog_cxx_cross
13822
13823   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
13824 echo "configure:13825: checking for _coshl declaration" >&5
13825   cat > conftest.$ac_ext <<EOF
13826 #line 13827 "configure"
13827 #include "confdefs.h"
13828 #include <math.h>
13829 int main() {
13830  _coshl(0);
13831 ; return 0; }
13832 EOF
13833 if { (eval echo configure:13834: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13834   rm -rf conftest*
13835   use__coshl=yes
13836 else
13837   echo "configure: failed program was:" >&5
13838   cat conftest.$ac_ext >&5
13839   rm -rf conftest*
13840   use__coshl=no
13841 fi
13842 rm -f conftest*
13843   echo "$ac_t""$use__coshl" 1>&6
13844   ac_ext=c
13845 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13846 ac_cpp='$CPP $CPPFLAGS'
13847 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13848 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13849 cross_compiling=$ac_cv_prog_cc_cross
13850
13851   if test x$use__coshl = x"yes"; then
13852     for ac_func in _coshl
13853 do
13854 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13855 echo "configure:13856: checking for $ac_func" >&5
13856 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13857   echo $ac_n "(cached) $ac_c" 1>&6
13858 else
13859   cat > conftest.$ac_ext <<EOF
13860 #line 13861 "configure"
13861 #include "confdefs.h"
13862 /* System header to define __stub macros and hopefully few prototypes,
13863     which can conflict with char $ac_func(); below.  */
13864 #include <assert.h>
13865 /* Override any gcc2 internal prototype to avoid an error.  */
13866 /* We use char because int might match the return type of a gcc2
13867     builtin and then its argument prototype would still apply.  */
13868 char $ac_func();
13869
13870 int main() {
13871
13872 /* The GNU C library defines this for functions which it implements
13873     to always fail with ENOSYS.  Some functions are actually named
13874     something starting with __ and the normal name is an alias.  */
13875 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13876 choke me
13877 #else
13878 $ac_func();
13879 #endif
13880
13881 ; return 0; }
13882 EOF
13883 if { (eval echo configure:13884: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13884   rm -rf conftest*
13885   eval "ac_cv_func_$ac_func=yes"
13886 else
13887   echo "configure: failed program was:" >&5
13888   cat conftest.$ac_ext >&5
13889   rm -rf conftest*
13890   eval "ac_cv_func_$ac_func=no"
13891 fi
13892 rm -f conftest*
13893 fi
13894
13895 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13896   echo "$ac_t""yes" 1>&6
13897     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13898   cat >> confdefs.h <<EOF
13899 #define $ac_tr_func 1
13900 EOF
13901
13902 else
13903   echo "$ac_t""no" 1>&6
13904 fi
13905 done
13906
13907   fi
13908
13909
13910
13911   ac_ext=C
13912 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13913 ac_cpp='$CXXCPP $CPPFLAGS'
13914 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13915 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13916 cross_compiling=$ac_cv_prog_cxx_cross
13917
13918   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
13919 echo "configure:13920: checking for _expl declaration" >&5
13920   cat > conftest.$ac_ext <<EOF
13921 #line 13922 "configure"
13922 #include "confdefs.h"
13923 #include <math.h>
13924 int main() {
13925  _expl(0);
13926 ; return 0; }
13927 EOF
13928 if { (eval echo configure:13929: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13929   rm -rf conftest*
13930   use__expl=yes
13931 else
13932   echo "configure: failed program was:" >&5
13933   cat conftest.$ac_ext >&5
13934   rm -rf conftest*
13935   use__expl=no
13936 fi
13937 rm -f conftest*
13938   echo "$ac_t""$use__expl" 1>&6
13939   ac_ext=c
13940 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13941 ac_cpp='$CPP $CPPFLAGS'
13942 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13943 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13944 cross_compiling=$ac_cv_prog_cc_cross
13945
13946   if test x$use__expl = x"yes"; then
13947     for ac_func in _expl
13948 do
13949 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13950 echo "configure:13951: checking for $ac_func" >&5
13951 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13952   echo $ac_n "(cached) $ac_c" 1>&6
13953 else
13954   cat > conftest.$ac_ext <<EOF
13955 #line 13956 "configure"
13956 #include "confdefs.h"
13957 /* System header to define __stub macros and hopefully few prototypes,
13958     which can conflict with char $ac_func(); below.  */
13959 #include <assert.h>
13960 /* Override any gcc2 internal prototype to avoid an error.  */
13961 /* We use char because int might match the return type of a gcc2
13962     builtin and then its argument prototype would still apply.  */
13963 char $ac_func();
13964
13965 int main() {
13966
13967 /* The GNU C library defines this for functions which it implements
13968     to always fail with ENOSYS.  Some functions are actually named
13969     something starting with __ and the normal name is an alias.  */
13970 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13971 choke me
13972 #else
13973 $ac_func();
13974 #endif
13975
13976 ; return 0; }
13977 EOF
13978 if { (eval echo configure:13979: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13979   rm -rf conftest*
13980   eval "ac_cv_func_$ac_func=yes"
13981 else
13982   echo "configure: failed program was:" >&5
13983   cat conftest.$ac_ext >&5
13984   rm -rf conftest*
13985   eval "ac_cv_func_$ac_func=no"
13986 fi
13987 rm -f conftest*
13988 fi
13989
13990 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13991   echo "$ac_t""yes" 1>&6
13992     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13993   cat >> confdefs.h <<EOF
13994 #define $ac_tr_func 1
13995 EOF
13996
13997 else
13998   echo "$ac_t""no" 1>&6
13999 fi
14000 done
14001
14002   fi
14003
14004
14005
14006   ac_ext=C
14007 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14008 ac_cpp='$CXXCPP $CPPFLAGS'
14009 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14010 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14011 cross_compiling=$ac_cv_prog_cxx_cross
14012
14013   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
14014 echo "configure:14015: checking for _fabsl declaration" >&5
14015   cat > conftest.$ac_ext <<EOF
14016 #line 14017 "configure"
14017 #include "confdefs.h"
14018 #include <math.h>
14019 int main() {
14020  _fabsl(0);
14021 ; return 0; }
14022 EOF
14023 if { (eval echo configure:14024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14024   rm -rf conftest*
14025   use__fabsl=yes
14026 else
14027   echo "configure: failed program was:" >&5
14028   cat conftest.$ac_ext >&5
14029   rm -rf conftest*
14030   use__fabsl=no
14031 fi
14032 rm -f conftest*
14033   echo "$ac_t""$use__fabsl" 1>&6
14034   ac_ext=c
14035 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14036 ac_cpp='$CPP $CPPFLAGS'
14037 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14038 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14039 cross_compiling=$ac_cv_prog_cc_cross
14040
14041   if test x$use__fabsl = x"yes"; then
14042     for ac_func in _fabsl
14043 do
14044 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14045 echo "configure:14046: checking for $ac_func" >&5
14046 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14047   echo $ac_n "(cached) $ac_c" 1>&6
14048 else
14049   cat > conftest.$ac_ext <<EOF
14050 #line 14051 "configure"
14051 #include "confdefs.h"
14052 /* System header to define __stub macros and hopefully few prototypes,
14053     which can conflict with char $ac_func(); below.  */
14054 #include <assert.h>
14055 /* Override any gcc2 internal prototype to avoid an error.  */
14056 /* We use char because int might match the return type of a gcc2
14057     builtin and then its argument prototype would still apply.  */
14058 char $ac_func();
14059
14060 int main() {
14061
14062 /* The GNU C library defines this for functions which it implements
14063     to always fail with ENOSYS.  Some functions are actually named
14064     something starting with __ and the normal name is an alias.  */
14065 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14066 choke me
14067 #else
14068 $ac_func();
14069 #endif
14070
14071 ; return 0; }
14072 EOF
14073 if { (eval echo configure:14074: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14074   rm -rf conftest*
14075   eval "ac_cv_func_$ac_func=yes"
14076 else
14077   echo "configure: failed program was:" >&5
14078   cat conftest.$ac_ext >&5
14079   rm -rf conftest*
14080   eval "ac_cv_func_$ac_func=no"
14081 fi
14082 rm -f conftest*
14083 fi
14084
14085 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14086   echo "$ac_t""yes" 1>&6
14087     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14088   cat >> confdefs.h <<EOF
14089 #define $ac_tr_func 1
14090 EOF
14091
14092 else
14093   echo "$ac_t""no" 1>&6
14094 fi
14095 done
14096
14097   fi
14098
14099
14100
14101   ac_ext=C
14102 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14103 ac_cpp='$CXXCPP $CPPFLAGS'
14104 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14105 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14106 cross_compiling=$ac_cv_prog_cxx_cross
14107
14108   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
14109 echo "configure:14110: checking for _floorl declaration" >&5
14110   cat > conftest.$ac_ext <<EOF
14111 #line 14112 "configure"
14112 #include "confdefs.h"
14113 #include <math.h>
14114 int main() {
14115  _floorl(0);
14116 ; return 0; }
14117 EOF
14118 if { (eval echo configure:14119: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14119   rm -rf conftest*
14120   use__floorl=yes
14121 else
14122   echo "configure: failed program was:" >&5
14123   cat conftest.$ac_ext >&5
14124   rm -rf conftest*
14125   use__floorl=no
14126 fi
14127 rm -f conftest*
14128   echo "$ac_t""$use__floorl" 1>&6
14129   ac_ext=c
14130 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14131 ac_cpp='$CPP $CPPFLAGS'
14132 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14133 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14134 cross_compiling=$ac_cv_prog_cc_cross
14135
14136   if test x$use__floorl = x"yes"; then
14137     for ac_func in _floorl
14138 do
14139 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14140 echo "configure:14141: checking for $ac_func" >&5
14141 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14142   echo $ac_n "(cached) $ac_c" 1>&6
14143 else
14144   cat > conftest.$ac_ext <<EOF
14145 #line 14146 "configure"
14146 #include "confdefs.h"
14147 /* System header to define __stub macros and hopefully few prototypes,
14148     which can conflict with char $ac_func(); below.  */
14149 #include <assert.h>
14150 /* Override any gcc2 internal prototype to avoid an error.  */
14151 /* We use char because int might match the return type of a gcc2
14152     builtin and then its argument prototype would still apply.  */
14153 char $ac_func();
14154
14155 int main() {
14156
14157 /* The GNU C library defines this for functions which it implements
14158     to always fail with ENOSYS.  Some functions are actually named
14159     something starting with __ and the normal name is an alias.  */
14160 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14161 choke me
14162 #else
14163 $ac_func();
14164 #endif
14165
14166 ; return 0; }
14167 EOF
14168 if { (eval echo configure:14169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14169   rm -rf conftest*
14170   eval "ac_cv_func_$ac_func=yes"
14171 else
14172   echo "configure: failed program was:" >&5
14173   cat conftest.$ac_ext >&5
14174   rm -rf conftest*
14175   eval "ac_cv_func_$ac_func=no"
14176 fi
14177 rm -f conftest*
14178 fi
14179
14180 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14181   echo "$ac_t""yes" 1>&6
14182     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14183   cat >> confdefs.h <<EOF
14184 #define $ac_tr_func 1
14185 EOF
14186
14187 else
14188   echo "$ac_t""no" 1>&6
14189 fi
14190 done
14191
14192   fi
14193
14194
14195
14196   ac_ext=C
14197 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14198 ac_cpp='$CXXCPP $CPPFLAGS'
14199 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14200 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14201 cross_compiling=$ac_cv_prog_cxx_cross
14202
14203   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
14204 echo "configure:14205: checking for _fmodl declaration" >&5
14205   cat > conftest.$ac_ext <<EOF
14206 #line 14207 "configure"
14207 #include "confdefs.h"
14208 #include <math.h>
14209 int main() {
14210  _fmodl(0, 0);
14211 ; return 0; }
14212 EOF
14213 if { (eval echo configure:14214: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14214   rm -rf conftest*
14215   use__fmodl=yes
14216 else
14217   echo "configure: failed program was:" >&5
14218   cat conftest.$ac_ext >&5
14219   rm -rf conftest*
14220   use__fmodl=no
14221 fi
14222 rm -f conftest*
14223   echo "$ac_t""$use__fmodl" 1>&6
14224   ac_ext=c
14225 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14226 ac_cpp='$CPP $CPPFLAGS'
14227 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14228 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14229 cross_compiling=$ac_cv_prog_cc_cross
14230
14231   if test x$use__fmodl = x"yes"; then
14232     for ac_func in _fmodl
14233 do
14234 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14235 echo "configure:14236: checking for $ac_func" >&5
14236 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14237   echo $ac_n "(cached) $ac_c" 1>&6
14238 else
14239   cat > conftest.$ac_ext <<EOF
14240 #line 14241 "configure"
14241 #include "confdefs.h"
14242 /* System header to define __stub macros and hopefully few prototypes,
14243     which can conflict with char $ac_func(); below.  */
14244 #include <assert.h>
14245 /* Override any gcc2 internal prototype to avoid an error.  */
14246 /* We use char because int might match the return type of a gcc2
14247     builtin and then its argument prototype would still apply.  */
14248 char $ac_func();
14249
14250 int main() {
14251
14252 /* The GNU C library defines this for functions which it implements
14253     to always fail with ENOSYS.  Some functions are actually named
14254     something starting with __ and the normal name is an alias.  */
14255 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14256 choke me
14257 #else
14258 $ac_func();
14259 #endif
14260
14261 ; return 0; }
14262 EOF
14263 if { (eval echo configure:14264: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14264   rm -rf conftest*
14265   eval "ac_cv_func_$ac_func=yes"
14266 else
14267   echo "configure: failed program was:" >&5
14268   cat conftest.$ac_ext >&5
14269   rm -rf conftest*
14270   eval "ac_cv_func_$ac_func=no"
14271 fi
14272 rm -f conftest*
14273 fi
14274
14275 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14276   echo "$ac_t""yes" 1>&6
14277     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14278   cat >> confdefs.h <<EOF
14279 #define $ac_tr_func 1
14280 EOF
14281
14282 else
14283   echo "$ac_t""no" 1>&6
14284 fi
14285 done
14286
14287   fi
14288
14289
14290
14291   ac_ext=C
14292 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14293 ac_cpp='$CXXCPP $CPPFLAGS'
14294 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14295 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14296 cross_compiling=$ac_cv_prog_cxx_cross
14297
14298   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
14299 echo "configure:14300: checking for _frexpl declaration" >&5
14300   cat > conftest.$ac_ext <<EOF
14301 #line 14302 "configure"
14302 #include "confdefs.h"
14303 #include <math.h>
14304 int main() {
14305  _frexpl(0, 0);
14306 ; return 0; }
14307 EOF
14308 if { (eval echo configure:14309: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14309   rm -rf conftest*
14310   use__frexpl=yes
14311 else
14312   echo "configure: failed program was:" >&5
14313   cat conftest.$ac_ext >&5
14314   rm -rf conftest*
14315   use__frexpl=no
14316 fi
14317 rm -f conftest*
14318   echo "$ac_t""$use__frexpl" 1>&6
14319   ac_ext=c
14320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14321 ac_cpp='$CPP $CPPFLAGS'
14322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14324 cross_compiling=$ac_cv_prog_cc_cross
14325
14326   if test x$use__frexpl = x"yes"; then
14327     for ac_func in _frexpl
14328 do
14329 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14330 echo "configure:14331: checking for $ac_func" >&5
14331 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14332   echo $ac_n "(cached) $ac_c" 1>&6
14333 else
14334   cat > conftest.$ac_ext <<EOF
14335 #line 14336 "configure"
14336 #include "confdefs.h"
14337 /* System header to define __stub macros and hopefully few prototypes,
14338     which can conflict with char $ac_func(); below.  */
14339 #include <assert.h>
14340 /* Override any gcc2 internal prototype to avoid an error.  */
14341 /* We use char because int might match the return type of a gcc2
14342     builtin and then its argument prototype would still apply.  */
14343 char $ac_func();
14344
14345 int main() {
14346
14347 /* The GNU C library defines this for functions which it implements
14348     to always fail with ENOSYS.  Some functions are actually named
14349     something starting with __ and the normal name is an alias.  */
14350 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14351 choke me
14352 #else
14353 $ac_func();
14354 #endif
14355
14356 ; return 0; }
14357 EOF
14358 if { (eval echo configure:14359: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14359   rm -rf conftest*
14360   eval "ac_cv_func_$ac_func=yes"
14361 else
14362   echo "configure: failed program was:" >&5
14363   cat conftest.$ac_ext >&5
14364   rm -rf conftest*
14365   eval "ac_cv_func_$ac_func=no"
14366 fi
14367 rm -f conftest*
14368 fi
14369
14370 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14371   echo "$ac_t""yes" 1>&6
14372     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14373   cat >> confdefs.h <<EOF
14374 #define $ac_tr_func 1
14375 EOF
14376
14377 else
14378   echo "$ac_t""no" 1>&6
14379 fi
14380 done
14381
14382   fi
14383
14384
14385
14386   ac_ext=C
14387 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14388 ac_cpp='$CXXCPP $CPPFLAGS'
14389 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14390 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14391 cross_compiling=$ac_cv_prog_cxx_cross
14392
14393   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
14394 echo "configure:14395: checking for _ldexpl declaration" >&5
14395   cat > conftest.$ac_ext <<EOF
14396 #line 14397 "configure"
14397 #include "confdefs.h"
14398 #include <math.h>
14399 int main() {
14400  _ldexpl(0, 0);
14401 ; return 0; }
14402 EOF
14403 if { (eval echo configure:14404: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14404   rm -rf conftest*
14405   use__ldexpl=yes
14406 else
14407   echo "configure: failed program was:" >&5
14408   cat conftest.$ac_ext >&5
14409   rm -rf conftest*
14410   use__ldexpl=no
14411 fi
14412 rm -f conftest*
14413   echo "$ac_t""$use__ldexpl" 1>&6
14414   ac_ext=c
14415 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14416 ac_cpp='$CPP $CPPFLAGS'
14417 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14418 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14419 cross_compiling=$ac_cv_prog_cc_cross
14420
14421   if test x$use__ldexpl = x"yes"; then
14422     for ac_func in _ldexpl
14423 do
14424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14425 echo "configure:14426: checking for $ac_func" >&5
14426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14427   echo $ac_n "(cached) $ac_c" 1>&6
14428 else
14429   cat > conftest.$ac_ext <<EOF
14430 #line 14431 "configure"
14431 #include "confdefs.h"
14432 /* System header to define __stub macros and hopefully few prototypes,
14433     which can conflict with char $ac_func(); below.  */
14434 #include <assert.h>
14435 /* Override any gcc2 internal prototype to avoid an error.  */
14436 /* We use char because int might match the return type of a gcc2
14437     builtin and then its argument prototype would still apply.  */
14438 char $ac_func();
14439
14440 int main() {
14441
14442 /* The GNU C library defines this for functions which it implements
14443     to always fail with ENOSYS.  Some functions are actually named
14444     something starting with __ and the normal name is an alias.  */
14445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14446 choke me
14447 #else
14448 $ac_func();
14449 #endif
14450
14451 ; return 0; }
14452 EOF
14453 if { (eval echo configure:14454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14454   rm -rf conftest*
14455   eval "ac_cv_func_$ac_func=yes"
14456 else
14457   echo "configure: failed program was:" >&5
14458   cat conftest.$ac_ext >&5
14459   rm -rf conftest*
14460   eval "ac_cv_func_$ac_func=no"
14461 fi
14462 rm -f conftest*
14463 fi
14464
14465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14466   echo "$ac_t""yes" 1>&6
14467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14468   cat >> confdefs.h <<EOF
14469 #define $ac_tr_func 1
14470 EOF
14471
14472 else
14473   echo "$ac_t""no" 1>&6
14474 fi
14475 done
14476
14477   fi
14478
14479
14480
14481   ac_ext=C
14482 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14483 ac_cpp='$CXXCPP $CPPFLAGS'
14484 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14485 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14486 cross_compiling=$ac_cv_prog_cxx_cross
14487
14488   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
14489 echo "configure:14490: checking for _logl declaration" >&5
14490   cat > conftest.$ac_ext <<EOF
14491 #line 14492 "configure"
14492 #include "confdefs.h"
14493 #include <math.h>
14494 int main() {
14495  _logl(0);
14496 ; return 0; }
14497 EOF
14498 if { (eval echo configure:14499: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14499   rm -rf conftest*
14500   use__logl=yes
14501 else
14502   echo "configure: failed program was:" >&5
14503   cat conftest.$ac_ext >&5
14504   rm -rf conftest*
14505   use__logl=no
14506 fi
14507 rm -f conftest*
14508   echo "$ac_t""$use__logl" 1>&6
14509   ac_ext=c
14510 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14511 ac_cpp='$CPP $CPPFLAGS'
14512 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14513 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14514 cross_compiling=$ac_cv_prog_cc_cross
14515
14516   if test x$use__logl = x"yes"; then
14517     for ac_func in _logl
14518 do
14519 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14520 echo "configure:14521: checking for $ac_func" >&5
14521 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14522   echo $ac_n "(cached) $ac_c" 1>&6
14523 else
14524   cat > conftest.$ac_ext <<EOF
14525 #line 14526 "configure"
14526 #include "confdefs.h"
14527 /* System header to define __stub macros and hopefully few prototypes,
14528     which can conflict with char $ac_func(); below.  */
14529 #include <assert.h>
14530 /* Override any gcc2 internal prototype to avoid an error.  */
14531 /* We use char because int might match the return type of a gcc2
14532     builtin and then its argument prototype would still apply.  */
14533 char $ac_func();
14534
14535 int main() {
14536
14537 /* The GNU C library defines this for functions which it implements
14538     to always fail with ENOSYS.  Some functions are actually named
14539     something starting with __ and the normal name is an alias.  */
14540 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14541 choke me
14542 #else
14543 $ac_func();
14544 #endif
14545
14546 ; return 0; }
14547 EOF
14548 if { (eval echo configure:14549: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14549   rm -rf conftest*
14550   eval "ac_cv_func_$ac_func=yes"
14551 else
14552   echo "configure: failed program was:" >&5
14553   cat conftest.$ac_ext >&5
14554   rm -rf conftest*
14555   eval "ac_cv_func_$ac_func=no"
14556 fi
14557 rm -f conftest*
14558 fi
14559
14560 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14561   echo "$ac_t""yes" 1>&6
14562     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14563   cat >> confdefs.h <<EOF
14564 #define $ac_tr_func 1
14565 EOF
14566
14567 else
14568   echo "$ac_t""no" 1>&6
14569 fi
14570 done
14571
14572   fi
14573
14574
14575
14576   ac_ext=C
14577 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14578 ac_cpp='$CXXCPP $CPPFLAGS'
14579 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14580 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14581 cross_compiling=$ac_cv_prog_cxx_cross
14582
14583   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
14584 echo "configure:14585: checking for _log10l declaration" >&5
14585   cat > conftest.$ac_ext <<EOF
14586 #line 14587 "configure"
14587 #include "confdefs.h"
14588 #include <math.h>
14589 int main() {
14590  _log10l(0);
14591 ; return 0; }
14592 EOF
14593 if { (eval echo configure:14594: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14594   rm -rf conftest*
14595   use__log10l=yes
14596 else
14597   echo "configure: failed program was:" >&5
14598   cat conftest.$ac_ext >&5
14599   rm -rf conftest*
14600   use__log10l=no
14601 fi
14602 rm -f conftest*
14603   echo "$ac_t""$use__log10l" 1>&6
14604   ac_ext=c
14605 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14606 ac_cpp='$CPP $CPPFLAGS'
14607 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14608 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14609 cross_compiling=$ac_cv_prog_cc_cross
14610
14611   if test x$use__log10l = x"yes"; then
14612     for ac_func in _log10l
14613 do
14614 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14615 echo "configure:14616: checking for $ac_func" >&5
14616 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14617   echo $ac_n "(cached) $ac_c" 1>&6
14618 else
14619   cat > conftest.$ac_ext <<EOF
14620 #line 14621 "configure"
14621 #include "confdefs.h"
14622 /* System header to define __stub macros and hopefully few prototypes,
14623     which can conflict with char $ac_func(); below.  */
14624 #include <assert.h>
14625 /* Override any gcc2 internal prototype to avoid an error.  */
14626 /* We use char because int might match the return type of a gcc2
14627     builtin and then its argument prototype would still apply.  */
14628 char $ac_func();
14629
14630 int main() {
14631
14632 /* The GNU C library defines this for functions which it implements
14633     to always fail with ENOSYS.  Some functions are actually named
14634     something starting with __ and the normal name is an alias.  */
14635 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14636 choke me
14637 #else
14638 $ac_func();
14639 #endif
14640
14641 ; return 0; }
14642 EOF
14643 if { (eval echo configure:14644: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14644   rm -rf conftest*
14645   eval "ac_cv_func_$ac_func=yes"
14646 else
14647   echo "configure: failed program was:" >&5
14648   cat conftest.$ac_ext >&5
14649   rm -rf conftest*
14650   eval "ac_cv_func_$ac_func=no"
14651 fi
14652 rm -f conftest*
14653 fi
14654
14655 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14656   echo "$ac_t""yes" 1>&6
14657     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14658   cat >> confdefs.h <<EOF
14659 #define $ac_tr_func 1
14660 EOF
14661
14662 else
14663   echo "$ac_t""no" 1>&6
14664 fi
14665 done
14666
14667   fi
14668
14669
14670
14671   ac_ext=C
14672 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14673 ac_cpp='$CXXCPP $CPPFLAGS'
14674 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14675 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14676 cross_compiling=$ac_cv_prog_cxx_cross
14677
14678   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
14679 echo "configure:14680: checking for _modfl declaration" >&5
14680   cat > conftest.$ac_ext <<EOF
14681 #line 14682 "configure"
14682 #include "confdefs.h"
14683 #include <math.h>
14684 int main() {
14685  _modfl(0, 0);
14686 ; return 0; }
14687 EOF
14688 if { (eval echo configure:14689: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14689   rm -rf conftest*
14690   use__modfl=yes
14691 else
14692   echo "configure: failed program was:" >&5
14693   cat conftest.$ac_ext >&5
14694   rm -rf conftest*
14695   use__modfl=no
14696 fi
14697 rm -f conftest*
14698   echo "$ac_t""$use__modfl" 1>&6
14699   ac_ext=c
14700 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14701 ac_cpp='$CPP $CPPFLAGS'
14702 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14703 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14704 cross_compiling=$ac_cv_prog_cc_cross
14705
14706   if test x$use__modfl = x"yes"; then
14707     for ac_func in _modfl
14708 do
14709 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14710 echo "configure:14711: checking for $ac_func" >&5
14711 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14712   echo $ac_n "(cached) $ac_c" 1>&6
14713 else
14714   cat > conftest.$ac_ext <<EOF
14715 #line 14716 "configure"
14716 #include "confdefs.h"
14717 /* System header to define __stub macros and hopefully few prototypes,
14718     which can conflict with char $ac_func(); below.  */
14719 #include <assert.h>
14720 /* Override any gcc2 internal prototype to avoid an error.  */
14721 /* We use char because int might match the return type of a gcc2
14722     builtin and then its argument prototype would still apply.  */
14723 char $ac_func();
14724
14725 int main() {
14726
14727 /* The GNU C library defines this for functions which it implements
14728     to always fail with ENOSYS.  Some functions are actually named
14729     something starting with __ and the normal name is an alias.  */
14730 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14731 choke me
14732 #else
14733 $ac_func();
14734 #endif
14735
14736 ; return 0; }
14737 EOF
14738 if { (eval echo configure:14739: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14739   rm -rf conftest*
14740   eval "ac_cv_func_$ac_func=yes"
14741 else
14742   echo "configure: failed program was:" >&5
14743   cat conftest.$ac_ext >&5
14744   rm -rf conftest*
14745   eval "ac_cv_func_$ac_func=no"
14746 fi
14747 rm -f conftest*
14748 fi
14749
14750 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14751   echo "$ac_t""yes" 1>&6
14752     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14753   cat >> confdefs.h <<EOF
14754 #define $ac_tr_func 1
14755 EOF
14756
14757 else
14758   echo "$ac_t""no" 1>&6
14759 fi
14760 done
14761
14762   fi
14763
14764
14765
14766   ac_ext=C
14767 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14768 ac_cpp='$CXXCPP $CPPFLAGS'
14769 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14770 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14771 cross_compiling=$ac_cv_prog_cxx_cross
14772
14773   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
14774 echo "configure:14775: checking for _powl declaration" >&5
14775   cat > conftest.$ac_ext <<EOF
14776 #line 14777 "configure"
14777 #include "confdefs.h"
14778 #include <math.h>
14779 int main() {
14780  _powl(0, 0);
14781 ; return 0; }
14782 EOF
14783 if { (eval echo configure:14784: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14784   rm -rf conftest*
14785   use__powl=yes
14786 else
14787   echo "configure: failed program was:" >&5
14788   cat conftest.$ac_ext >&5
14789   rm -rf conftest*
14790   use__powl=no
14791 fi
14792 rm -f conftest*
14793   echo "$ac_t""$use__powl" 1>&6
14794   ac_ext=c
14795 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14796 ac_cpp='$CPP $CPPFLAGS'
14797 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14798 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14799 cross_compiling=$ac_cv_prog_cc_cross
14800
14801   if test x$use__powl = x"yes"; then
14802     for ac_func in _powl
14803 do
14804 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14805 echo "configure:14806: checking for $ac_func" >&5
14806 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14807   echo $ac_n "(cached) $ac_c" 1>&6
14808 else
14809   cat > conftest.$ac_ext <<EOF
14810 #line 14811 "configure"
14811 #include "confdefs.h"
14812 /* System header to define __stub macros and hopefully few prototypes,
14813     which can conflict with char $ac_func(); below.  */
14814 #include <assert.h>
14815 /* Override any gcc2 internal prototype to avoid an error.  */
14816 /* We use char because int might match the return type of a gcc2
14817     builtin and then its argument prototype would still apply.  */
14818 char $ac_func();
14819
14820 int main() {
14821
14822 /* The GNU C library defines this for functions which it implements
14823     to always fail with ENOSYS.  Some functions are actually named
14824     something starting with __ and the normal name is an alias.  */
14825 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14826 choke me
14827 #else
14828 $ac_func();
14829 #endif
14830
14831 ; return 0; }
14832 EOF
14833 if { (eval echo configure:14834: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14834   rm -rf conftest*
14835   eval "ac_cv_func_$ac_func=yes"
14836 else
14837   echo "configure: failed program was:" >&5
14838   cat conftest.$ac_ext >&5
14839   rm -rf conftest*
14840   eval "ac_cv_func_$ac_func=no"
14841 fi
14842 rm -f conftest*
14843 fi
14844
14845 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14846   echo "$ac_t""yes" 1>&6
14847     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14848   cat >> confdefs.h <<EOF
14849 #define $ac_tr_func 1
14850 EOF
14851
14852 else
14853   echo "$ac_t""no" 1>&6
14854 fi
14855 done
14856
14857   fi
14858
14859
14860
14861   ac_ext=C
14862 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14863 ac_cpp='$CXXCPP $CPPFLAGS'
14864 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14865 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14866 cross_compiling=$ac_cv_prog_cxx_cross
14867
14868   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
14869 echo "configure:14870: checking for _sinl declaration" >&5
14870   cat > conftest.$ac_ext <<EOF
14871 #line 14872 "configure"
14872 #include "confdefs.h"
14873 #include <math.h>
14874 int main() {
14875  _sinl(0);
14876 ; return 0; }
14877 EOF
14878 if { (eval echo configure:14879: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14879   rm -rf conftest*
14880   use__sinl=yes
14881 else
14882   echo "configure: failed program was:" >&5
14883   cat conftest.$ac_ext >&5
14884   rm -rf conftest*
14885   use__sinl=no
14886 fi
14887 rm -f conftest*
14888   echo "$ac_t""$use__sinl" 1>&6
14889   ac_ext=c
14890 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14891 ac_cpp='$CPP $CPPFLAGS'
14892 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14893 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14894 cross_compiling=$ac_cv_prog_cc_cross
14895
14896   if test x$use__sinl = x"yes"; then
14897     for ac_func in _sinl
14898 do
14899 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14900 echo "configure:14901: checking for $ac_func" >&5
14901 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14902   echo $ac_n "(cached) $ac_c" 1>&6
14903 else
14904   cat > conftest.$ac_ext <<EOF
14905 #line 14906 "configure"
14906 #include "confdefs.h"
14907 /* System header to define __stub macros and hopefully few prototypes,
14908     which can conflict with char $ac_func(); below.  */
14909 #include <assert.h>
14910 /* Override any gcc2 internal prototype to avoid an error.  */
14911 /* We use char because int might match the return type of a gcc2
14912     builtin and then its argument prototype would still apply.  */
14913 char $ac_func();
14914
14915 int main() {
14916
14917 /* The GNU C library defines this for functions which it implements
14918     to always fail with ENOSYS.  Some functions are actually named
14919     something starting with __ and the normal name is an alias.  */
14920 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14921 choke me
14922 #else
14923 $ac_func();
14924 #endif
14925
14926 ; return 0; }
14927 EOF
14928 if { (eval echo configure:14929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14929   rm -rf conftest*
14930   eval "ac_cv_func_$ac_func=yes"
14931 else
14932   echo "configure: failed program was:" >&5
14933   cat conftest.$ac_ext >&5
14934   rm -rf conftest*
14935   eval "ac_cv_func_$ac_func=no"
14936 fi
14937 rm -f conftest*
14938 fi
14939
14940 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14941   echo "$ac_t""yes" 1>&6
14942     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14943   cat >> confdefs.h <<EOF
14944 #define $ac_tr_func 1
14945 EOF
14946
14947 else
14948   echo "$ac_t""no" 1>&6
14949 fi
14950 done
14951
14952   fi
14953
14954
14955
14956   ac_ext=C
14957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14958 ac_cpp='$CXXCPP $CPPFLAGS'
14959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14961 cross_compiling=$ac_cv_prog_cxx_cross
14962
14963   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
14964 echo "configure:14965: checking for _sinhl declaration" >&5
14965   cat > conftest.$ac_ext <<EOF
14966 #line 14967 "configure"
14967 #include "confdefs.h"
14968 #include <math.h>
14969 int main() {
14970  _sinhl(0);
14971 ; return 0; }
14972 EOF
14973 if { (eval echo configure:14974: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14974   rm -rf conftest*
14975   use__sinhl=yes
14976 else
14977   echo "configure: failed program was:" >&5
14978   cat conftest.$ac_ext >&5
14979   rm -rf conftest*
14980   use__sinhl=no
14981 fi
14982 rm -f conftest*
14983   echo "$ac_t""$use__sinhl" 1>&6
14984   ac_ext=c
14985 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14986 ac_cpp='$CPP $CPPFLAGS'
14987 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14988 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14989 cross_compiling=$ac_cv_prog_cc_cross
14990
14991   if test x$use__sinhl = x"yes"; then
14992     for ac_func in _sinhl
14993 do
14994 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14995 echo "configure:14996: checking for $ac_func" >&5
14996 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14997   echo $ac_n "(cached) $ac_c" 1>&6
14998 else
14999   cat > conftest.$ac_ext <<EOF
15000 #line 15001 "configure"
15001 #include "confdefs.h"
15002 /* System header to define __stub macros and hopefully few prototypes,
15003     which can conflict with char $ac_func(); below.  */
15004 #include <assert.h>
15005 /* Override any gcc2 internal prototype to avoid an error.  */
15006 /* We use char because int might match the return type of a gcc2
15007     builtin and then its argument prototype would still apply.  */
15008 char $ac_func();
15009
15010 int main() {
15011
15012 /* The GNU C library defines this for functions which it implements
15013     to always fail with ENOSYS.  Some functions are actually named
15014     something starting with __ and the normal name is an alias.  */
15015 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15016 choke me
15017 #else
15018 $ac_func();
15019 #endif
15020
15021 ; return 0; }
15022 EOF
15023 if { (eval echo configure:15024: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15024   rm -rf conftest*
15025   eval "ac_cv_func_$ac_func=yes"
15026 else
15027   echo "configure: failed program was:" >&5
15028   cat conftest.$ac_ext >&5
15029   rm -rf conftest*
15030   eval "ac_cv_func_$ac_func=no"
15031 fi
15032 rm -f conftest*
15033 fi
15034
15035 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15036   echo "$ac_t""yes" 1>&6
15037     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15038   cat >> confdefs.h <<EOF
15039 #define $ac_tr_func 1
15040 EOF
15041
15042 else
15043   echo "$ac_t""no" 1>&6
15044 fi
15045 done
15046
15047   fi
15048
15049
15050
15051   ac_ext=C
15052 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15053 ac_cpp='$CXXCPP $CPPFLAGS'
15054 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15055 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15056 cross_compiling=$ac_cv_prog_cxx_cross
15057
15058   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
15059 echo "configure:15060: checking for _sqrtl declaration" >&5
15060   cat > conftest.$ac_ext <<EOF
15061 #line 15062 "configure"
15062 #include "confdefs.h"
15063 #include <math.h>
15064 int main() {
15065  _sqrtl(0);
15066 ; return 0; }
15067 EOF
15068 if { (eval echo configure:15069: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15069   rm -rf conftest*
15070   use__sqrtl=yes
15071 else
15072   echo "configure: failed program was:" >&5
15073   cat conftest.$ac_ext >&5
15074   rm -rf conftest*
15075   use__sqrtl=no
15076 fi
15077 rm -f conftest*
15078   echo "$ac_t""$use__sqrtl" 1>&6
15079   ac_ext=c
15080 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15081 ac_cpp='$CPP $CPPFLAGS'
15082 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15083 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15084 cross_compiling=$ac_cv_prog_cc_cross
15085
15086   if test x$use__sqrtl = x"yes"; then
15087     for ac_func in _sqrtl
15088 do
15089 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15090 echo "configure:15091: checking for $ac_func" >&5
15091 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15092   echo $ac_n "(cached) $ac_c" 1>&6
15093 else
15094   cat > conftest.$ac_ext <<EOF
15095 #line 15096 "configure"
15096 #include "confdefs.h"
15097 /* System header to define __stub macros and hopefully few prototypes,
15098     which can conflict with char $ac_func(); below.  */
15099 #include <assert.h>
15100 /* Override any gcc2 internal prototype to avoid an error.  */
15101 /* We use char because int might match the return type of a gcc2
15102     builtin and then its argument prototype would still apply.  */
15103 char $ac_func();
15104
15105 int main() {
15106
15107 /* The GNU C library defines this for functions which it implements
15108     to always fail with ENOSYS.  Some functions are actually named
15109     something starting with __ and the normal name is an alias.  */
15110 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15111 choke me
15112 #else
15113 $ac_func();
15114 #endif
15115
15116 ; return 0; }
15117 EOF
15118 if { (eval echo configure:15119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15119   rm -rf conftest*
15120   eval "ac_cv_func_$ac_func=yes"
15121 else
15122   echo "configure: failed program was:" >&5
15123   cat conftest.$ac_ext >&5
15124   rm -rf conftest*
15125   eval "ac_cv_func_$ac_func=no"
15126 fi
15127 rm -f conftest*
15128 fi
15129
15130 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15131   echo "$ac_t""yes" 1>&6
15132     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15133   cat >> confdefs.h <<EOF
15134 #define $ac_tr_func 1
15135 EOF
15136
15137 else
15138   echo "$ac_t""no" 1>&6
15139 fi
15140 done
15141
15142   fi
15143
15144
15145
15146   ac_ext=C
15147 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15148 ac_cpp='$CXXCPP $CPPFLAGS'
15149 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15150 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15151 cross_compiling=$ac_cv_prog_cxx_cross
15152
15153   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
15154 echo "configure:15155: checking for _tanl declaration" >&5
15155   cat > conftest.$ac_ext <<EOF
15156 #line 15157 "configure"
15157 #include "confdefs.h"
15158 #include <math.h>
15159 int main() {
15160  _tanl(0);
15161 ; return 0; }
15162 EOF
15163 if { (eval echo configure:15164: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15164   rm -rf conftest*
15165   use__tanl=yes
15166 else
15167   echo "configure: failed program was:" >&5
15168   cat conftest.$ac_ext >&5
15169   rm -rf conftest*
15170   use__tanl=no
15171 fi
15172 rm -f conftest*
15173   echo "$ac_t""$use__tanl" 1>&6
15174   ac_ext=c
15175 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15176 ac_cpp='$CPP $CPPFLAGS'
15177 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15178 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15179 cross_compiling=$ac_cv_prog_cc_cross
15180
15181   if test x$use__tanl = x"yes"; then
15182     for ac_func in _tanl
15183 do
15184 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15185 echo "configure:15186: checking for $ac_func" >&5
15186 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15187   echo $ac_n "(cached) $ac_c" 1>&6
15188 else
15189   cat > conftest.$ac_ext <<EOF
15190 #line 15191 "configure"
15191 #include "confdefs.h"
15192 /* System header to define __stub macros and hopefully few prototypes,
15193     which can conflict with char $ac_func(); below.  */
15194 #include <assert.h>
15195 /* Override any gcc2 internal prototype to avoid an error.  */
15196 /* We use char because int might match the return type of a gcc2
15197     builtin and then its argument prototype would still apply.  */
15198 char $ac_func();
15199
15200 int main() {
15201
15202 /* The GNU C library defines this for functions which it implements
15203     to always fail with ENOSYS.  Some functions are actually named
15204     something starting with __ and the normal name is an alias.  */
15205 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15206 choke me
15207 #else
15208 $ac_func();
15209 #endif
15210
15211 ; return 0; }
15212 EOF
15213 if { (eval echo configure:15214: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15214   rm -rf conftest*
15215   eval "ac_cv_func_$ac_func=yes"
15216 else
15217   echo "configure: failed program was:" >&5
15218   cat conftest.$ac_ext >&5
15219   rm -rf conftest*
15220   eval "ac_cv_func_$ac_func=no"
15221 fi
15222 rm -f conftest*
15223 fi
15224
15225 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15226   echo "$ac_t""yes" 1>&6
15227     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15228   cat >> confdefs.h <<EOF
15229 #define $ac_tr_func 1
15230 EOF
15231
15232 else
15233   echo "$ac_t""no" 1>&6
15234 fi
15235 done
15236
15237   fi
15238
15239
15240
15241   ac_ext=C
15242 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15243 ac_cpp='$CXXCPP $CPPFLAGS'
15244 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15245 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15246 cross_compiling=$ac_cv_prog_cxx_cross
15247
15248   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
15249 echo "configure:15250: checking for _tanhl declaration" >&5
15250   cat > conftest.$ac_ext <<EOF
15251 #line 15252 "configure"
15252 #include "confdefs.h"
15253 #include <math.h>
15254 int main() {
15255  _tanhl(0);
15256 ; return 0; }
15257 EOF
15258 if { (eval echo configure:15259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15259   rm -rf conftest*
15260   use__tanhl=yes
15261 else
15262   echo "configure: failed program was:" >&5
15263   cat conftest.$ac_ext >&5
15264   rm -rf conftest*
15265   use__tanhl=no
15266 fi
15267 rm -f conftest*
15268   echo "$ac_t""$use__tanhl" 1>&6
15269   ac_ext=c
15270 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15271 ac_cpp='$CPP $CPPFLAGS'
15272 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15273 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15274 cross_compiling=$ac_cv_prog_cc_cross
15275
15276   if test x$use__tanhl = x"yes"; then
15277     for ac_func in _tanhl
15278 do
15279 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15280 echo "configure:15281: checking for $ac_func" >&5
15281 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15282   echo $ac_n "(cached) $ac_c" 1>&6
15283 else
15284   cat > conftest.$ac_ext <<EOF
15285 #line 15286 "configure"
15286 #include "confdefs.h"
15287 /* System header to define __stub macros and hopefully few prototypes,
15288     which can conflict with char $ac_func(); below.  */
15289 #include <assert.h>
15290 /* Override any gcc2 internal prototype to avoid an error.  */
15291 /* We use char because int might match the return type of a gcc2
15292     builtin and then its argument prototype would still apply.  */
15293 char $ac_func();
15294
15295 int main() {
15296
15297 /* The GNU C library defines this for functions which it implements
15298     to always fail with ENOSYS.  Some functions are actually named
15299     something starting with __ and the normal name is an alias.  */
15300 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15301 choke me
15302 #else
15303 $ac_func();
15304 #endif
15305
15306 ; return 0; }
15307 EOF
15308 if { (eval echo configure:15309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15309   rm -rf conftest*
15310   eval "ac_cv_func_$ac_func=yes"
15311 else
15312   echo "configure: failed program was:" >&5
15313   cat conftest.$ac_ext >&5
15314   rm -rf conftest*
15315   eval "ac_cv_func_$ac_func=no"
15316 fi
15317 rm -f conftest*
15318 fi
15319
15320 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15321   echo "$ac_t""yes" 1>&6
15322     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15323   cat >> confdefs.h <<EOF
15324 #define $ac_tr_func 1
15325 EOF
15326
15327 else
15328   echo "$ac_t""no" 1>&6
15329 fi
15330 done
15331
15332   fi
15333
15334
15335
15336   ac_ext=C
15337 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15338 ac_cpp='$CXXCPP $CPPFLAGS'
15339 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15340 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15341 cross_compiling=$ac_cv_prog_cxx_cross
15342
15343   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
15344 echo "configure:15345: checking for _sincosl declaration" >&5
15345   cat > conftest.$ac_ext <<EOF
15346 #line 15347 "configure"
15347 #include "confdefs.h"
15348 #include <math.h>
15349 int main() {
15350  _sincosl(0, 0, 0);
15351 ; return 0; }
15352 EOF
15353 if { (eval echo configure:15354: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15354   rm -rf conftest*
15355   use__sincosl=yes
15356 else
15357   echo "configure: failed program was:" >&5
15358   cat conftest.$ac_ext >&5
15359   rm -rf conftest*
15360   use__sincosl=no
15361 fi
15362 rm -f conftest*
15363   echo "$ac_t""$use__sincosl" 1>&6
15364   ac_ext=c
15365 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15366 ac_cpp='$CPP $CPPFLAGS'
15367 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15368 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15369 cross_compiling=$ac_cv_prog_cc_cross
15370
15371   if test x$use__sincosl = x"yes"; then
15372     for ac_func in _sincosl
15373 do
15374 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15375 echo "configure:15376: checking for $ac_func" >&5
15376 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15377   echo $ac_n "(cached) $ac_c" 1>&6
15378 else
15379   cat > conftest.$ac_ext <<EOF
15380 #line 15381 "configure"
15381 #include "confdefs.h"
15382 /* System header to define __stub macros and hopefully few prototypes,
15383     which can conflict with char $ac_func(); below.  */
15384 #include <assert.h>
15385 /* Override any gcc2 internal prototype to avoid an error.  */
15386 /* We use char because int might match the return type of a gcc2
15387     builtin and then its argument prototype would still apply.  */
15388 char $ac_func();
15389
15390 int main() {
15391
15392 /* The GNU C library defines this for functions which it implements
15393     to always fail with ENOSYS.  Some functions are actually named
15394     something starting with __ and the normal name is an alias.  */
15395 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15396 choke me
15397 #else
15398 $ac_func();
15399 #endif
15400
15401 ; return 0; }
15402 EOF
15403 if { (eval echo configure:15404: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15404   rm -rf conftest*
15405   eval "ac_cv_func_$ac_func=yes"
15406 else
15407   echo "configure: failed program was:" >&5
15408   cat conftest.$ac_ext >&5
15409   rm -rf conftest*
15410   eval "ac_cv_func_$ac_func=no"
15411 fi
15412 rm -f conftest*
15413 fi
15414
15415 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15416   echo "$ac_t""yes" 1>&6
15417     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15418   cat >> confdefs.h <<EOF
15419 #define $ac_tr_func 1
15420 EOF
15421
15422 else
15423   echo "$ac_t""no" 1>&6
15424 fi
15425 done
15426
15427   fi
15428
15429
15430
15431   ac_ext=C
15432 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15433 ac_cpp='$CXXCPP $CPPFLAGS'
15434 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15435 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15436 cross_compiling=$ac_cv_prog_cxx_cross
15437
15438   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
15439 echo "configure:15440: checking for _finitel declaration" >&5
15440   cat > conftest.$ac_ext <<EOF
15441 #line 15442 "configure"
15442 #include "confdefs.h"
15443 #include <math.h>
15444 int main() {
15445  _finitel(0);
15446 ; return 0; }
15447 EOF
15448 if { (eval echo configure:15449: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15449   rm -rf conftest*
15450   use__finitel=yes
15451 else
15452   echo "configure: failed program was:" >&5
15453   cat conftest.$ac_ext >&5
15454   rm -rf conftest*
15455   use__finitel=no
15456 fi
15457 rm -f conftest*
15458   echo "$ac_t""$use__finitel" 1>&6
15459   ac_ext=c
15460 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15461 ac_cpp='$CPP $CPPFLAGS'
15462 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15463 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15464 cross_compiling=$ac_cv_prog_cc_cross
15465
15466   if test x$use__finitel = x"yes"; then
15467     for ac_func in _finitel
15468 do
15469 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15470 echo "configure:15471: checking for $ac_func" >&5
15471 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15472   echo $ac_n "(cached) $ac_c" 1>&6
15473 else
15474   cat > conftest.$ac_ext <<EOF
15475 #line 15476 "configure"
15476 #include "confdefs.h"
15477 /* System header to define __stub macros and hopefully few prototypes,
15478     which can conflict with char $ac_func(); below.  */
15479 #include <assert.h>
15480 /* Override any gcc2 internal prototype to avoid an error.  */
15481 /* We use char because int might match the return type of a gcc2
15482     builtin and then its argument prototype would still apply.  */
15483 char $ac_func();
15484
15485 int main() {
15486
15487 /* The GNU C library defines this for functions which it implements
15488     to always fail with ENOSYS.  Some functions are actually named
15489     something starting with __ and the normal name is an alias.  */
15490 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15491 choke me
15492 #else
15493 $ac_func();
15494 #endif
15495
15496 ; return 0; }
15497 EOF
15498 if { (eval echo configure:15499: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15499   rm -rf conftest*
15500   eval "ac_cv_func_$ac_func=yes"
15501 else
15502   echo "configure: failed program was:" >&5
15503   cat conftest.$ac_ext >&5
15504   rm -rf conftest*
15505   eval "ac_cv_func_$ac_func=no"
15506 fi
15507 rm -f conftest*
15508 fi
15509
15510 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15511   echo "$ac_t""yes" 1>&6
15512     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15513   cat >> confdefs.h <<EOF
15514 #define $ac_tr_func 1
15515 EOF
15516
15517 else
15518   echo "$ac_t""no" 1>&6
15519 fi
15520 done
15521
15522   fi
15523
15524
15525   LIBS="$ac_save_LIBS"
15526   CXXFLAGS="$ac_save_CXXFLAGS"
15527
15528
15529     for ac_hdr in complex.h
15530 do
15531 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
15532 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
15533 echo "configure:15534: checking for $ac_hdr" >&5
15534 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15535   echo $ac_n "(cached) $ac_c" 1>&6
15536 else
15537   cat > conftest.$ac_ext <<EOF
15538 #line 15539 "configure"
15539 #include "confdefs.h"
15540 #include <$ac_hdr>
15541 EOF
15542 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15543 { (eval echo configure:15544: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15544 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15545 if test -z "$ac_err"; then
15546   rm -rf conftest*
15547   eval "ac_cv_header_$ac_safe=yes"
15548 else
15549   echo "$ac_err" >&5
15550   echo "configure: failed program was:" >&5
15551   cat conftest.$ac_ext >&5
15552   rm -rf conftest*
15553   eval "ac_cv_header_$ac_safe=no"
15554 fi
15555 rm -f conftest*
15556 fi
15557 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15558   echo "$ac_t""yes" 1>&6
15559     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
15560   cat >> confdefs.h <<EOF
15561 #define $ac_tr_hdr 1
15562 EOF
15563
15564 else
15565   echo "$ac_t""no" 1>&6
15566 fi
15567 done
15568
15569   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
15570   clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
15571   ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf copysignf
15572 do
15573 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15574 echo "configure:15575: checking for $ac_func" >&5
15575 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15576   echo $ac_n "(cached) $ac_c" 1>&6
15577 else
15578   cat > conftest.$ac_ext <<EOF
15579 #line 15580 "configure"
15580 #include "confdefs.h"
15581 /* System header to define __stub macros and hopefully few prototypes,
15582     which can conflict with char $ac_func(); below.  */
15583 #include <assert.h>
15584 /* Override any gcc2 internal prototype to avoid an error.  */
15585 /* We use char because int might match the return type of a gcc2
15586     builtin and then its argument prototype would still apply.  */
15587 char $ac_func();
15588
15589 int main() {
15590
15591 /* The GNU C library defines this for functions which it implements
15592     to always fail with ENOSYS.  Some functions are actually named
15593     something starting with __ and the normal name is an alias.  */
15594 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15595 choke me
15596 #else
15597 $ac_func();
15598 #endif
15599
15600 ; return 0; }
15601 EOF
15602 if { (eval echo configure:15603: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15603   rm -rf conftest*
15604   eval "ac_cv_func_$ac_func=yes"
15605 else
15606   echo "configure: failed program was:" >&5
15607   cat conftest.$ac_ext >&5
15608   rm -rf conftest*
15609   eval "ac_cv_func_$ac_func=no"
15610 fi
15611 rm -f conftest*
15612 fi
15613
15614 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15615   echo "$ac_t""yes" 1>&6
15616     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15617   cat >> confdefs.h <<EOF
15618 #define $ac_tr_func 1
15619 EOF
15620
15621 else
15622   echo "$ac_t""no" 1>&6
15623 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15624 fi
15625 done
15626
15627
15628
15629           USE_COMPLEX_LONG_DOUBLE=no
15630   if test x$ac_cv_func_atan2l = x"yes" \
15631      && test x$ac_cv_func_copysignl = x"yes"; then
15632     USE_COMPLEX_LONG_DOUBLE=yes
15633     for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
15634     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
15635 do
15636 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15637 echo "configure:15638: checking for $ac_func" >&5
15638 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15639   echo $ac_n "(cached) $ac_c" 1>&6
15640 else
15641   cat > conftest.$ac_ext <<EOF
15642 #line 15643 "configure"
15643 #include "confdefs.h"
15644 /* System header to define __stub macros and hopefully few prototypes,
15645     which can conflict with char $ac_func(); below.  */
15646 #include <assert.h>
15647 /* Override any gcc2 internal prototype to avoid an error.  */
15648 /* We use char because int might match the return type of a gcc2
15649     builtin and then its argument prototype would still apply.  */
15650 char $ac_func();
15651
15652 int main() {
15653
15654 /* The GNU C library defines this for functions which it implements
15655     to always fail with ENOSYS.  Some functions are actually named
15656     something starting with __ and the normal name is an alias.  */
15657 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15658 choke me
15659 #else
15660 $ac_func();
15661 #endif
15662
15663 ; return 0; }
15664 EOF
15665 if { (eval echo configure:15666: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15666   rm -rf conftest*
15667   eval "ac_cv_func_$ac_func=yes"
15668 else
15669   echo "configure: failed program was:" >&5
15670   cat conftest.$ac_ext >&5
15671   rm -rf conftest*
15672   eval "ac_cv_func_$ac_func=no"
15673 fi
15674 rm -f conftest*
15675 fi
15676
15677 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15678   echo "$ac_t""yes" 1>&6
15679     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15680   cat >> confdefs.h <<EOF
15681 #define $ac_tr_func 1
15682 EOF
15683
15684 else
15685   echo "$ac_t""no" 1>&6
15686 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15687 fi
15688 done
15689
15690
15691   fi
15692
15693
15694
15695
15696
15697
15698   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
15699 echo "configure:15700: checking for GNU C++ __complex__ support" >&5
15700   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
15701   echo $ac_n "(cached) $ac_c" 1>&6
15702 else
15703
15704
15705     ac_ext=C
15706 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15707 ac_cpp='$CXXCPP $CPPFLAGS'
15708 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15709 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15710 cross_compiling=$ac_cv_prog_cxx_cross
15711
15712     cat > conftest.$ac_ext <<EOF
15713 #line 15714 "configure"
15714 #include "confdefs.h"
15715 struct dcomplex { __complex__ double x; }; \
15716                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
15717 int main() {
15718 \
15719                      dcomplex x; f(x);
15720 ; return 0; }
15721 EOF
15722 if { (eval echo configure:15723: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15723   rm -rf conftest*
15724   glibcpp_cv_complex=ok
15725 else
15726   echo "configure: failed program was:" >&5
15727   cat conftest.$ac_ext >&5
15728   rm -rf conftest*
15729   glibcpp_cv_complex=buggy
15730
15731 fi
15732 rm -f conftest*
15733     ac_ext=c
15734 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15735 ac_cpp='$CPP $CPPFLAGS'
15736 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15737 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15738 cross_compiling=$ac_cv_prog_cc_cross
15739
15740
15741 fi
15742
15743   echo "$ac_t""$glibcpp_cv_complex" 1>&6
15744   if test $glibcpp_cv_complex = buggy; then
15745     cat >> confdefs.h <<\EOF
15746 #define _GLIBCPP_BUGGY_COMPLEX 1
15747 EOF
15748
15749   fi
15750
15751   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
15752 echo "configure:15753: checking for GNU C++ __complex__ float support" >&5
15753   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
15754   echo $ac_n "(cached) $ac_c" 1>&6
15755 else
15756
15757
15758     ac_ext=C
15759 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15760 ac_cpp='$CXXCPP $CPPFLAGS'
15761 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15762 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15763 cross_compiling=$ac_cv_prog_cxx_cross
15764
15765     rm -f conftest.h
15766     cat > conftest.h <<EOB
15767       //
15768       // Check for buggy __complex__ that causes ICE in most versions of egcs
15769       // and gcc-2.95.x on certain platforms (eg., x86-win32).
15770       //
15771       // See http://egcs.cygnus.com/ml/gcc-bugs/1999-07/msg00845.html for
15772       // more info on the bug itself.
15773       //
15774       struct
15775       float_complex
15776       {
15777        __complex__ float m_value;
15778        float_complex (float = 0.0f, float = 0.0f);
15779        float_complex (__complex__ float val) : m_value (val) {}
15780        float_complex foo (const float_complex &val)
15781          { return float_complex (~val.m_value); }
15782       };
15783 EOB
15784     cat > conftest.$ac_ext <<EOF
15785 #line 15786 "configure"
15786 #include "confdefs.h"
15787 #include "conftest.h"
15788 int main() {
15789
15790 ; return 0; }
15791 EOF
15792 if { (eval echo configure:15793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15793   rm -rf conftest*
15794   glibcpp_cv_float_complex=ok
15795 else
15796   echo "configure: failed program was:" >&5
15797   cat conftest.$ac_ext >&5
15798   rm -rf conftest*
15799   glibcpp_cv_float_complex=buggy
15800
15801 fi
15802 rm -f conftest*
15803     ac_ext=c
15804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15805 ac_cpp='$CPP $CPPFLAGS'
15806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15808 cross_compiling=$ac_cv_prog_cc_cross
15809
15810
15811 fi
15812
15813   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
15814   if test $glibcpp_cv_float_complex = buggy; then
15815     cat >> confdefs.h <<\EOF
15816 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
15817 EOF
15818
15819   fi
15820
15821
15822
15823     ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
15824 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
15825 echo "configure:15826: checking for wchar.h" >&5
15826 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15827   echo $ac_n "(cached) $ac_c" 1>&6
15828 else
15829   cat > conftest.$ac_ext <<EOF
15830 #line 15831 "configure"
15831 #include "confdefs.h"
15832 #include <wchar.h>
15833 EOF
15834 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15835 { (eval echo configure:15836: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15836 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15837 if test -z "$ac_err"; then
15838   rm -rf conftest*
15839   eval "ac_cv_header_$ac_safe=yes"
15840 else
15841   echo "$ac_err" >&5
15842   echo "configure: failed program was:" >&5
15843   cat conftest.$ac_ext >&5
15844   rm -rf conftest*
15845   eval "ac_cv_header_$ac_safe=no"
15846 fi
15847 rm -f conftest*
15848 fi
15849 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15850   echo "$ac_t""yes" 1>&6
15851   ac_has_wchar_h=yes
15852 else
15853   echo "$ac_t""no" 1>&6
15854 ac_has_wchar_h=no
15855 fi
15856
15857   ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
15858 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
15859 echo "configure:15860: checking for wctype.h" >&5
15860 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15861   echo $ac_n "(cached) $ac_c" 1>&6
15862 else
15863   cat > conftest.$ac_ext <<EOF
15864 #line 15865 "configure"
15865 #include "confdefs.h"
15866 #include <wctype.h>
15867 EOF
15868 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15869 { (eval echo configure:15870: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15870 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15871 if test -z "$ac_err"; then
15872   rm -rf conftest*
15873   eval "ac_cv_header_$ac_safe=yes"
15874 else
15875   echo "$ac_err" >&5
15876   echo "configure: failed program was:" >&5
15877   cat conftest.$ac_ext >&5
15878   rm -rf conftest*
15879   eval "ac_cv_header_$ac_safe=no"
15880 fi
15881 rm -f conftest*
15882 fi
15883 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15884   echo "$ac_t""yes" 1>&6
15885   ac_has_wctype_h=yes
15886 else
15887   echo "$ac_t""no" 1>&6
15888 ac_has_wctype_h=no
15889 fi
15890
15891
15892     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
15893
15894         echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
15895 echo "configure:15896: checking for mbstate_t" >&5
15896     cat > conftest.$ac_ext <<EOF
15897 #line 15898 "configure"
15898 #include "confdefs.h"
15899 #include <wchar.h>
15900 int main() {
15901 mbstate_t teststate;
15902 ; return 0; }
15903 EOF
15904 if { (eval echo configure:15905: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15905   rm -rf conftest*
15906   use_native_mbstatet=yes
15907 else
15908   echo "configure: failed program was:" >&5
15909   cat conftest.$ac_ext >&5
15910   rm -rf conftest*
15911   use_native_mbstatet=no
15912 fi
15913 rm -f conftest*
15914     echo "$ac_t""$use_native_mbstatet" 1>&6
15915     if test x"$use_native_mbstatet" = xno; then
15916       cat >> confdefs.h <<\EOF
15917 #define _GLIBCPP_NEED_MBSTATE_T 1
15918 EOF
15919
15920     fi
15921
15922             echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
15923 echo "configure:15924: checking for WCHAR_MIN and WCHAR_MAX" >&5
15924     cat > conftest.$ac_ext <<EOF
15925 #line 15926 "configure"
15926 #include "confdefs.h"
15927 #include <wchar.h>
15928 int main() {
15929 int i = WCHAR_MIN; int j = WCHAR_MAX;
15930 ; return 0; }
15931 EOF
15932 if { (eval echo configure:15933: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15933   rm -rf conftest*
15934   has_wchar_minmax=yes
15935 else
15936   echo "configure: failed program was:" >&5
15937   cat conftest.$ac_ext >&5
15938   rm -rf conftest*
15939   has_wchar_minmax=no
15940 fi
15941 rm -f conftest*
15942     echo "$ac_t""$has_wchar_minmax" 1>&6
15943
15944             echo $ac_n "checking for WEOF""... $ac_c" 1>&6
15945 echo "configure:15946: checking for WEOF" >&5
15946     cat > conftest.$ac_ext <<EOF
15947 #line 15948 "configure"
15948 #include "confdefs.h"
15949
15950       #include <wchar.h>
15951       #include <stddef.h>
15952 int main() {
15953 wint_t i = WEOF;
15954 ; return 0; }
15955 EOF
15956 if { (eval echo configure:15957: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15957   rm -rf conftest*
15958   has_weof=yes
15959 else
15960   echo "configure: failed program was:" >&5
15961   cat conftest.$ac_ext >&5
15962   rm -rf conftest*
15963   has_weof=no
15964 fi
15965 rm -f conftest*
15966     echo "$ac_t""$has_weof" 1>&6
15967
15968         for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset
15969 do
15970 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15971 echo "configure:15972: checking for $ac_func" >&5
15972 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15973   echo $ac_n "(cached) $ac_c" 1>&6
15974 else
15975   cat > conftest.$ac_ext <<EOF
15976 #line 15977 "configure"
15977 #include "confdefs.h"
15978 /* System header to define __stub macros and hopefully few prototypes,
15979     which can conflict with char $ac_func(); below.  */
15980 #include <assert.h>
15981 /* Override any gcc2 internal prototype to avoid an error.  */
15982 /* We use char because int might match the return type of a gcc2
15983     builtin and then its argument prototype would still apply.  */
15984 char $ac_func();
15985
15986 int main() {
15987
15988 /* The GNU C library defines this for functions which it implements
15989     to always fail with ENOSYS.  Some functions are actually named
15990     something starting with __ and the normal name is an alias.  */
15991 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15992 choke me
15993 #else
15994 $ac_func();
15995 #endif
15996
15997 ; return 0; }
15998 EOF
15999 if { (eval echo configure:16000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16000   rm -rf conftest*
16001   eval "ac_cv_func_$ac_func=yes"
16002 else
16003   echo "configure: failed program was:" >&5
16004   cat conftest.$ac_ext >&5
16005   rm -rf conftest*
16006   eval "ac_cv_func_$ac_func=no"
16007 fi
16008 rm -f conftest*
16009 fi
16010
16011 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16012   echo "$ac_t""yes" 1>&6
16013     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16014   cat >> confdefs.h <<EOF
16015 #define $ac_tr_func 1
16016 EOF
16017  ac_wfuncs=yes
16018 else
16019   echo "$ac_t""no" 1>&6
16020 ac_wfuncs=no
16021 fi
16022 done
16023
16024
16025     echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
16026 echo "configure:16027: checking for ISO C9X wchar_t support" >&5
16027     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes && test x"$ac_wfuncs" = xyes; then
16028       ac_isoC9X_wchar_t=yes
16029     else
16030       ac_isoC9X_wchar_t=no
16031     fi
16032     echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
16033
16034             ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
16035 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
16036 echo "configure:16037: checking for iconv.h" >&5
16037 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16038   echo $ac_n "(cached) $ac_c" 1>&6
16039 else
16040   cat > conftest.$ac_ext <<EOF
16041 #line 16042 "configure"
16042 #include "confdefs.h"
16043 #include <iconv.h>
16044 EOF
16045 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16046 { (eval echo configure:16047: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16047 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16048 if test -z "$ac_err"; then
16049   rm -rf conftest*
16050   eval "ac_cv_header_$ac_safe=yes"
16051 else
16052   echo "$ac_err" >&5
16053   echo "configure: failed program was:" >&5
16054   cat conftest.$ac_ext >&5
16055   rm -rf conftest*
16056   eval "ac_cv_header_$ac_safe=no"
16057 fi
16058 rm -f conftest*
16059 fi
16060 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16061   echo "$ac_t""yes" 1>&6
16062   ac_has_iconv_h=yes
16063 else
16064   echo "$ac_t""no" 1>&6
16065 ac_has_iconv_h=no
16066 fi
16067
16068     for ac_func in iconv_open iconv_close iconv
16069 do
16070 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16071 echo "configure:16072: checking for $ac_func" >&5
16072 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16073   echo $ac_n "(cached) $ac_c" 1>&6
16074 else
16075   cat > conftest.$ac_ext <<EOF
16076 #line 16077 "configure"
16077 #include "confdefs.h"
16078 /* System header to define __stub macros and hopefully few prototypes,
16079     which can conflict with char $ac_func(); below.  */
16080 #include <assert.h>
16081 /* Override any gcc2 internal prototype to avoid an error.  */
16082 /* We use char because int might match the return type of a gcc2
16083     builtin and then its argument prototype would still apply.  */
16084 char $ac_func();
16085
16086 int main() {
16087
16088 /* The GNU C library defines this for functions which it implements
16089     to always fail with ENOSYS.  Some functions are actually named
16090     something starting with __ and the normal name is an alias.  */
16091 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16092 choke me
16093 #else
16094 $ac_func();
16095 #endif
16096
16097 ; return 0; }
16098 EOF
16099 if { (eval echo configure:16100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16100   rm -rf conftest*
16101   eval "ac_cv_func_$ac_func=yes"
16102 else
16103   echo "configure: failed program was:" >&5
16104   cat conftest.$ac_ext >&5
16105   rm -rf conftest*
16106   eval "ac_cv_func_$ac_func=no"
16107 fi
16108 rm -f conftest*
16109 fi
16110
16111 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16112   echo "$ac_t""yes" 1>&6
16113     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16114   cat >> confdefs.h <<EOF
16115 #define $ac_tr_func 1
16116 EOF
16117  ac_XPG2funcs=yes
16118 else
16119   echo "$ac_t""no" 1>&6
16120 ac_XPG2funcs=no
16121 fi
16122 done
16123
16124
16125     echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
16126 echo "configure:16127: checking for XPG2 wchar_t support" >&5
16127     if test x"$ac_has_iconv_h" = xyes && test x"$ac_XPG2funcs" = xyes; then
16128       ac_XPG2_wchar_t=yes
16129     else
16130       ac_XPG2_wchar_t=no
16131     fi
16132     echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
16133
16134             echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
16135 echo "configure:16136: checking for enabled wchar_t specializations" >&5
16136     if test x"$ac_isoC9X_wchar_t" = xyes && test x"$ac_XPG2_wchar_t" = xyes; then
16137       libinst_wstring_la="libinst-wstring.la"
16138       cat >> confdefs.h <<\EOF
16139 #define _GLIBCPP_USE_WCHAR_T 1
16140 EOF
16141
16142       echo "$ac_t"""yes"" 1>&6
16143     else
16144       libinst_wstring_la=""
16145       echo "$ac_t"""no"" 1>&6
16146     fi
16147
16148
16149   else
16150     echo "configure: warning: <wchar.h> not found" 1>&2
16151     cat >> confdefs.h <<\EOF
16152 #define _GLIBCPP_NEED_MBSTATE_T 1
16153 EOF
16154
16155   fi
16156
16157
16158   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
16159 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
16160 echo "configure:16161: checking for ctype.h" >&5
16161 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16162   echo $ac_n "(cached) $ac_c" 1>&6
16163 else
16164   cat > conftest.$ac_ext <<EOF
16165 #line 16166 "configure"
16166 #include "confdefs.h"
16167 #include <ctype.h>
16168 EOF
16169 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16170 { (eval echo configure:16171: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16171 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16172 if test -z "$ac_err"; then
16173   rm -rf conftest*
16174   eval "ac_cv_header_$ac_safe=yes"
16175 else
16176   echo "$ac_err" >&5
16177   echo "configure: failed program was:" >&5
16178   cat conftest.$ac_ext >&5
16179   rm -rf conftest*
16180   eval "ac_cv_header_$ac_safe=no"
16181 fi
16182 rm -f conftest*
16183 fi
16184 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16185   echo "$ac_t""yes" 1>&6
16186
16187
16188         ctype_default=yes
16189
16190         echo $ac_n "checking <ctype> for gnu-linux ""... $ac_c" 1>&6
16191 echo "configure:16192: checking <ctype> for gnu-linux " >&5
16192     cat > conftest.$ac_ext <<EOF
16193 #line 16194 "configure"
16194 #include "confdefs.h"
16195 #include <ctype.h>
16196 int main() {
16197 int
16198     foo (int a)
16199     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
16200         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
16201         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
16202 ; return 0; }
16203 EOF
16204 if { (eval echo configure:16205: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16205   rm -rf conftest*
16206   \
16207     ctype_linux=yes
16208 else
16209   echo "configure: failed program was:" >&5
16210   cat conftest.$ac_ext >&5
16211   rm -rf conftest*
16212   ctype_linux=no
16213 fi
16214 rm -f conftest*
16215     echo "$ac_t""$ctype_linux" 1>&6
16216     if test $ctype_linux = "yes"; then
16217       ctype_include_dir="config/gnu-linux"
16218       ctype_default=no
16219     fi
16220
16221         if test $ctype_default = "yes"; then
16222     echo $ac_n "checking <ctype> for freebsd 4.0 ""... $ac_c" 1>&6
16223 echo "configure:16224: checking <ctype> for freebsd 4.0 " >&5
16224     cat > conftest.$ac_ext <<EOF
16225 #line 16226 "configure"
16226 #include "confdefs.h"
16227 #include <ctype.h>
16228 int main() {
16229 int
16230     foo (int a)
16231     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
16232         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
16233 ; return 0; }
16234 EOF
16235 if { (eval echo configure:16236: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16236   rm -rf conftest*
16237   \
16238     ctype_bsd=yes
16239 else
16240   echo "configure: failed program was:" >&5
16241   cat conftest.$ac_ext >&5
16242   rm -rf conftest*
16243   ctype_bsd=no
16244 fi
16245 rm -f conftest*
16246     echo "$ac_t""$ctype_bsd" 1>&6
16247     if test $ctype_bsd = "yes"; then
16248       ctype_include_dir="config/bsd"
16249       ctype_default=no
16250     fi
16251     fi
16252
16253         if test $ctype_default = "yes"; then
16254     echo $ac_n "checking <ctype> for freebsd 3.4 ""... $ac_c" 1>&6
16255 echo "configure:16256: checking <ctype> for freebsd 3.4 " >&5
16256     cat > conftest.$ac_ext <<EOF
16257 #line 16258 "configure"
16258 #include "confdefs.h"
16259 #include <ctype.h>
16260 int main() {
16261 int
16262     foo (int a)
16263     { return _S + _R + _C + _U + _L + _A \
16264       + _D + _P + _X + _G + __istype (a, 0);}
16265 ; return 0; }
16266 EOF
16267 if { (eval echo configure:16268: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16268   rm -rf conftest*
16269   \
16270     ctype_freebsd34=yes
16271 else
16272   echo "configure: failed program was:" >&5
16273   cat conftest.$ac_ext >&5
16274   rm -rf conftest*
16275   ctype_freebsd34=no
16276 fi
16277 rm -f conftest*
16278     echo "$ac_t""$ctype_freebsd34" 1>&6
16279     if test $ctype_freebsd34 = "yes"; then
16280       ctype_include_dir="config/bsd"
16281       ctype_default=no
16282     fi
16283     fi
16284
16285         if test $ctype_default = "yes"; then
16286     echo $ac_n "checking <ctype> for solaris 2.6,7,8 ""... $ac_c" 1>&6
16287 echo "configure:16288: checking <ctype> for solaris 2.6,7,8 " >&5
16288     cat > conftest.$ac_ext <<EOF
16289 #line 16290 "configure"
16290 #include "confdefs.h"
16291 #include <ctype.h>
16292 int main() {
16293 int
16294     foo (int a)
16295     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16296         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16297         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
16298 ; return 0; }
16299 EOF
16300 if { (eval echo configure:16301: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16301   rm -rf conftest*
16302   \
16303     ctype_solaris=yes
16304 else
16305   echo "configure: failed program was:" >&5
16306   cat conftest.$ac_ext >&5
16307   rm -rf conftest*
16308   ctype_solaris=no
16309 fi
16310 rm -f conftest*
16311     echo "$ac_t""$ctype_solaris" 1>&6
16312
16313     if test $ctype_solaris = "yes"; then
16314       echo $ac_n "checking   for version""... $ac_c" 1>&6
16315 echo "configure:16316: checking   for version" >&5
16316       ac_ext=C
16317 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16318 ac_cpp='$CXXCPP $CPPFLAGS'
16319 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16320 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16321 cross_compiling=$ac_cv_prog_cxx_cross
16322
16323       cat > conftest.$ac_ext <<EOF
16324 #line 16325 "configure"
16325 #include "confdefs.h"
16326 #include <ctype.h>
16327 int main() {
16328 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
16329 ; return 0; }
16330 EOF
16331 if { (eval echo configure:16332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16332   rm -rf conftest*
16333   \
16334       ctype_solaris26=yes
16335 else
16336   echo "configure: failed program was:" >&5
16337   cat conftest.$ac_ext >&5
16338   rm -rf conftest*
16339   ctype_solaris26=no
16340 fi
16341 rm -f conftest*
16342       ac_ext=c
16343 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16344 ac_cpp='$CPP $CPPFLAGS'
16345 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16346 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16347 cross_compiling=$ac_cv_prog_cc_cross
16348
16349       if test $ctype_solaris26 = "yes"; then
16350         ctype_include_dir="config/solaris/solaris2.6"
16351         echo "$ac_t"""solaris2.6"" 1>&6
16352         ctype_default=no
16353       else
16354         ctype_include_dir="config/solaris/solaris2.7"
16355         echo "$ac_t"""solaris2.7,8"" 1>&6
16356         ctype_default=no
16357       fi
16358     fi
16359     fi
16360
16361         if test $ctype_default = "yes"; then
16362     echo $ac_n "checking <ctype> for solaris 2.5.1 ""... $ac_c" 1>&6
16363 echo "configure:16364: checking <ctype> for solaris 2.5.1 " >&5
16364     cat > conftest.$ac_ext <<EOF
16365 #line 16366 "configure"
16366 #include "confdefs.h"
16367 #include <ctype.h>
16368 int main() {
16369 int
16370     foo (int a)
16371     { return _U + _L + _N + _S + _P + _C + _X + _B \
16372         + __ctype[a];}
16373 ; return 0; }
16374 EOF
16375 if { (eval echo configure:16376: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16376   rm -rf conftest*
16377   \
16378     ctype_solaris25=yes
16379 else
16380   echo "configure: failed program was:" >&5
16381   cat conftest.$ac_ext >&5
16382   rm -rf conftest*
16383   ctype_solaris25=no
16384 fi
16385 rm -f conftest*
16386     echo "$ac_t""$ctype_solaris25" 1>&6
16387     if test $ctype_solaris25 = "yes"; then
16388       ctype_include_dir="config/solaris/solaris2.5"
16389       ctype_default=no
16390     fi
16391     fi
16392
16393         if test $ctype_default = "yes"; then
16394     echo $ac_n "checking <ctype> for aix ""... $ac_c" 1>&6
16395 echo "configure:16396: checking <ctype> for aix " >&5
16396     cat > conftest.$ac_ext <<EOF
16397 #line 16398 "configure"
16398 #include "confdefs.h"
16399 #include <ctype.h>
16400 int main() {
16401 int
16402     foo (int a)
16403     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16404         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16405         + _VALC('a') + _IS('c', 0);}
16406 ; return 0; }
16407 EOF
16408 if { (eval echo configure:16409: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16409   rm -rf conftest*
16410   \
16411     ctype_aix=yes
16412 else
16413   echo "configure: failed program was:" >&5
16414   cat conftest.$ac_ext >&5
16415   rm -rf conftest*
16416   ctype_aix=no
16417 fi
16418 rm -f conftest*
16419     echo "$ac_t""$ctype_aix" 1>&6
16420     if test $ctype_aix = "yes"; then
16421       ctype_include_dir="config/aix"
16422       ctype_default=no
16423     fi
16424     fi
16425
16426         if test $ctype_default = "yes"; then
16427     echo $ac_n "checking <ctype> for newlib ""... $ac_c" 1>&6
16428 echo "configure:16429: checking <ctype> for newlib " >&5
16429     cat > conftest.$ac_ext <<EOF
16430 #line 16431 "configure"
16431 #include "confdefs.h"
16432 #include <ctype.h>
16433 int main() {
16434 int
16435     foo (int a)
16436     { return _U + _L + _N + _S + _P + _C + _X + _B \
16437         + _ctype_[a];}
16438 ; return 0; }
16439 EOF
16440 if { (eval echo configure:16441: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16441   rm -rf conftest*
16442   \
16443     ctype_newlib=yes
16444 else
16445   echo "configure: failed program was:" >&5
16446   cat conftest.$ac_ext >&5
16447   rm -rf conftest*
16448   ctype_newlib=no
16449 fi
16450 rm -f conftest*
16451     echo "$ac_t""$ctype_newlib" 1>&6
16452     if test $ctype_newlib = "yes"; then
16453       ctype_include_dir="config/newlib"
16454       ctype_default=no
16455     fi
16456     fi
16457
16458     if test $ctype_default = "yes"; then
16459       ctype_include_dir="config/generic"
16460       echo "configure: warning: "Using default ctype headers."" 1>&2
16461     fi
16462
16463
16464 else
16465   echo "$ac_t""no" 1>&6
16466 fi
16467
16468
16469
16470   for ac_hdr in unistd.h
16471 do
16472 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16473 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16474 echo "configure:16475: checking for $ac_hdr" >&5
16475 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16476   echo $ac_n "(cached) $ac_c" 1>&6
16477 else
16478   cat > conftest.$ac_ext <<EOF
16479 #line 16480 "configure"
16480 #include "confdefs.h"
16481 #include <$ac_hdr>
16482 EOF
16483 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16484 { (eval echo configure:16485: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16485 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16486 if test -z "$ac_err"; then
16487   rm -rf conftest*
16488   eval "ac_cv_header_$ac_safe=yes"
16489 else
16490   echo "$ac_err" >&5
16491   echo "configure: failed program was:" >&5
16492   cat conftest.$ac_ext >&5
16493   rm -rf conftest*
16494   eval "ac_cv_header_$ac_safe=no"
16495 fi
16496 rm -f conftest*
16497 fi
16498 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16499   echo "$ac_t""yes" 1>&6
16500     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
16501   cat >> confdefs.h <<EOF
16502 #define $ac_tr_hdr 1
16503 EOF
16504
16505 else
16506   echo "$ac_t""no" 1>&6
16507 fi
16508 done
16509
16510 for ac_func in getpagesize
16511 do
16512 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16513 echo "configure:16514: checking for $ac_func" >&5
16514 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16515   echo $ac_n "(cached) $ac_c" 1>&6
16516 else
16517   cat > conftest.$ac_ext <<EOF
16518 #line 16519 "configure"
16519 #include "confdefs.h"
16520 /* System header to define __stub macros and hopefully few prototypes,
16521     which can conflict with char $ac_func(); below.  */
16522 #include <assert.h>
16523 /* Override any gcc2 internal prototype to avoid an error.  */
16524 /* We use char because int might match the return type of a gcc2
16525     builtin and then its argument prototype would still apply.  */
16526 char $ac_func();
16527
16528 int main() {
16529
16530 /* The GNU C library defines this for functions which it implements
16531     to always fail with ENOSYS.  Some functions are actually named
16532     something starting with __ and the normal name is an alias.  */
16533 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16534 choke me
16535 #else
16536 $ac_func();
16537 #endif
16538
16539 ; return 0; }
16540 EOF
16541 if { (eval echo configure:16542: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16542   rm -rf conftest*
16543   eval "ac_cv_func_$ac_func=yes"
16544 else
16545   echo "configure: failed program was:" >&5
16546   cat conftest.$ac_ext >&5
16547   rm -rf conftest*
16548   eval "ac_cv_func_$ac_func=no"
16549 fi
16550 rm -f conftest*
16551 fi
16552
16553 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16554   echo "$ac_t""yes" 1>&6
16555     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16556   cat >> confdefs.h <<EOF
16557 #define $ac_tr_func 1
16558 EOF
16559
16560 else
16561   echo "$ac_t""no" 1>&6
16562 fi
16563 done
16564
16565 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
16566 echo "configure:16567: checking for working mmap" >&5
16567 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
16568   echo $ac_n "(cached) $ac_c" 1>&6
16569 else
16570   if test "$cross_compiling" = yes; then
16571   ac_cv_func_mmap_fixed_mapped=no
16572 else
16573   cat > conftest.$ac_ext <<EOF
16574 #line 16575 "configure"
16575 #include "confdefs.h"
16576
16577 /* Thanks to Mike Haertel and Jim Avera for this test.
16578    Here is a matrix of mmap possibilities:
16579         mmap private not fixed
16580         mmap private fixed at somewhere currently unmapped
16581         mmap private fixed at somewhere already mapped
16582         mmap shared not fixed
16583         mmap shared fixed at somewhere currently unmapped
16584         mmap shared fixed at somewhere already mapped
16585    For private mappings, we should verify that changes cannot be read()
16586    back from the file, nor mmap's back from the file at a different
16587    address.  (There have been systems where private was not correctly
16588    implemented like the infamous i386 svr4.0, and systems where the
16589    VM page cache was not coherent with the filesystem buffer cache
16590    like early versions of FreeBSD and possibly contemporary NetBSD.)
16591    For shared mappings, we should conversely verify that changes get
16592    propogated back to all the places they're supposed to be.
16593
16594    Grep wants private fixed already mapped.
16595    The main things grep needs to know about mmap are:
16596    * does it exist and is it safe to write into the mmap'd area
16597    * how to use it (BSD variants)  */
16598 #include <sys/types.h>
16599 #include <fcntl.h>
16600 #include <sys/mman.h>
16601
16602 /* This mess was copied from the GNU getpagesize.h.  */
16603 #ifndef HAVE_GETPAGESIZE
16604 # ifdef HAVE_UNISTD_H
16605 #  include <unistd.h>
16606 # endif
16607
16608 /* Assume that all systems that can run configure have sys/param.h.  */
16609 # ifndef HAVE_SYS_PARAM_H
16610 #  define HAVE_SYS_PARAM_H 1
16611 # endif
16612
16613 # ifdef _SC_PAGESIZE
16614 #  define getpagesize() sysconf(_SC_PAGESIZE)
16615 # else /* no _SC_PAGESIZE */
16616 #  ifdef HAVE_SYS_PARAM_H
16617 #   include <sys/param.h>
16618 #   ifdef EXEC_PAGESIZE
16619 #    define getpagesize() EXEC_PAGESIZE
16620 #   else /* no EXEC_PAGESIZE */
16621 #    ifdef NBPG
16622 #     define getpagesize() NBPG * CLSIZE
16623 #     ifndef CLSIZE
16624 #      define CLSIZE 1
16625 #     endif /* no CLSIZE */
16626 #    else /* no NBPG */
16627 #     ifdef NBPC
16628 #      define getpagesize() NBPC
16629 #     else /* no NBPC */
16630 #      ifdef PAGESIZE
16631 #       define getpagesize() PAGESIZE
16632 #      endif /* PAGESIZE */
16633 #     endif /* no NBPC */
16634 #    endif /* no NBPG */
16635 #   endif /* no EXEC_PAGESIZE */
16636 #  else /* no HAVE_SYS_PARAM_H */
16637 #   define getpagesize() 8192   /* punt totally */
16638 #  endif /* no HAVE_SYS_PARAM_H */
16639 # endif /* no _SC_PAGESIZE */
16640
16641 #endif /* no HAVE_GETPAGESIZE */
16642
16643 #ifdef __cplusplus
16644 extern "C" { void *malloc(unsigned); }
16645 #else
16646 char *malloc();
16647 #endif
16648
16649 int
16650 main()
16651 {
16652         char *data, *data2, *data3;
16653         int i, pagesize;
16654         int fd;
16655
16656         pagesize = getpagesize();
16657
16658         /*
16659          * First, make a file with some known garbage in it.
16660          */
16661         data = malloc(pagesize);
16662         if (!data)
16663                 exit(1);
16664         for (i = 0; i < pagesize; ++i)
16665                 *(data + i) = rand();
16666         umask(0);
16667         fd = creat("conftestmmap", 0600);
16668         if (fd < 0)
16669                 exit(1);
16670         if (write(fd, data, pagesize) != pagesize)
16671                 exit(1);
16672         close(fd);
16673
16674         /*
16675          * Next, try to mmap the file at a fixed address which
16676          * already has something else allocated at it.  If we can,
16677          * also make sure that we see the same garbage.
16678          */
16679         fd = open("conftestmmap", O_RDWR);
16680         if (fd < 0)
16681                 exit(1);
16682         data2 = malloc(2 * pagesize);
16683         if (!data2)
16684                 exit(1);
16685         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
16686         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
16687             MAP_PRIVATE | MAP_FIXED, fd, 0L))
16688                 exit(1);
16689         for (i = 0; i < pagesize; ++i)
16690                 if (*(data + i) != *(data2 + i))
16691                         exit(1);
16692
16693         /*
16694          * Finally, make sure that changes to the mapped area
16695          * do not percolate back to the file as seen by read().
16696          * (This is a bug on some variants of i386 svr4.0.)
16697          */
16698         for (i = 0; i < pagesize; ++i)
16699                 *(data2 + i) = *(data2 + i) + 1;
16700         data3 = malloc(pagesize);
16701         if (!data3)
16702                 exit(1);
16703         if (read(fd, data3, pagesize) != pagesize)
16704                 exit(1);
16705         for (i = 0; i < pagesize; ++i)
16706                 if (*(data + i) != *(data3 + i))
16707                         exit(1);
16708         close(fd);
16709         unlink("conftestmmap");
16710         exit(0);
16711 }
16712
16713 EOF
16714 if { (eval echo configure:16715: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
16715 then
16716   ac_cv_func_mmap_fixed_mapped=yes
16717 else
16718   echo "configure: failed program was:" >&5
16719   cat conftest.$ac_ext >&5
16720   rm -fr conftest*
16721   ac_cv_func_mmap_fixed_mapped=no
16722 fi
16723 rm -fr conftest*
16724 fi
16725
16726 fi
16727
16728 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
16729 if test $ac_cv_func_mmap_fixed_mapped = yes; then
16730   cat >> confdefs.h <<\EOF
16731 #define HAVE_MMAP 1
16732 EOF
16733
16734 fi
16735
16736 fi
16737
16738
16739
16740 if test "$CANADIAN" = yes; then
16741   CANADIAN_TRUE=
16742   CANADIAN_FALSE='#'
16743 else
16744   CANADIAN_TRUE='#'
16745   CANADIAN_FALSE=
16746 fi
16747
16748
16749 if test "$NULL_TARGET" = yes; then
16750   NULL_TARGET_TRUE=
16751   NULL_TARGET_FALSE='#'
16752 else
16753   NULL_TARGET_TRUE='#'
16754   NULL_TARGET_FALSE=
16755 fi
16756
16757
16758 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
16759   NATIVE_TRUE=
16760   NATIVE_FALSE='#'
16761 else
16762   NATIVE_TRUE='#'
16763   NATIVE_FALSE=
16764 fi
16765
16766
16767 if test -z "$with_cross_host"; then
16768   USE_LIBDIR_TRUE=
16769   USE_LIBDIR_FALSE='#'
16770 else
16771   USE_LIBDIR_TRUE='#'
16772   USE_LIBDIR_FALSE=
16773 fi
16774
16775 if test $ac_cv_header_locale_h = yes; then
16776     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
16777 echo "configure:16778: checking for LC_MESSAGES" >&5
16778 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
16779   echo $ac_n "(cached) $ac_c" 1>&6
16780 else
16781   cat > conftest.$ac_ext <<EOF
16782 #line 16783 "configure"
16783 #include "confdefs.h"
16784 #include <locale.h>
16785 int main() {
16786 return LC_MESSAGES
16787 ; return 0; }
16788 EOF
16789 if { (eval echo configure:16790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16790   rm -rf conftest*
16791   ac_cv_val_LC_MESSAGES=yes
16792 else
16793   echo "configure: failed program was:" >&5
16794   cat conftest.$ac_ext >&5
16795   rm -rf conftest*
16796   ac_cv_val_LC_MESSAGES=no
16797 fi
16798 rm -f conftest*
16799 fi
16800
16801 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
16802     if test $ac_cv_val_LC_MESSAGES = yes; then
16803       cat >> confdefs.h <<\EOF
16804 #define HAVE_LC_MESSAGES 1
16805 EOF
16806
16807     fi
16808   fi
16809
16810
16811 if test "${multilib}" = "yes"; then
16812   multilib_arg="--enable-multilib"
16813 else
16814   multilib_arg=
16815 fi
16816
16817
16818 # Generate the various Makefiles, include files, and scripts.
16819
16820 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
16821 # so that multilib installs will end up installed in the correct
16822 # place. To work around this not being passed down from config-ml.in
16823 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
16824 # append it here.
16825
16826 trap '' 1 2 15
16827 cat > confcache <<\EOF
16828 # This file is a shell script that caches the results of configure
16829 # tests run on this system so they can be shared between configure
16830 # scripts and configure runs.  It is not useful on other systems.
16831 # If it contains results you don't want to keep, you may remove or edit it.
16832 #
16833 # By default, configure uses ./config.cache as the cache file,
16834 # creating it if it does not exist already.  You can give configure
16835 # the --cache-file=FILE option to use a different cache file; that is
16836 # what configure does when it calls configure scripts in
16837 # subdirectories, so they share the cache.
16838 # Giving --cache-file=/dev/null disables caching, for debugging configure.
16839 # config.status only pays attention to the cache file if you give it the
16840 # --recheck option to rerun configure.
16841 #
16842 EOF
16843 # The following way of writing the cache mishandles newlines in values,
16844 # but we know of no workaround that is simple, portable, and efficient.
16845 # So, don't put newlines in cache variables' values.
16846 # Ultrix sh set writes to stderr and can't be redirected directly,
16847 # and sets the high bit in the cache file unless we assign to the vars.
16848 (set) 2>&1 |
16849   case `(ac_space=' '; set | grep ac_space) 2>&1` in
16850   *ac_space=\ *)
16851     # `set' does not quote correctly, so add quotes (double-quote substitution
16852     # turns \\\\ into \\, and sed turns \\ into \).
16853     sed -n \
16854       -e "s/'/'\\\\''/g" \
16855       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
16856     ;;
16857   *)
16858     # `set' quotes correctly as required by POSIX, so do not add quotes.
16859     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
16860     ;;
16861   esac >> confcache
16862 if cmp -s $cache_file confcache; then
16863   :
16864 else
16865   if test -w $cache_file; then
16866     echo "updating cache $cache_file"
16867     cat confcache > $cache_file
16868   else
16869     echo "not updating unwritable cache $cache_file"
16870   fi
16871 fi
16872 rm -f confcache
16873
16874 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
16875
16876 test "x$prefix" = xNONE && prefix=$ac_default_prefix
16877 # Let make expand exec_prefix.
16878 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
16879
16880 # Any assignment to VPATH causes Sun make to only execute
16881 # the first set of double-colon rules, so remove it if not needed.
16882 # If there is a colon in the path, we need to keep it.
16883 if test "x$srcdir" = x.; then
16884   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
16885 fi
16886
16887 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
16888
16889 DEFS=-DHAVE_CONFIG_H
16890
16891 # Without the "./", some shells look in PATH for config.status.
16892 : ${CONFIG_STATUS=./config.status}
16893
16894 echo creating $CONFIG_STATUS
16895 rm -f $CONFIG_STATUS
16896 cat > $CONFIG_STATUS <<EOF
16897 #! /bin/sh
16898 # Generated automatically by configure.
16899 # Run this file to recreate the current configuration.
16900 # This directory was configured as follows,
16901 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
16902 #
16903 # $0 $ac_configure_args
16904 #
16905 # Compiler output produced by configure, useful for debugging
16906 # configure, is in ./config.log if it exists.
16907
16908 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
16909 for ac_option
16910 do
16911   case "\$ac_option" in
16912   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
16913     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
16914     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
16915   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
16916     echo "$CONFIG_STATUS generated by autoconf version 2.13"
16917     exit 0 ;;
16918   -help | --help | --hel | --he | --h)
16919     echo "\$ac_cs_usage"; exit 0 ;;
16920   *) echo "\$ac_cs_usage"; exit 1 ;;
16921   esac
16922 done
16923
16924 ac_given_srcdir=$srcdir
16925 ac_given_INSTALL="$INSTALL"
16926
16927 trap 'rm -fr `echo "mkcheck Makefile src/Makefile math/Makefile libio/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
16928 EOF
16929 cat >> $CONFIG_STATUS <<EOF
16930
16931 # Protect against being on the right side of a sed subst in config.status.
16932 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
16933  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
16934 $ac_vpsub
16935 $extrasub
16936 s%@SHELL@%$SHELL%g
16937 s%@CFLAGS@%$CFLAGS%g
16938 s%@CPPFLAGS@%$CPPFLAGS%g
16939 s%@CXXFLAGS@%$CXXFLAGS%g
16940 s%@FFLAGS@%$FFLAGS%g
16941 s%@DEFS@%$DEFS%g
16942 s%@LDFLAGS@%$LDFLAGS%g
16943 s%@LIBS@%$LIBS%g
16944 s%@exec_prefix@%$exec_prefix%g
16945 s%@prefix@%$prefix%g
16946 s%@program_transform_name@%$program_transform_name%g
16947 s%@bindir@%$bindir%g
16948 s%@sbindir@%$sbindir%g
16949 s%@libexecdir@%$libexecdir%g
16950 s%@datadir@%$datadir%g
16951 s%@sysconfdir@%$sysconfdir%g
16952 s%@sharedstatedir@%$sharedstatedir%g
16953 s%@localstatedir@%$localstatedir%g
16954 s%@libdir@%$libdir%g
16955 s%@includedir@%$includedir%g
16956 s%@oldincludedir@%$oldincludedir%g
16957 s%@infodir@%$infodir%g
16958 s%@mandir@%$mandir%g
16959 s%@host@%$host%g
16960 s%@host_alias@%$host_alias%g
16961 s%@host_cpu@%$host_cpu%g
16962 s%@host_vendor@%$host_vendor%g
16963 s%@host_os@%$host_os%g
16964 s%@target@%$target%g
16965 s%@target_alias@%$target_alias%g
16966 s%@target_cpu@%$target_cpu%g
16967 s%@target_vendor@%$target_vendor%g
16968 s%@target_os@%$target_os%g
16969 s%@build@%$build%g
16970 s%@build_alias@%$build_alias%g
16971 s%@build_cpu@%$build_cpu%g
16972 s%@build_vendor@%$build_vendor%g
16973 s%@build_os@%$build_os%g
16974 s%@glibcpp_basedir@%$glibcpp_basedir%g
16975 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
16976 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
16977 s%@INSTALL_DATA@%$INSTALL_DATA%g
16978 s%@PACKAGE@%$PACKAGE%g
16979 s%@VERSION@%$VERSION%g
16980 s%@ACLOCAL@%$ACLOCAL%g
16981 s%@AUTOCONF@%$AUTOCONF%g
16982 s%@AUTOMAKE@%$AUTOMAKE%g
16983 s%@AUTOHEADER@%$AUTOHEADER%g
16984 s%@MAKEINFO@%$MAKEINFO%g
16985 s%@SET_MAKE@%$SET_MAKE%g
16986 s%@CC@%$CC%g
16987 s%@CXX@%$CXX%g
16988 s%@AS@%$AS%g
16989 s%@AR@%$AR%g
16990 s%@RANLIB@%$RANLIB%g
16991 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
16992 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
16993 s%@MAINT@%$MAINT%g
16994 s%@EXEEXT@%$EXEEXT%g
16995 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
16996 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
16997 s%@ifGNUmake@%$ifGNUmake%g
16998 s%@LN_S@%$LN_S%g
16999 s%@LIBTOOL@%$LIBTOOL%g
17000 s%@CPP@%$CPP%g
17001 s%@cpu_include_dir@%$cpu_include_dir%g
17002 s%@CPU_FLAGS@%$CPU_FLAGS%g
17003 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
17004 s%@BUILD_LIBIO_INCLUDE@%$BUILD_LIBIO_INCLUDE%g
17005 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE%g
17006 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE%g
17007 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
17008 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
17009 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
17010 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
17011 s%@CSHADOWFLAGS@%$CSHADOWFLAGS%g
17012 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
17013 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
17014 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
17015 s%@THREADLIBS@%$THREADLIBS%g
17016 s%@THREADINCS@%$THREADINCS%g
17017 s%@THREADDEPS@%$THREADDEPS%g
17018 s%@THREADOBJS@%$THREADOBJS%g
17019 s%@THREADSPEC@%$THREADSPEC%g
17020 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
17021 s%@ctype_include_dir@%$ctype_include_dir%g
17022 s%@WERROR@%$WERROR%g
17023 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
17024 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
17025 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
17026 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
17027 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
17028 s%@libinst_wstring_la@%$libinst_wstring_la%g
17029 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
17030 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
17031 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
17032 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
17033 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
17034 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
17035 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
17036 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
17037
17038 CEOF
17039 EOF
17040
17041 cat >> $CONFIG_STATUS <<\EOF
17042
17043 # Split the substitutions into bite-sized pieces for seds with
17044 # small command number limits, like on Digital OSF/1 and HP-UX.
17045 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
17046 ac_file=1 # Number of current file.
17047 ac_beg=1 # First line for current file.
17048 ac_end=$ac_max_sed_cmds # Line after last line for current file.
17049 ac_more_lines=:
17050 ac_sed_cmds=""
17051 while $ac_more_lines; do
17052   if test $ac_beg -gt 1; then
17053     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
17054   else
17055     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
17056   fi
17057   if test ! -s conftest.s$ac_file; then
17058     ac_more_lines=false
17059     rm -f conftest.s$ac_file
17060   else
17061     if test -z "$ac_sed_cmds"; then
17062       ac_sed_cmds="sed -f conftest.s$ac_file"
17063     else
17064       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
17065     fi
17066     ac_file=`expr $ac_file + 1`
17067     ac_beg=$ac_end
17068     ac_end=`expr $ac_end + $ac_max_sed_cmds`
17069   fi
17070 done
17071 if test -z "$ac_sed_cmds"; then
17072   ac_sed_cmds=cat
17073 fi
17074 EOF
17075
17076 cat >> $CONFIG_STATUS <<EOF
17077
17078 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile math/Makefile libio/Makefile"}
17079 EOF
17080 cat >> $CONFIG_STATUS <<\EOF
17081 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
17082   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17083   case "$ac_file" in
17084   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17085        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17086   *) ac_file_in="${ac_file}.in" ;;
17087   esac
17088
17089   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
17090
17091   # Remove last slash and all that follows it.  Not all systems have dirname.
17092   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17093   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17094     # The file is in a subdirectory.
17095     test ! -d "$ac_dir" && mkdir "$ac_dir"
17096     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
17097     # A "../" for each directory in $ac_dir_suffix.
17098     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
17099   else
17100     ac_dir_suffix= ac_dots=
17101   fi
17102
17103   case "$ac_given_srcdir" in
17104   .)  srcdir=.
17105       if test -z "$ac_dots"; then top_srcdir=.
17106       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
17107   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
17108   *) # Relative path.
17109     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
17110     top_srcdir="$ac_dots$ac_given_srcdir" ;;
17111   esac
17112
17113   case "$ac_given_INSTALL" in
17114   [/$]*) INSTALL="$ac_given_INSTALL" ;;
17115   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
17116   esac
17117
17118   echo creating "$ac_file"
17119   rm -f "$ac_file"
17120   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
17121   case "$ac_file" in
17122   *Makefile*) ac_comsub="1i\\
17123 # $configure_input" ;;
17124   *) ac_comsub= ;;
17125   esac
17126
17127   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17128   sed -e "$ac_comsub
17129 s%@configure_input@%$configure_input%g
17130 s%@srcdir@%$srcdir%g
17131 s%@top_srcdir@%$top_srcdir%g
17132 s%@INSTALL@%$INSTALL%g
17133 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
17134 fi; done
17135 rm -f conftest.s*
17136
17137 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
17138 # NAME is the cpp macro being defined and VALUE is the value it is being given.
17139 #
17140 # ac_d sets the value in "#define NAME VALUE" lines.
17141 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
17142 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
17143 ac_dC='\3'
17144 ac_dD='%g'
17145 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
17146 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17147 ac_uB='\([      ]\)%\1#\2define\3'
17148 ac_uC=' '
17149 ac_uD='\4%g'
17150 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
17151 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17152 ac_eB='$%\1#\2define\3'
17153 ac_eC=' '
17154 ac_eD='%g'
17155
17156 if test "${CONFIG_HEADERS+set}" != set; then
17157 EOF
17158 cat >> $CONFIG_STATUS <<EOF
17159   CONFIG_HEADERS="config.h"
17160 EOF
17161 cat >> $CONFIG_STATUS <<\EOF
17162 fi
17163 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
17164   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17165   case "$ac_file" in
17166   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17167        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17168   *) ac_file_in="${ac_file}.in" ;;
17169   esac
17170
17171   echo creating $ac_file
17172
17173   rm -f conftest.frag conftest.in conftest.out
17174   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17175   cat $ac_file_inputs > conftest.in
17176
17177 EOF
17178
17179 # Transform confdefs.h into a sed script conftest.vals that substitutes
17180 # the proper values into config.h.in to produce config.h.  And first:
17181 # Protect against being on the right side of a sed subst in config.status.
17182 # Protect against being in an unquoted here document in config.status.
17183 rm -f conftest.vals
17184 cat > conftest.hdr <<\EOF
17185 s/[\\&%]/\\&/g
17186 s%[\\$`]%\\&%g
17187 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
17188 s%ac_d%ac_u%gp
17189 s%ac_u%ac_e%gp
17190 EOF
17191 sed -n -f conftest.hdr confdefs.h > conftest.vals
17192 rm -f conftest.hdr
17193
17194 # This sed command replaces #undef with comments.  This is necessary, for
17195 # example, in the case of _POSIX_SOURCE, which is predefined and required
17196 # on some systems where configure will not decide to define it.
17197 cat >> conftest.vals <<\EOF
17198 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
17199 EOF
17200
17201 # Break up conftest.vals because some shells have a limit on
17202 # the size of here documents, and old seds have small limits too.
17203
17204 rm -f conftest.tail
17205 while :
17206 do
17207   ac_lines=`grep -c . conftest.vals`
17208   # grep -c gives empty output for an empty file on some AIX systems.
17209   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
17210   # Write a limited-size here document to conftest.frag.
17211   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
17212   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
17213   echo 'CEOF
17214   sed -f conftest.frag conftest.in > conftest.out
17215   rm -f conftest.in
17216   mv conftest.out conftest.in
17217 ' >> $CONFIG_STATUS
17218   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
17219   rm -f conftest.vals
17220   mv conftest.tail conftest.vals
17221 done
17222 rm -f conftest.vals
17223
17224 cat >> $CONFIG_STATUS <<\EOF
17225   rm -f conftest.frag conftest.h
17226   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
17227   cat conftest.in >> conftest.h
17228   rm -f conftest.in
17229   if cmp -s $ac_file conftest.h 2>/dev/null; then
17230     echo "$ac_file is unchanged"
17231     rm -f conftest.h
17232   else
17233     # Remove last slash and all that follows it.  Not all systems have dirname.
17234       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17235       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17236       # The file is in a subdirectory.
17237       test ! -d "$ac_dir" && mkdir "$ac_dir"
17238     fi
17239     rm -f $ac_file
17240     mv conftest.h $ac_file
17241   fi
17242 fi; done
17243
17244 EOF
17245
17246 cat >> $CONFIG_STATUS <<EOF
17247 ac_sources="$CSTDIO_H $CSTDIO_CC config/$THREADH"
17248 ac_dests="bits/c++io.h src/c++io.cc bits/c++threads.h"
17249 EOF
17250
17251 cat >> $CONFIG_STATUS <<\EOF
17252 srcdir=$ac_given_srcdir
17253 while test -n "$ac_sources"; do
17254   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
17255   set $ac_sources; ac_source=$1; shift; ac_sources=$*
17256
17257   echo "linking $srcdir/$ac_source to $ac_dest"
17258
17259   if test ! -r $srcdir/$ac_source; then
17260     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
17261   fi
17262   rm -f $ac_dest
17263
17264   # Make relative symlinks.
17265   # Remove last slash and all that follows it.  Not all systems have dirname.
17266   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
17267   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
17268     # The dest file is in a subdirectory.
17269     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
17270     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
17271     # A "../" for each directory in $ac_dest_dir_suffix.
17272     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
17273   else
17274     ac_dest_dir_suffix= ac_dots=
17275   fi
17276
17277   case "$srcdir" in
17278   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
17279   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
17280   esac
17281
17282   # Make a symlink if possible; otherwise try a hard link.
17283   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
17284     ln $srcdir/$ac_source $ac_dest; then :
17285   else
17286     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
17287   fi
17288 done
17289 EOF
17290 cat >> $CONFIG_STATUS <<EOF
17291
17292 srcdir=${srcdir}
17293 host=${host}
17294 target=${target}
17295 with_multisubdir=${with_multisubdir}
17296 ac_configure_args="${multilib_arg} ${ac_configure_args}"
17297 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
17298 glibcpp_basedir=${glibcpp_basedir}
17299 CC="${CC}"
17300 CXX="${CXX}"
17301
17302 EOF
17303 cat >> $CONFIG_STATUS <<\EOF
17304 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
17305 if test -n "$CONFIG_FILES"; then
17306   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
17307   grep '^MULTISUBDIR =' Makefile >> src/Makefile
17308 fi
17309 exit 0
17310 EOF
17311 chmod +x $CONFIG_STATUS
17312 rm -fr confdefs* $ac_clean_files
17313 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
17314
17315
17316
17317 blddir=`pwd`
17318 # Generate bits/c++config.h
17319 # NB: This must be the first generated file as others include it. . .
17320
17321
17322 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
17323
17324
17325
17326 # Sanity checking & User-visible messages.
17327 # Checks down here, otherwise they get scrolled off before
17328 # the user will notice.
17329 if test "$enable_namespaces" = "yes" && test "$enable_libgcc_rebuild" = "no"
17330 then
17331   echo "configure: warning: libgcc.a will not match mangled symbols unless it is rebuilt" 1>&2
17332 fi
17333 if test "$enable_namespaces" = "no" && test "$enable_libgcc_rebuild" != "no"
17334 then
17335   # Other things besides namespaces can make this true as well, but none
17336   # of them are done automatically... yet
17337   echo "configure: warning: no point in rebuilding libgcc.a if namespaces aren't used" 1>&2
17338 fi
17339
17340 # Trying to get more people to read documentation.  Possibly remove check
17341 # and warn all the time.
17342 if test ! -f .sanity_warned; then
17343   touch .sanity_warned
17344   # There is no "informational" AC_MSG_ macro, so these are going to be
17345   # printed even when --quiet/--silent is given.
17346   echo ''
17347   echo 'Please make certain that you read the installation information here:'
17348   echo "  faster => ${srcdir}/docs/install.html"
17349   echo '  slower => <URL:http://sources.redhat.com/libstdc++/install.html>'
17350   echo ''
17351   echo 'and the configuration information here:'
17352   echo "  faster => ${srcdir}/docs/configopts.html"
17353   echo '  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>'
17354   echo ''
17355   echo 'before proceeding with "make".'
17356   echo ''
17357 fi
17358
17359
17360 $srcdir/mkc++config $blddir $srcdir
17361 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
17362
17363