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   --with-pic              try to use only PIC/non-PIC objects [default=use both]"
  36 ac_help="$ac_help
  37   --enable-debug          extra debugging, turn off optimization [default=no]"
  38 ac_help="$ac_help
  39   --enable-c-mbchar       enable multibyte (wide) characters [default=yes]"
  40 ac_help="$ac_help
  41   --enable-cstdio        enable GNU libio for target io package. (default)
  42      --enable-cstdio=LIB    use LIB target-speific io package."
  43 ac_help="$ac_help
  44   --enable-long-long      turns on 'long long' [default=yes]"
  45 ac_help="$ac_help
  46   --enable-cshadow-headers construct "shadowed" C header files for
  47                            g++ [default=no]"
  48 ac_help="$ac_help
  49   --enable-threads        enable thread usage for target GCC.
  50      --enable-threads=LIB    use LIB thread package for target GCC."
  51 ac_help="$ac_help
  52   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  53                                 [default=none]"
  54 ac_help="$ac_help
  55  --with-gxx-include-dir  the installation directory for include files"
  56 ac_help="$ac_help
  57   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory "
  58
  59 # Initialize some variables set by options.
  60 # The variables have the same names as the options, with
  61 # dashes changed to underlines.
  62 build=NONE
  63 cache_file=./config.cache
  64 exec_prefix=NONE
  65 host=NONE
  66 no_create=
  67 nonopt=NONE
  68 no_recursion=
  69 prefix=NONE
  70 program_prefix=NONE
  71 program_suffix=NONE
  72 program_transform_name=s,x,x,
  73 silent=
  74 site=
  75 sitefile=
  76 srcdir=
  77 target=NONE
  78 verbose=
  79 x_includes=NONE
  80 x_libraries=NONE
  81 bindir='${exec_prefix}/bin'
  82 sbindir='${exec_prefix}/sbin'
  83 libexecdir='${exec_prefix}/libexec'
  84 datadir='${prefix}/share'
  85 sysconfdir='${prefix}/etc'
  86 sharedstatedir='${prefix}/com'
  87 localstatedir='${prefix}/var'
  88 libdir='${exec_prefix}/lib'
  89 includedir='${prefix}/include'
  90 oldincludedir='/usr/include'
  91 infodir='${prefix}/info'
  92 mandir='${prefix}/man'
  93
  94 # Initialize some other variables.
  95 subdirs=
  96 MFLAGS= MAKEFLAGS=
  97 SHELL=${CONFIG_SHELL-/bin/sh}
  98 # Maximum number of lines to put in a shell here document.
  99 ac_max_here_lines=12
 100
 101 ac_prev=
 102 for ac_option
 103 do
 104
 105   # If the previous option needs an argument, assign it.
 106   if test -n "$ac_prev"; then
 107     eval "$ac_prev=\$ac_option"
 108     ac_prev=
 109     continue
 110   fi
 111
 112   case "$ac_option" in
 113   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 114   *) ac_optarg= ;;
 115   esac
 116
 117   # Accept the important Cygnus configure options, so we can diagnose typos.
 118
 119   case "$ac_option" in
 120
 121   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 122     ac_prev=bindir ;;
 123   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 124     bindir="$ac_optarg" ;;
 125
 126   -build | --build | --buil | --bui | --bu)
 127     ac_prev=build ;;
 128   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 129     build="$ac_optarg" ;;
 130
 131   -cache-file | --cache-file | --cache-fil | --cache-fi \
 132   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 133     ac_prev=cache_file ;;
 134   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 135   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 136     cache_file="$ac_optarg" ;;
 137
 138   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 139     ac_prev=datadir ;;
 140   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 141   | --da=*)
 142     datadir="$ac_optarg" ;;
 143
 144   -disable-* | --disable-*)
 145     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 146     # Reject names that are not valid shell variable names.
 147     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 148       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 149     fi
 150     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 151     eval "enable_${ac_feature}=no" ;;
 152
 153   -enable-* | --enable-*)
 154     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 155     # Reject names that are not valid shell variable names.
 156     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 157       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 158     fi
 159     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 160     case "$ac_option" in
 161       *=*) ;;
 162       *) ac_optarg=yes ;;
 163     esac
 164     eval "enable_${ac_feature}='$ac_optarg'" ;;
 165
 166   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 167   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 168   | --exec | --exe | --ex)
 169     ac_prev=exec_prefix ;;
 170   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 171   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 172   | --exec=* | --exe=* | --ex=*)
 173     exec_prefix="$ac_optarg" ;;
 174
 175   -gas | --gas | --ga | --g)
 176     # Obsolete; use --with-gas.
 177     with_gas=yes ;;
 178
 179   -help | --help | --hel | --he)
 180     # Omit some internal or obsolete options to make the list less imposing.
 181     # This message is too long to be a string in the A/UX 3.1 sh.
 182     cat << EOF
 183 Usage: configure [options] [host]
 184 Options: [defaults in brackets after descriptions]
 185 Configuration:
 186   --cache-file=FILE       cache test results in FILE
 187   --help                  print this message
 188   --no-create             do not create output files
 189   --quiet, --silent       do not print \`checking...' messages
 190   --site-file=FILE        use FILE as the site file
 191   --version               print the version of autoconf that created configure
 192 Directory and file names:
 193   --prefix=PREFIX         install architecture-independent files in PREFIX
 194                           [$ac_default_prefix]
 195   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 196                           [same as prefix]
 197   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 198   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 199   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 200   --datadir=DIR           read-only architecture-independent data in DIR
 201                           [PREFIX/share]
 202   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 203   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 204                           [PREFIX/com]
 205   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 206   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 207   --includedir=DIR        C header files in DIR [PREFIX/include]
 208   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 209   --infodir=DIR           info documentation in DIR [PREFIX/info]
 210   --mandir=DIR            man documentation in DIR [PREFIX/man]
 211   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 212   --program-prefix=PREFIX prepend PREFIX to installed program names
 213   --program-suffix=SUFFIX append SUFFIX to installed program names
 214   --program-transform-name=PROGRAM
 215                           run sed PROGRAM on installed program names
 216 EOF
 217     cat << EOF
 218 Host type:
 219   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 220   --host=HOST             configure for HOST [guessed]
 221   --target=TARGET         configure for TARGET [TARGET=HOST]
 222 Features and packages:
 223   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 224   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 225   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 226   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 227   --x-includes=DIR        X include files are in DIR
 228   --x-libraries=DIR       X library files are in DIR
 229 EOF
 230     if test -n "$ac_help"; then
 231       echo "--enable and --with options recognized:$ac_help"
 232     fi
 233     exit 0 ;;
 234
 235   -host | --host | --hos | --ho)
 236     ac_prev=host ;;
 237   -host=* | --host=* | --hos=* | --ho=*)
 238     host="$ac_optarg" ;;
 239
 240   -includedir | --includedir | --includedi | --included | --include \
 241   | --includ | --inclu | --incl | --inc)
 242     ac_prev=includedir ;;
 243   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 244   | --includ=* | --inclu=* | --incl=* | --inc=*)
 245     includedir="$ac_optarg" ;;
 246
 247   -infodir | --infodir | --infodi | --infod | --info | --inf)
 248     ac_prev=infodir ;;
 249   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 250     infodir="$ac_optarg" ;;
 251
 252   -libdir | --libdir | --libdi | --libd)
 253     ac_prev=libdir ;;
 254   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 255     libdir="$ac_optarg" ;;
 256
 257   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 258   | --libexe | --libex | --libe)
 259     ac_prev=libexecdir ;;
 260   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 261   | --libexe=* | --libex=* | --libe=*)
 262     libexecdir="$ac_optarg" ;;
 263
 264   -localstatedir | --localstatedir | --localstatedi | --localstated \
 265   | --localstate | --localstat | --localsta | --localst \
 266   | --locals | --local | --loca | --loc | --lo)
 267     ac_prev=localstatedir ;;
 268   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 269   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 270   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 271     localstatedir="$ac_optarg" ;;
 272
 273   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 274     ac_prev=mandir ;;
 275   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 276     mandir="$ac_optarg" ;;
 277
 278   -nfp | --nfp | --nf)
 279     # Obsolete; use --without-fp.
 280     with_fp=no ;;
 281
 282   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 283   | --no-cr | --no-c)
 284     no_create=yes ;;
 285
 286   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 287   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 288     no_recursion=yes ;;
 289
 290   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 291   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 292   | --oldin | --oldi | --old | --ol | --o)
 293     ac_prev=oldincludedir ;;
 294   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 295   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 296   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 297     oldincludedir="$ac_optarg" ;;
 298
 299   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 300     ac_prev=prefix ;;
 301   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 302     prefix="$ac_optarg" ;;
 303
 304   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 305   | --program-pre | --program-pr | --program-p)
 306     ac_prev=program_prefix ;;
 307   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 308   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 309     program_prefix="$ac_optarg" ;;
 310
 311   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 312   | --program-suf | --program-su | --program-s)
 313     ac_prev=program_suffix ;;
 314   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 315   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 316     program_suffix="$ac_optarg" ;;
 317
 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     ac_prev=program_transform_name ;;
 326   -program-transform-name=* | --program-transform-name=* \
 327   | --program-transform-nam=* | --program-transform-na=* \
 328   | --program-transform-n=* | --program-transform-=* \
 329   | --program-transform=* | --program-transfor=* \
 330   | --program-transfo=* | --program-transf=* \
 331   | --program-trans=* | --program-tran=* \
 332   | --progr-tra=* | --program-tr=* | --program-t=*)
 333     program_transform_name="$ac_optarg" ;;
 334
 335   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 336   | -silent | --silent | --silen | --sile | --sil)
 337     silent=yes ;;
 338
 339   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 340     ac_prev=sbindir ;;
 341   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 342   | --sbi=* | --sb=*)
 343     sbindir="$ac_optarg" ;;
 344
 345   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 346   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 347   | --sharedst | --shareds | --shared | --share | --shar \
 348   | --sha | --sh)
 349     ac_prev=sharedstatedir ;;
 350   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 351   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 352   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 353   | --sha=* | --sh=*)
 354     sharedstatedir="$ac_optarg" ;;
 355
 356   -site | --site | --sit)
 357     ac_prev=site ;;
 358   -site=* | --site=* | --sit=*)
 359     site="$ac_optarg" ;;
 360
 361   -site-file | --site-file | --site-fil | --site-fi | --site-f)
 362     ac_prev=sitefile ;;
 363   -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
 364     sitefile="$ac_optarg" ;;
 365
 366   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 367     ac_prev=srcdir ;;
 368   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 369     srcdir="$ac_optarg" ;;
 370
 371   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 372   | --syscon | --sysco | --sysc | --sys | --sy)
 373     ac_prev=sysconfdir ;;
 374   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 375   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 376     sysconfdir="$ac_optarg" ;;
 377
 378   -target | --target | --targe | --targ | --tar | --ta | --t)
 379     ac_prev=target ;;
 380   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 381     target="$ac_optarg" ;;
 382
 383   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 384     verbose=yes ;;
 385
 386   -version | --version | --versio | --versi | --vers)
 387     echo "configure generated by autoconf version 2.13"
 388     exit 0 ;;
 389
 390   -with-* | --with-*)
 391     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 392     # Reject names that are not valid shell variable names.
 393     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 394       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 395     fi
 396     ac_package=`echo $ac_package| sed 's/-/_/g'`
 397     case "$ac_option" in
 398       *=*) ;;
 399       *) ac_optarg=yes ;;
 400     esac
 401     eval "with_${ac_package}='$ac_optarg'" ;;
 402
 403   -without-* | --without-*)
 404     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 405     # Reject names that are not valid shell variable names.
 406     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 407       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 408     fi
 409     ac_package=`echo $ac_package| sed 's/-/_/g'`
 410     eval "with_${ac_package}=no" ;;
 411
 412   --x)
 413     # Obsolete; use --with-x.
 414     with_x=yes ;;
 415
 416   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 417   | --x-incl | --x-inc | --x-in | --x-i)
 418     ac_prev=x_includes ;;
 419   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 420   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 421     x_includes="$ac_optarg" ;;
 422
 423   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 424   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 425     ac_prev=x_libraries ;;
 426   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 427   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 428     x_libraries="$ac_optarg" ;;
 429
 430   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 431     ;;
 432
 433   *)
 434     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 435       echo "configure: warning: $ac_option: invalid host type" 1>&2
 436     fi
 437     if test "x$nonopt" != xNONE; then
 438       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 439     fi
 440     nonopt="$ac_option"
 441     ;;
 442
 443   esac
 444 done
 445
 446 if test -n "$ac_prev"; then
 447   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 448 fi
 449
 450 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 451
 452 # File descriptor usage:
 453 # 0 standard input
 454 # 1 file creation
 455 # 2 errors and warnings
 456 # 3 some systems may open it to /dev/tty
 457 # 4 used on the Kubota Titan
 458 # 6 checking for... messages and results
 459 # 5 compiler messages saved in config.log
 460 if test "$silent" = yes; then
 461   exec 6>/dev/null
 462 else
 463   exec 6>&1
 464 fi
 465 exec 5>./config.log
 466
 467 echo "\
 468 This file contains any messages produced by compilers while
 469 running configure, to aid debugging if configure makes a mistake.
 470 " 1>&5
 471
 472 # Strip out --no-create and --no-recursion so they do not pile up.
 473 # Also quote any args containing shell metacharacters.
 474 ac_configure_args=
 475 for ac_arg
 476 do
 477   case "$ac_arg" in
 478   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 479   | --no-cr | --no-c) ;;
 480   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 481   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 482   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 483   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 484   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 485   esac
 486 done
 487
 488 # NLS nuisances.
 489 # Only set these to C if already set.  These must not be set unconditionally
 490 # because not all systems understand e.g. LANG=C (notably SCO).
 491 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 492 # Non-C LC_CTYPE values break the ctype check.
 493 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 494 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 495 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 496 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 497
 498 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 499 rm -rf conftest* confdefs.h
 500 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 501 echo > confdefs.h
 502
 503 # A filename unique to this package, relative to the directory that
 504 # configure is in, which we can look for to find out if srcdir is correct.
 505 ac_unique_file=src/complex.cc
 506
 507 # Find the source files, if location was not specified.
 508 if test -z "$srcdir"; then
 509   ac_srcdir_defaulted=yes
 510   # Try the directory containing this script, then its parent.
 511   ac_prog=$0
 512   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 513   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 514   srcdir=$ac_confdir
 515   if test ! -r $srcdir/$ac_unique_file; then
 516     srcdir=..
 517   fi
 518 else
 519   ac_srcdir_defaulted=no
 520 fi
 521 if test ! -r $srcdir/$ac_unique_file; then
 522   if test "$ac_srcdir_defaulted" = yes; then
 523     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 524   else
 525     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 526   fi
 527 fi
 528 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 529
 530 # Prefer explicitly selected file to automatically selected ones.
 531 if test -z "$sitefile"; then
 532   if test -z "$CONFIG_SITE"; then
 533     if test "x$prefix" != xNONE; then
 534       CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 535     else
 536       CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 537     fi
 538   fi
 539 else
 540   CONFIG_SITE="$sitefile"
 541 fi
 542 for ac_site_file in $CONFIG_SITE; do
 543   if test -r "$ac_site_file"; then
 544     echo "loading site script $ac_site_file"
 545     . "$ac_site_file"
 546   fi
 547 done
 548
 549 if test -r "$cache_file"; then
 550   echo "loading cache $cache_file"
 551   . $cache_file
 552 else
 553   echo "creating cache $cache_file"
 554   > $cache_file
 555 fi
 556
 557 ac_ext=c
 558 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 559 ac_cpp='$CPP $CPPFLAGS'
 560 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 561 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 562 cross_compiling=$ac_cv_prog_cc_cross
 563
 564 ac_exeext=
 565 ac_objext=o
 566 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 567   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 568   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 569     ac_n= ac_c='
 570 ' ac_t='        '
 571   else
 572     ac_n=-n ac_c= ac_t=
 573   fi
 574 else
 575   ac_n= ac_c='\c' ac_t=
 576 fi
 577
 578
 579 ac_aux_dir=
 580 for ac_dir in .. $srcdir/..; do
 581   if test -f $ac_dir/install-sh; then
 582     ac_aux_dir=$ac_dir
 583     ac_install_sh="$ac_aux_dir/install-sh -c"
 584     break
 585   elif test -f $ac_dir/install.sh; then
 586     ac_aux_dir=$ac_dir
 587     ac_install_sh="$ac_aux_dir/install.sh -c"
 588     break
 589   fi
 590 done
 591 if test -z "$ac_aux_dir"; then
 592   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 593 fi
 594 ac_config_guess=$ac_aux_dir/config.guess
 595 ac_config_sub=$ac_aux_dir/config.sub
 596 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 597
 598
 599 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 600
 601 # Do some error checking and defaulting for the host and target type.
 602 # The inputs are:
 603 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 604 #
 605 # The rules are:
 606 # 1. You are not allowed to specify --host, --target, and nonopt at the
 607 #    same time.
 608 # 2. Host defaults to nonopt.
 609 # 3. If nonopt is not specified, then host defaults to the current host,
 610 #    as determined by config.guess.
 611 # 4. Target and build default to nonopt.
 612 # 5. If nonopt is not specified, then target and build default to host.
 613
 614 # The aliases save the names the user supplied, while $host etc.
 615 # will get canonicalized.
 616 case $host---$target---$nonopt in
 617 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 618 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 619 esac
 620
 621
 622 # Make sure we can run config.sub.
 623 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 624 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 625 fi
 626
 627 echo $ac_n "checking host system type""... $ac_c" 1>&6
 628 echo "configure:629: checking host system type" >&5
 629
 630 host_alias=$host
 631 case "$host_alias" in
 632 NONE)
 633   case $nonopt in
 634   NONE)
 635     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 636     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 637     fi ;;
 638   *) host_alias=$nonopt ;;
 639   esac ;;
 640 esac
 641
 642 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 643 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 644 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 645 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 646 echo "$ac_t""$host" 1>&6
 647
 648 echo $ac_n "checking target system type""... $ac_c" 1>&6
 649 echo "configure:650: checking target system type" >&5
 650
 651 target_alias=$target
 652 case "$target_alias" in
 653 NONE)
 654   case $nonopt in
 655   NONE) target_alias=$host_alias ;;
 656   *) target_alias=$nonopt ;;
 657   esac ;;
 658 esac
 659
 660 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 661 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 662 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 663 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 664 echo "$ac_t""$target" 1>&6
 665
 666 echo $ac_n "checking build system type""... $ac_c" 1>&6
 667 echo "configure:668: checking build system type" >&5
 668
 669 build_alias=$build
 670 case "$build_alias" in
 671 NONE)
 672   case $nonopt in
 673   NONE) build_alias=$host_alias ;;
 674   *) build_alias=$nonopt ;;
 675   esac ;;
 676 esac
 677
 678 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 679 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 680 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 681 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 682 echo "$ac_t""$build" 1>&6
 683
 684 test "$host_alias" != "$target_alias" &&
 685   test "$program_prefix$program_suffix$program_transform_name" = \
 686     NONENONEs,x,x, &&
 687   program_prefix=${target_alias}-
 688
 689
 690 # We use these options to decide which functions to include.
 691 # Check whether --with-target-subdir or --without-target-subdir was given.
 692 if test "${with_target_subdir+set}" = set; then
 693   withval="$with_target_subdir"
 694   :
 695 fi
 696
 697 # Check whether --with-cross-host or --without-cross-host was given.
 698 if test "${with_cross_host+set}" = set; then
 699   withval="$with_cross_host"
 700   :
 701 fi
 702
 703
 704 # Find a good install program.  We prefer a C program (faster),
 705 # so one script is as good as another.  But avoid the broken or
 706 # incompatible versions:
 707 # SysV /etc/install, /usr/sbin/install
 708 # SunOS /usr/etc/install
 709 # IRIX /sbin/install
 710 # AIX /bin/install
 711 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 712 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 713 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 714 # ./install, which can be erroneously created by make from ./install.sh.
 715 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 716 echo "configure:717: checking for a BSD compatible install" >&5
 717 if test -z "$INSTALL"; then
 718 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 719   echo $ac_n "(cached) $ac_c" 1>&6
 720 else
 721     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 722   for ac_dir in $PATH; do
 723     # Account for people who put trailing slashes in PATH elements.
 724     case "$ac_dir/" in
 725     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 726     *)
 727       # OSF1 and SCO ODT 3.0 have their own names for install.
 728       # Don't use installbsd from OSF since it installs stuff as root
 729       # by default.
 730       for ac_prog in ginstall scoinst install; do
 731         if test -f $ac_dir/$ac_prog; then
 732           if test $ac_prog = install &&
 733             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 734             # AIX install.  It has an incompatible calling convention.
 735             :
 736           else
 737             ac_cv_path_install="$ac_dir/$ac_prog -c"
 738             break 2
 739           fi
 740         fi
 741       done
 742       ;;
 743     esac
 744   done
 745   IFS="$ac_save_IFS"
 746
 747 fi
 748   if test "${ac_cv_path_install+set}" = set; then
 749     INSTALL="$ac_cv_path_install"
 750   else
 751     # As a last resort, use the slow shell script.  We don't cache a
 752     # path for INSTALL within a source directory, because that will
 753     # break other packages using the cache if that directory is
 754     # removed, or if the path is relative.
 755     INSTALL="$ac_install_sh"
 756   fi
 757 fi
 758 echo "$ac_t""$INSTALL" 1>&6
 759
 760 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 761 # It thinks the first close brace ends the variable substitution.
 762 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 763
 764 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 765
 766 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 767
 768 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 769 echo "configure:770: checking whether build environment is sane" >&5
 770 # Just in case
 771 sleep 1
 772 echo timestamp > conftestfile
 773 # Do `set' in a subshell so we don't clobber the current shell's
 774 # arguments.  Must try -L first in case configure is actually a
 775 # symlink; some systems play weird games with the mod time of symlinks
 776 # (eg FreeBSD returns the mod time of the symlink's containing
 777 # directory).
 778 if (
 779    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 780    if test "$*" = "X"; then
 781       # -L didn't work.
 782       set X `ls -t $srcdir/configure conftestfile`
 783    fi
 784    if test "$*" != "X $srcdir/configure conftestfile" \
 785       && test "$*" != "X conftestfile $srcdir/configure"; then
 786
 787       # If neither matched, then we have a broken ls.  This can happen
 788       # if, for instance, CONFIG_SHELL is bash and it inherits a
 789       # broken ls alias from the environment.  This has actually
 790       # happened.  Such a system could not be considered "sane".
 791       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 792 alias in your environment" 1>&2; exit 1; }
 793    fi
 794
 795    test "$2" = conftestfile
 796    )
 797 then
 798    # Ok.
 799    :
 800 else
 801    { echo "configure: error: newly created file is older than distributed files!
 802 Check your system clock" 1>&2; exit 1; }
 803 fi
 804 rm -f conftest*
 805 echo "$ac_t""yes" 1>&6
 806 if test "$program_transform_name" = s,x,x,; then
 807   program_transform_name=
 808 else
 809   # Double any \ or $.  echo might interpret backslashes.
 810   cat <<\EOF_SED > conftestsed
 811 s,\\,\\\\,g; s,\$,$$,g
 812 EOF_SED
 813   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 814   rm -f conftestsed
 815 fi
 816 test "$program_prefix" != NONE &&
 817   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 818 # Use a double $ so make ignores it.
 819 test "$program_suffix" != NONE &&
 820   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 821
 822 # sed with no file args requires a program.
 823 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 824
 825 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 826 echo "configure:827: checking whether ${MAKE-make} sets \${MAKE}" >&5
 827 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 828 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 829   echo $ac_n "(cached) $ac_c" 1>&6
 830 else
 831   cat > conftestmake <<\EOF
 832 all:
 833         @echo 'ac_maketemp="${MAKE}"'
 834 EOF
 835 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 836 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 837 if test -n "$ac_maketemp"; then
 838   eval ac_cv_prog_make_${ac_make}_set=yes
 839 else
 840   eval ac_cv_prog_make_${ac_make}_set=no
 841 fi
 842 rm -f conftestmake
 843 fi
 844 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 845   echo "$ac_t""yes" 1>&6
 846   SET_MAKE=
 847 else
 848   echo "$ac_t""no" 1>&6
 849   SET_MAKE="MAKE=${MAKE-make}"
 850 fi
 851
 852 if test $host != $build; then
 853   ac_tool_prefix=${host_alias}-
 854 else
 855   ac_tool_prefix=
 856 fi
 857
 858 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 859 echo "configure:860: checking for Cygwin environment" >&5
 860 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 861   echo $ac_n "(cached) $ac_c" 1>&6
 862 else
 863   cat > conftest.$ac_ext <<EOF
 864 #line 865 "configure"
 865 #include "confdefs.h"
 866
 867 int main() {
 868
 869 #ifndef __CYGWIN__
 870 #define __CYGWIN__ __CYGWIN32__
 871 #endif
 872 return __CYGWIN__;
 873 ; return 0; }
 874 EOF
 875 if { (eval echo configure:876: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 876   rm -rf conftest*
 877   ac_cv_cygwin=yes
 878 else
 879   echo "configure: failed program was:" >&5
 880   cat conftest.$ac_ext >&5
 881   rm -rf conftest*
 882   ac_cv_cygwin=no
 883 fi
 884 rm -f conftest*
 885 rm -f conftest*
 886 fi
 887
 888 echo "$ac_t""$ac_cv_cygwin" 1>&6
 889 CYGWIN=
 890 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 891 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 892 echo "configure:893: checking for mingw32 environment" >&5
 893 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 894   echo $ac_n "(cached) $ac_c" 1>&6
 895 else
 896   cat > conftest.$ac_ext <<EOF
 897 #line 898 "configure"
 898 #include "confdefs.h"
 899
 900 int main() {
 901 return __MINGW32__;
 902 ; return 0; }
 903 EOF
 904 if { (eval echo configure:905: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 905   rm -rf conftest*
 906   ac_cv_mingw32=yes
 907 else
 908   echo "configure: failed program was:" >&5
 909   cat conftest.$ac_ext >&5
 910   rm -rf conftest*
 911   ac_cv_mingw32=no
 912 fi
 913 rm -f conftest*
 914 rm -f conftest*
 915 fi
 916
 917 echo "$ac_t""$ac_cv_mingw32" 1>&6
 918 MINGW32=
 919 test "$ac_cv_mingw32" = yes && MINGW32=yes
 920
 921     # Check whether --enable-multilib or --disable-multilib was given.
 922 if test "${enable_multilib+set}" = set; then
 923   enableval="$enable_multilib"
 924   case "${enableval}" in
 925     yes) multilib=yes ;;
 926     no)  multilib=no ;;
 927     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 928    esac
 929 else
 930   multilib=yes
 931 fi
 932
 933       if test "${srcdir}" = "."; then
 934     if test "${with_target_subdir}" != "."; then
 935       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 936     else
 937       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 938     fi
 939   else
 940     glibcpp_basedir="${srcdir}/."
 941   fi
 942
 943
 944
 945 PACKAGE=libstdc++
 946
 947 VERSION=2.90.8
 948
 949 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 950   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 951 fi
 952 cat >> confdefs.h <<EOF
 953 #define PACKAGE "$PACKAGE"
 954 EOF
 955
 956 cat >> confdefs.h <<EOF
 957 #define VERSION "$VERSION"
 958 EOF
 959
 960
 961
 962 missing_dir=`cd $ac_aux_dir && pwd`
 963 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 964 echo "configure:965: checking for working aclocal" >&5
 965 # Run test in a subshell; some versions of sh will print an error if
 966 # an executable is not found, even if stderr is redirected.
 967 # Redirect stdin to placate older versions of autoconf.  Sigh.
 968 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 969    ACLOCAL=aclocal
 970    echo "$ac_t""found" 1>&6
 971 else
 972    ACLOCAL="$missing_dir/missing aclocal"
 973    echo "$ac_t""missing" 1>&6
 974 fi
 975
 976 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 977 echo "configure:978: checking for working autoconf" >&5
 978 # Run test in a subshell; some versions of sh will print an error if
 979 # an executable is not found, even if stderr is redirected.
 980 # Redirect stdin to placate older versions of autoconf.  Sigh.
 981 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 982    AUTOCONF=autoconf
 983    echo "$ac_t""found" 1>&6
 984 else
 985    AUTOCONF="$missing_dir/missing autoconf"
 986    echo "$ac_t""missing" 1>&6
 987 fi
 988
 989 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 990 echo "configure:991: checking for working automake" >&5
 991 # Run test in a subshell; some versions of sh will print an error if
 992 # an executable is not found, even if stderr is redirected.
 993 # Redirect stdin to placate older versions of autoconf.  Sigh.
 994 if (automake --version) < /dev/null > /dev/null 2>&1; then
 995    AUTOMAKE=automake
 996    echo "$ac_t""found" 1>&6
 997 else
 998    AUTOMAKE="$missing_dir/missing automake"
 999    echo "$ac_t""missing" 1>&6
1000 fi
1001
1002 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
1003 echo "configure:1004: checking for working autoheader" >&5
1004 # Run test in a subshell; some versions of sh will print an error if
1005 # an executable is not found, even if stderr is redirected.
1006 # Redirect stdin to placate older versions of autoconf.  Sigh.
1007 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
1008    AUTOHEADER=autoheader
1009    echo "$ac_t""found" 1>&6
1010 else
1011    AUTOHEADER="$missing_dir/missing autoheader"
1012    echo "$ac_t""missing" 1>&6
1013 fi
1014
1015 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1016 echo "configure:1017: checking for working makeinfo" >&5
1017 # Run test in a subshell; some versions of sh will print an error if
1018 # an executable is not found, even if stderr is redirected.
1019 # Redirect stdin to placate older versions of autoconf.  Sigh.
1020 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1021    MAKEINFO=makeinfo
1022    echo "$ac_t""found" 1>&6
1023 else
1024    MAKEINFO="$missing_dir/missing makeinfo"
1025    echo "$ac_t""missing" 1>&6
1026 fi
1027
1028
1029
1030   # Never versions of autoconf add an underscore to these functions.
1031   # Prevent future problems ...
1032
1033
1034
1035
1036
1037 #  AC_PROG_CC
1038
1039 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1040 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1041 # are probably using a cross compiler, which will not be able to fully
1042 # link an executable.  This should really be fixed in autoconf
1043 # itself.
1044
1045
1046
1047
1048 # Extract the first word of "gcc", so it can be a program name with args.
1049 set dummy gcc; ac_word=$2
1050 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1051 echo "configure:1052: checking for $ac_word" >&5
1052 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1053   echo $ac_n "(cached) $ac_c" 1>&6
1054 else
1055   if test -n "$CC"; then
1056   ac_cv_prog_CC="$CC" # Let the user override the test.
1057 else
1058   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1059   ac_dummy="$PATH"
1060   for ac_dir in $ac_dummy; do
1061     test -z "$ac_dir" && ac_dir=.
1062     if test -f $ac_dir/$ac_word; then
1063       ac_cv_prog_CC="gcc"
1064       break
1065     fi
1066   done
1067   IFS="$ac_save_ifs"
1068 fi
1069 fi
1070 CC="$ac_cv_prog_CC"
1071 if test -n "$CC"; then
1072   echo "$ac_t""$CC" 1>&6
1073 else
1074   echo "$ac_t""no" 1>&6
1075 fi
1076
1077 if test -z "$CC"; then
1078   # Extract the first word of "cc", so it can be a program name with args.
1079 set dummy cc; ac_word=$2
1080 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1081 echo "configure:1082: checking for $ac_word" >&5
1082 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1083   echo $ac_n "(cached) $ac_c" 1>&6
1084 else
1085   if test -n "$CC"; then
1086   ac_cv_prog_CC="$CC" # Let the user override the test.
1087 else
1088   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1089   ac_prog_rejected=no
1090   ac_dummy="$PATH"
1091   for ac_dir in $ac_dummy; do
1092     test -z "$ac_dir" && ac_dir=.
1093     if test -f $ac_dir/$ac_word; then
1094       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1095         ac_prog_rejected=yes
1096         continue
1097       fi
1098       ac_cv_prog_CC="cc"
1099       break
1100     fi
1101   done
1102   IFS="$ac_save_ifs"
1103 if test $ac_prog_rejected = yes; then
1104   # We found a bogon in the path, so make sure we never use it.
1105   set dummy $ac_cv_prog_CC
1106   shift
1107   if test $# -gt 0; then
1108     # We chose a different compiler from the bogus one.
1109     # However, it has the same basename, so the bogon will be chosen
1110     # first if we set CC to just the basename; use the full file name.
1111     shift
1112     set dummy "$ac_dir/$ac_word" "$@"
1113     shift
1114     ac_cv_prog_CC="$@"
1115   fi
1116 fi
1117 fi
1118 fi
1119 CC="$ac_cv_prog_CC"
1120 if test -n "$CC"; then
1121   echo "$ac_t""$CC" 1>&6
1122 else
1123   echo "$ac_t""no" 1>&6
1124 fi
1125
1126   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1127 fi
1128
1129 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1130 echo "configure:1131: checking whether we are using GNU C" >&5
1131 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1132   echo $ac_n "(cached) $ac_c" 1>&6
1133 else
1134   cat > conftest.c <<EOF
1135 #ifdef __GNUC__
1136   yes;
1137 #endif
1138 EOF
1139 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1140: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1140   ac_cv_prog_gcc=yes
1141 else
1142   ac_cv_prog_gcc=no
1143 fi
1144 fi
1145
1146 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1147
1148 if test $ac_cv_prog_gcc = yes; then
1149   GCC=yes
1150   ac_test_CFLAGS="${CFLAGS+set}"
1151   ac_save_CFLAGS="$CFLAGS"
1152   CFLAGS=
1153   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1154 echo "configure:1155: checking whether ${CC-cc} accepts -g" >&5
1155 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1156   echo $ac_n "(cached) $ac_c" 1>&6
1157 else
1158   echo 'void f(){}' > conftest.c
1159 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1160   ac_cv_prog_cc_g=yes
1161 else
1162   ac_cv_prog_cc_g=no
1163 fi
1164 rm -f conftest*
1165
1166 fi
1167
1168 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1169   if test "$ac_test_CFLAGS" = set; then
1170     CFLAGS="$ac_save_CFLAGS"
1171   elif test $ac_cv_prog_cc_g = yes; then
1172     CFLAGS="-g -O2"
1173   else
1174     CFLAGS="-O2"
1175   fi
1176 else
1177   GCC=
1178   test "${CFLAGS+set}" = set || CFLAGS="-g"
1179 fi
1180
1181
1182 # Can't just call these here as g++ requires libstc++ to be built....
1183 #  AC_PROG_CXX
1184
1185 # Likewise for AC_PROG_CXX.
1186
1187
1188
1189 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1190 # flags that come in CXX while configuring libstdc++.  They're different
1191 # from those used for all other target libraries.
1192 for ac_prog in "$CXX" "$CCC" c++ g++ gcc CC cxx cc++
1193 do
1194 # Extract the first word of "$ac_prog", so it can be a program name with args.
1195 set dummy $ac_prog; ac_word=$2
1196 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1197 echo "configure:1198: checking for $ac_word" >&5
1198 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1199   echo $ac_n "(cached) $ac_c" 1>&6
1200 else
1201   if test -n "$CXX_libstdcxx"; then
1202   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1203 else
1204   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1205   ac_dummy="$PATH"
1206   for ac_dir in $ac_dummy; do
1207     test -z "$ac_dir" && ac_dir=.
1208     if test -f $ac_dir/$ac_word; then
1209       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1210       break
1211     fi
1212   done
1213   IFS="$ac_save_ifs"
1214 fi
1215 fi
1216 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1217 if test -n "$CXX_libstdcxx"; then
1218   echo "$ac_t""$CXX_libstdcxx" 1>&6
1219 else
1220   echo "$ac_t""no" 1>&6
1221 fi
1222
1223 test -n "$CXX_libstdcxx" && break
1224 done
1225 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1226
1227 CXX=$CXX_libstdcxx
1228
1229 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1230
1231 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1232 echo "configure:1233: checking whether we are using GNU C++" >&5
1233 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1234   echo $ac_n "(cached) $ac_c" 1>&6
1235 else
1236   cat > conftest.C <<EOF
1237 #ifdef __GNUC__
1238   yes;
1239 #endif
1240 EOF
1241 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1242: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1242   ac_cv_prog_gxx=yes
1243 else
1244   ac_cv_prog_gxx=no
1245 fi
1246 fi
1247
1248 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1249
1250 if test $ac_cv_prog_gxx = yes; then
1251   GXX=yes
1252   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1253   ac_save_CXXFLAGS="$CXXFLAGS"
1254   CXXFLAGS=
1255   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1256 echo "configure:1257: checking whether ${CXX-g++} accepts -g" >&5
1257 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1258   echo $ac_n "(cached) $ac_c" 1>&6
1259 else
1260   echo 'void f(){}' > conftest.cc
1261 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1262   ac_cv_prog_cxx_g=yes
1263 else
1264   ac_cv_prog_cxx_g=no
1265 fi
1266 rm -f conftest*
1267
1268 fi
1269
1270 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1271   if test "$ac_test_CXXFLAGS" = set; then
1272     CXXFLAGS="$ac_save_CXXFLAGS"
1273   elif test $ac_cv_prog_cxx_g = yes; then
1274     CXXFLAGS="-g -O2"
1275   else
1276     CXXFLAGS="-O2"
1277   fi
1278 else
1279   GXX=
1280   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1281 fi
1282
1283
1284   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1285 set dummy ${ac_tool_prefix}as; ac_word=$2
1286 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1287 echo "configure:1288: checking for $ac_word" >&5
1288 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1289   echo $ac_n "(cached) $ac_c" 1>&6
1290 else
1291   if test -n "$AS"; then
1292   ac_cv_prog_AS="$AS" # Let the user override the test.
1293 else
1294   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1295   ac_dummy="$PATH"
1296   for ac_dir in $ac_dummy; do
1297     test -z "$ac_dir" && ac_dir=.
1298     if test -f $ac_dir/$ac_word; then
1299       ac_cv_prog_AS="${ac_tool_prefix}as"
1300       break
1301     fi
1302   done
1303   IFS="$ac_save_ifs"
1304   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1305 fi
1306 fi
1307 AS="$ac_cv_prog_AS"
1308 if test -n "$AS"; then
1309   echo "$ac_t""$AS" 1>&6
1310 else
1311   echo "$ac_t""no" 1>&6
1312 fi
1313
1314
1315
1316   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1317 set dummy ${ac_tool_prefix}ar; ac_word=$2
1318 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1319 echo "configure:1320: checking for $ac_word" >&5
1320 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1321   echo $ac_n "(cached) $ac_c" 1>&6
1322 else
1323   if test -n "$AR"; then
1324   ac_cv_prog_AR="$AR" # Let the user override the test.
1325 else
1326   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1327   ac_dummy="$PATH"
1328   for ac_dir in $ac_dummy; do
1329     test -z "$ac_dir" && ac_dir=.
1330     if test -f $ac_dir/$ac_word; then
1331       ac_cv_prog_AR="${ac_tool_prefix}ar"
1332       break
1333     fi
1334   done
1335   IFS="$ac_save_ifs"
1336   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1337 fi
1338 fi
1339 AR="$ac_cv_prog_AR"
1340 if test -n "$AR"; then
1341   echo "$ac_t""$AR" 1>&6
1342 else
1343   echo "$ac_t""no" 1>&6
1344 fi
1345
1346
1347
1348   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1349 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1350 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1351 echo "configure:1352: checking for $ac_word" >&5
1352 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1353   echo $ac_n "(cached) $ac_c" 1>&6
1354 else
1355   if test -n "$RANLIB"; then
1356   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1357 else
1358   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1359   ac_dummy="$PATH"
1360   for ac_dir in $ac_dummy; do
1361     test -z "$ac_dir" && ac_dir=.
1362     if test -f $ac_dir/$ac_word; then
1363       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1364       break
1365     fi
1366   done
1367   IFS="$ac_save_ifs"
1368 fi
1369 fi
1370 RANLIB="$ac_cv_prog_RANLIB"
1371 if test -n "$RANLIB"; then
1372   echo "$ac_t""$RANLIB" 1>&6
1373 else
1374   echo "$ac_t""no" 1>&6
1375 fi
1376
1377
1378 if test -z "$ac_cv_prog_RANLIB"; then
1379 if test -n "$ac_tool_prefix"; then
1380   # Extract the first word of "ranlib", so it can be a program name with args.
1381 set dummy ranlib; ac_word=$2
1382 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1383 echo "configure:1384: checking for $ac_word" >&5
1384 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1385   echo $ac_n "(cached) $ac_c" 1>&6
1386 else
1387   if test -n "$RANLIB"; then
1388   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1389 else
1390   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1391   ac_dummy="$PATH"
1392   for ac_dir in $ac_dummy; do
1393     test -z "$ac_dir" && ac_dir=.
1394     if test -f $ac_dir/$ac_word; then
1395       ac_cv_prog_RANLIB="ranlib"
1396       break
1397     fi
1398   done
1399   IFS="$ac_save_ifs"
1400   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1401 fi
1402 fi
1403 RANLIB="$ac_cv_prog_RANLIB"
1404 if test -n "$RANLIB"; then
1405   echo "$ac_t""$RANLIB" 1>&6
1406 else
1407   echo "$ac_t""no" 1>&6
1408 fi
1409
1410 else
1411   RANLIB=":"
1412 fi
1413 fi
1414
1415
1416   # Find a good install program.  We prefer a C program (faster),
1417 # so one script is as good as another.  But avoid the broken or
1418 # incompatible versions:
1419 # SysV /etc/install, /usr/sbin/install
1420 # SunOS /usr/etc/install
1421 # IRIX /sbin/install
1422 # AIX /bin/install
1423 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1424 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1425 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1426 # ./install, which can be erroneously created by make from ./install.sh.
1427 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1428 echo "configure:1429: checking for a BSD compatible install" >&5
1429 if test -z "$INSTALL"; then
1430 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1431   echo $ac_n "(cached) $ac_c" 1>&6
1432 else
1433     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1434   for ac_dir in $PATH; do
1435     # Account for people who put trailing slashes in PATH elements.
1436     case "$ac_dir/" in
1437     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1438     *)
1439       # OSF1 and SCO ODT 3.0 have their own names for install.
1440       # Don't use installbsd from OSF since it installs stuff as root
1441       # by default.
1442       for ac_prog in ginstall scoinst install; do
1443         if test -f $ac_dir/$ac_prog; then
1444           if test $ac_prog = install &&
1445             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1446             # AIX install.  It has an incompatible calling convention.
1447             :
1448           else
1449             ac_cv_path_install="$ac_dir/$ac_prog -c"
1450             break 2
1451           fi
1452         fi
1453       done
1454       ;;
1455     esac
1456   done
1457   IFS="$ac_save_IFS"
1458
1459 fi
1460   if test "${ac_cv_path_install+set}" = set; then
1461     INSTALL="$ac_cv_path_install"
1462   else
1463     # As a last resort, use the slow shell script.  We don't cache a
1464     # path for INSTALL within a source directory, because that will
1465     # break other packages using the cache if that directory is
1466     # removed, or if the path is relative.
1467     INSTALL="$ac_install_sh"
1468   fi
1469 fi
1470 echo "$ac_t""$INSTALL" 1>&6
1471
1472 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1473 # It thinks the first close brace ends the variable substitution.
1474 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1475
1476 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1477
1478 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1479
1480
1481   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1482 echo "configure:1483: checking whether to enable maintainer-specific portions of Makefiles" >&5
1483     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1484 if test "${enable_maintainer_mode+set}" = set; then
1485   enableval="$enable_maintainer_mode"
1486   USE_MAINTAINER_MODE=$enableval
1487 else
1488   USE_MAINTAINER_MODE=no
1489 fi
1490
1491   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1492
1493
1494 if test $USE_MAINTAINER_MODE = yes; then
1495   MAINTAINER_MODE_TRUE=
1496   MAINTAINER_MODE_FALSE='#'
1497 else
1498   MAINTAINER_MODE_TRUE='#'
1499   MAINTAINER_MODE_FALSE=
1500 fi
1501   MAINT=$MAINTAINER_MODE_TRUE
1502
1503
1504
1505   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1506   # at least currently, we never actually build a program, so we never
1507   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1508   # fails, because we are probably configuring with a cross compiler
1509   # which cant create executables.  So we include AC_EXEEXT to keep
1510   # automake happy, but we dont execute it, since we dont care about
1511   # the result.
1512   if false; then
1513
1514
1515 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1516 echo "configure:1517: checking for executable suffix" >&5
1517 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1518   echo $ac_n "(cached) $ac_c" 1>&6
1519 else
1520   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1521   ac_cv_exeext=.exe
1522 else
1523   rm -f conftest*
1524   echo 'int main () { return 0; }' > conftest.$ac_ext
1525   ac_cv_exeext=
1526   if { (eval echo configure:1527: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1527     for file in conftest.*; do
1528       case $file in
1529       *.c | *.o | *.obj | *.ilk | *.pdb) ;;
1530       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1531       esac
1532     done
1533   else
1534     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1535   fi
1536   rm -f conftest*
1537   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1538 fi
1539 fi
1540
1541 EXEEXT=""
1542 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1543 echo "$ac_t""${ac_cv_exeext}" 1>&6
1544 ac_exeext=$EXEEXT
1545
1546   fi
1547
1548   # configure.host sets the following important variables
1549   #        glibcpp_cflags    - host specific C compiler flags
1550   #        glibcpp_cxxflags  - host specific C++ compiler flags
1551   glibcpp_cflags=
1552   glibcpp_cxxflags=
1553
1554   . ${glibcpp_basedir}/configure.host
1555
1556   case ${glibcpp_basedir} in
1557     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1558     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1559   esac
1560
1561   GLIBCPP_CFLAGS="${glibcpp_cflags}"
1562   GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1563
1564
1565
1566
1567 # Check whether --enable-shared or --disable-shared was given.
1568 if test "${enable_shared+set}" = set; then
1569   enableval="$enable_shared"
1570   p=${PACKAGE-default}
1571 case "$enableval" in
1572 yes) enable_shared=yes ;;
1573 no) enable_shared=no ;;
1574 *)
1575   enable_shared=no
1576   # Look at the argument we got.  We use all the common list separators.
1577   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1578   for pkg in $enableval; do
1579     if test "X$pkg" = "X$p"; then
1580       enable_shared=yes
1581     fi
1582   done
1583   IFS="$ac_save_ifs"
1584   ;;
1585 esac
1586 else
1587   enable_shared=yes
1588 fi
1589
1590 # Check whether --enable-static or --disable-static was given.
1591 if test "${enable_static+set}" = set; then
1592   enableval="$enable_static"
1593   p=${PACKAGE-default}
1594 case "$enableval" in
1595 yes) enable_static=yes ;;
1596 no) enable_static=no ;;
1597 *)
1598   enable_static=no
1599   # Look at the argument we got.  We use all the common list separators.
1600   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1601   for pkg in $enableval; do
1602     if test "X$pkg" = "X$p"; then
1603       enable_static=yes
1604     fi
1605   done
1606   IFS="$ac_save_ifs"
1607   ;;
1608 esac
1609 else
1610   enable_static=yes
1611 fi
1612
1613 # Check whether --enable-fast-install or --disable-fast-install was given.
1614 if test "${enable_fast_install+set}" = set; then
1615   enableval="$enable_fast_install"
1616   p=${PACKAGE-default}
1617 case "$enableval" in
1618 yes) enable_fast_install=yes ;;
1619 no) enable_fast_install=no ;;
1620 *)
1621   enable_fast_install=no
1622   # Look at the argument we got.  We use all the common list separators.
1623   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1624   for pkg in $enableval; do
1625     if test "X$pkg" = "X$p"; then
1626       enable_fast_install=yes
1627     fi
1628   done
1629   IFS="$ac_save_ifs"
1630   ;;
1631 esac
1632 else
1633   enable_fast_install=yes
1634 fi
1635
1636 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1637 if test "${with_gnu_ld+set}" = set; then
1638   withval="$with_gnu_ld"
1639   test "$withval" = no || with_gnu_ld=yes
1640 else
1641   with_gnu_ld=no
1642 fi
1643
1644 ac_prog=ld
1645 if test "$ac_cv_prog_gcc" = yes; then
1646   # Check if gcc -print-prog-name=ld gives a path.
1647   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1648 echo "configure:1649: checking for ld used by GCC" >&5
1649   case $host in
1650   *-*-mingw*)
1651     # gcc leaves a trailing carriage return which upsets mingw
1652     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
1653   *)
1654     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
1655   esac
1656   case "$ac_prog" in
1657     # Accept absolute paths.
1658     [\\/]* | [A-Za-z]:[\\/]*)
1659       re_direlt='/[^/][^/]*/\.\./'
1660       # Canonicalize the path of ld
1661       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1662       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1663         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1664       done
1665       test -z "$LD" && LD="$ac_prog"
1666       ;;
1667   "")
1668     # If it fails, then pretend we aren't using GCC.
1669     ac_prog=ld
1670     ;;
1671   *)
1672     # If it is relative, then search for the first ld in PATH.
1673     with_gnu_ld=unknown
1674     ;;
1675   esac
1676 elif test "$with_gnu_ld" = yes; then
1677   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1678 echo "configure:1679: checking for GNU ld" >&5
1679 else
1680   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1681 echo "configure:1682: checking for non-GNU ld" >&5
1682 fi
1683 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1684   echo $ac_n "(cached) $ac_c" 1>&6
1685 else
1686   if test -z "$LD"; then
1687   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1688   for ac_dir in $PATH; do
1689     test -z "$ac_dir" && ac_dir=.
1690     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1691       ac_cv_path_LD="$ac_dir/$ac_prog"
1692       # Check to see if the program is GNU ld.  I'd rather use --version,
1693       # but apparently some GNU ld's only accept -v.
1694       # Break only if it was the GNU/non-GNU ld that we prefer.
1695       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1696         test "$with_gnu_ld" != no && break
1697       else
1698         test "$with_gnu_ld" != yes && break
1699       fi
1700     fi
1701   done
1702   IFS="$ac_save_ifs"
1703 else
1704   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1705 fi
1706 fi
1707
1708 LD="$ac_cv_path_LD"
1709 if test -n "$LD"; then
1710   echo "$ac_t""$LD" 1>&6
1711 else
1712   echo "$ac_t""no" 1>&6
1713 fi
1714 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1715 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1716 echo "configure:1717: checking if the linker ($LD) is GNU ld" >&5
1717 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1718   echo $ac_n "(cached) $ac_c" 1>&6
1719 else
1720   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1721 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1722   ac_cv_prog_gnu_ld=yes
1723 else
1724   ac_cv_prog_gnu_ld=no
1725 fi
1726 fi
1727
1728 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1729 with_gnu_ld=$ac_cv_prog_gnu_ld
1730
1731
1732 echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6
1733 echo "configure:1734: checking for $LD option to reload object files" >&5
1734 if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then
1735   echo $ac_n "(cached) $ac_c" 1>&6
1736 else
1737   lt_cv_ld_reload_flag='-r'
1738 fi
1739
1740 echo "$ac_t""$lt_cv_ld_reload_flag" 1>&6
1741 reload_flag=$lt_cv_ld_reload_flag
1742 test -n "$reload_flag" && reload_flag=" $reload_flag"
1743
1744 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1745 echo "configure:1746: checking for BSD-compatible nm" >&5
1746 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1747   echo $ac_n "(cached) $ac_c" 1>&6
1748 else
1749   if test -n "$NM"; then
1750   # Let the user override the test.
1751   ac_cv_path_NM="$NM"
1752 else
1753   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1754   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1755     test -z "$ac_dir" && ac_dir=.
1756     tmp_nm=$ac_dir/${ac_tool_prefix}nm
1757     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
1758       # Check to see if the nm accepts a BSD-compat flag.
1759       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1760       #   nm: unknown option "B" ignored
1761       # Tru64's nm complains that /dev/null is an invalid object file
1762       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
1763         ac_cv_path_NM="$tmp_nm -B"
1764         break
1765       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1766         ac_cv_path_NM="$tmp_nm -p"
1767         break
1768       else
1769         ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
1770         continue # so that we can try to find one that supports BSD flags
1771       fi
1772     fi
1773   done
1774   IFS="$ac_save_ifs"
1775   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1776 fi
1777 fi
1778
1779 NM="$ac_cv_path_NM"
1780 echo "$ac_t""$NM" 1>&6
1781
1782 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1783 echo "configure:1784: checking whether ln -s works" >&5
1784 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1785   echo $ac_n "(cached) $ac_c" 1>&6
1786 else
1787   rm -f conftestdata
1788 if ln -s X conftestdata 2>/dev/null
1789 then
1790   rm -f conftestdata
1791   ac_cv_prog_LN_S="ln -s"
1792 else
1793   ac_cv_prog_LN_S=ln
1794 fi
1795 fi
1796 LN_S="$ac_cv_prog_LN_S"
1797 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1798   echo "$ac_t""yes" 1>&6
1799 else
1800   echo "$ac_t""no" 1>&6
1801 fi
1802
1803 echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6
1804 echo "configure:1805: checking how to recognise dependant libraries" >&5
1805 if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then
1806   echo $ac_n "(cached) $ac_c" 1>&6
1807 else
1808   lt_cv_file_magic_cmd='$MAGIC_CMD'
1809 lt_cv_file_magic_test_file=
1810 lt_cv_deplibs_check_method='unknown'
1811 # Need to set the preceding variable on all platforms that support
1812 # interlibrary dependencies.
1813 # 'none' -- dependencies not supported.
1814 # `unknown' -- same as none, but documents that we really don't know.
1815 # 'pass_all' -- all dependencies passed with no checks.
1816 # 'test_compile' -- check by making test program.
1817 # 'file_magic [regex]' -- check by looking for files in library path
1818 # which responds to the $file_magic_cmd with a given egrep regex.
1819 # If you have `file' or equivalent on your system and you're not sure
1820 # whether `pass_all' will *always* work, you probably want this one.
1821
1822 case "$host_os" in
1823 aix4*)
1824   lt_cv_deplibs_check_method=pass_all
1825   ;;
1826
1827 beos*)
1828   lt_cv_deplibs_check_method=pass_all
1829   ;;
1830
1831 bsdi4*)
1832     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
1833     lt_cv_file_magic_cmd='/usr/bin/file -L'
1834   lt_cv_file_magic_test_file=/shlib/libc.so
1835   ;;
1836
1837 cygwin* | mingw* |pw32*)
1838   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
1839   lt_cv_file_magic_cmd='$OBJDUMP -f'
1840   ;;
1841
1842 freebsd* )
1843   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
1844     case "$host_cpu" in
1845     i*86 )
1846       # Not sure whether the presence of OpenBSD here was a mistake.
1847       # Let's accept both of them until this is cleared up.
1848             lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
1849             lt_cv_file_magic_cmd=/usr/bin/file
1850       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
1851       ;;
1852     esac
1853   else
1854     lt_cv_deplibs_check_method=pass_all
1855   fi
1856   ;;
1857
1858 gnu*)
1859   lt_cv_deplibs_check_method=pass_all
1860   ;;
1861
1862 hpux10.20*)
1863   # TODO:  Does this work for hpux-11 too?
1864   lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9.0-9) shared library'
1865   lt_cv_file_magic_cmd=/usr/bin/file
1866   lt_cv_file_magic_test_file=/usr/lib/libc.sl
1867   ;;
1868
1869 irix5* | irix6*)
1870   case "$host_os" in
1871   irix5*)
1872     # this will be overridden with pass_all, but let us keep it just in case
1873     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
1874     ;;
1875   *)
1876     case "$LD" in
1877     *-32|*"-32 ") libmagic=32-bit;;
1878     *-n32|*"-n32 ") libmagic=N32;;
1879     *-64|*"-64 ") libmagic=64-bit;;
1880     *) libmagic=never-match;;
1881     esac
1882     # this will be overridden with pass_all, but let us keep it just in case
1883         lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
1884         ;;
1885   esac
1886   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
1887   lt_cv_deplibs_check_method=pass_all
1888   ;;
1889
1890 # This must be Linux ELF.
1891 linux-gnu*)
1892   case "$host_cpu" in
1893   alpha* | i*86 | powerpc* | sparc* | ia64* )
1894     lt_cv_deplibs_check_method=pass_all ;;
1895   *)
1896     # glibc up to 2.1.1 does not perform some relocations on ARM
1897         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
1898       esac
1899   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
1900   ;;
1901
1902 netbsd*)
1903   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
1904   else
1905         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
1906         lt_cv_file_magic_cmd='/usr/bin/file -L'
1907     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1908   fi
1909   ;;
1910
1911 osf3* | osf4* | osf5*)
1912   # this will be overridden with pass_all, but let us keep it just in case
1913   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
1914   lt_cv_file_magic_test_file=/shlib/libc.so
1915   lt_cv_deplibs_check_method=pass_all
1916   ;;
1917
1918 sco3.2v5*)
1919   lt_cv_deplibs_check_method=pass_all
1920   ;;
1921
1922 solaris*)
1923   lt_cv_deplibs_check_method=pass_all
1924   lt_cv_file_magic_test_file=/lib/libc.so
1925   ;;
1926
1927 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
1928   case "$host_vendor" in
1929   ncr)
1930     lt_cv_deplibs_check_method=pass_all
1931     ;;
1932   motorola)
1933         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
1934         lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1935     ;;
1936   esac
1937   ;;
1938 esac
1939
1940 fi
1941
1942 echo "$ac_t""$lt_cv_deplibs_check_method" 1>&6
1943 file_magic_cmd=$lt_cv_file_magic_cmd
1944 deplibs_check_method=$lt_cv_deplibs_check_method
1945
1946 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
1947 echo "configure:1948: checking for object suffix" >&5
1948 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
1949   echo $ac_n "(cached) $ac_c" 1>&6
1950 else
1951   rm -f conftest*
1952 echo 'int i = 1;' > conftest.$ac_ext
1953 if { (eval echo configure:1954: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1954   for ac_file in conftest.*; do
1955     case $ac_file in
1956     *.c) ;;
1957     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
1958     esac
1959   done
1960 else
1961   { echo "configure: error: installation or configuration problem; compiler does not work" 1>&2; exit 1; }
1962 fi
1963 rm -f conftest*
1964 fi
1965
1966 echo "$ac_t""$ac_cv_objext" 1>&6
1967 OBJEXT=$ac_cv_objext
1968 ac_objext=$ac_cv_objext
1969
1970 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
1971
1972 # Only perform the check for file, if the check method requires it
1973 case "$deplibs_check_method" in
1974 file_magic*)
1975   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
1976     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
1977 echo "configure:1978: checking for ${ac_tool_prefix}file" >&5
1978 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
1979   echo $ac_n "(cached) $ac_c" 1>&6
1980 else
1981   case "$MAGIC_CMD" in
1982   /*)
1983   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
1984   ;;
1985   ?:/*)
1986   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
1987   ;;
1988   *)
1989   ac_save_MAGIC_CMD="$MAGIC_CMD"
1990   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1991   ac_dummy="/usr/bin:$PATH"
1992   for ac_dir in $ac_dummy; do
1993     test -z "$ac_dir" && ac_dir=.
1994     if test -f $ac_dir/${ac_tool_prefix}file; then
1995       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
1996       if test -n "$file_magic_test_file"; then
1997         case "$deplibs_check_method" in
1998         "file_magic "*)
1999           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2000           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2001           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2002             egrep "$file_magic_regex" > /dev/null; then
2003             :
2004           else
2005             cat <<EOF 1>&2
2006
2007 *** Warning: the command libtool uses to detect shared libraries,
2008 *** $file_magic_cmd, produces output that libtool cannot recognize.
2009 *** The result is that libtool may fail to recognize shared libraries
2010 *** as such.  This will affect the creation of libtool libraries that
2011 *** depend on shared libraries, but programs linked with such libtool
2012 *** libraries will work regardless of this problem.  Nevertheless, you
2013 *** may want to report the problem to your system manager and/or to
2014 *** bug-libtool@gnu.org
2015
2016 EOF
2017           fi ;;
2018         esac
2019       fi
2020       break
2021     fi
2022   done
2023   IFS="$ac_save_ifs"
2024   MAGIC_CMD="$ac_save_MAGIC_CMD"
2025   ;;
2026 esac
2027 fi
2028
2029 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2030 if test -n "$MAGIC_CMD"; then
2031   echo "$ac_t""$MAGIC_CMD" 1>&6
2032 else
2033   echo "$ac_t""no" 1>&6
2034 fi
2035
2036 if test -z "$lt_cv_path_MAGIC_CMD"; then
2037   if test -n "$ac_tool_prefix"; then
2038     echo $ac_n "checking for file""... $ac_c" 1>&6
2039 echo "configure:2040: checking for file" >&5
2040 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
2041   echo $ac_n "(cached) $ac_c" 1>&6
2042 else
2043   case "$MAGIC_CMD" in
2044   /*)
2045   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2046   ;;
2047   ?:/*)
2048   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
2049   ;;
2050   *)
2051   ac_save_MAGIC_CMD="$MAGIC_CMD"
2052   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2053   ac_dummy="/usr/bin:$PATH"
2054   for ac_dir in $ac_dummy; do
2055     test -z "$ac_dir" && ac_dir=.
2056     if test -f $ac_dir/file; then
2057       lt_cv_path_MAGIC_CMD="$ac_dir/file"
2058       if test -n "$file_magic_test_file"; then
2059         case "$deplibs_check_method" in
2060         "file_magic "*)
2061           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2062           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2063           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2064             egrep "$file_magic_regex" > /dev/null; then
2065             :
2066           else
2067             cat <<EOF 1>&2
2068
2069 *** Warning: the command libtool uses to detect shared libraries,
2070 *** $file_magic_cmd, produces output that libtool cannot recognize.
2071 *** The result is that libtool may fail to recognize shared libraries
2072 *** as such.  This will affect the creation of libtool libraries that
2073 *** depend on shared libraries, but programs linked with such libtool
2074 *** libraries will work regardless of this problem.  Nevertheless, you
2075 *** may want to report the problem to your system manager and/or to
2076 *** bug-libtool@gnu.org
2077
2078 EOF
2079           fi ;;
2080         esac
2081       fi
2082       break
2083     fi
2084   done
2085   IFS="$ac_save_ifs"
2086   MAGIC_CMD="$ac_save_MAGIC_CMD"
2087   ;;
2088 esac
2089 fi
2090
2091 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2092 if test -n "$MAGIC_CMD"; then
2093   echo "$ac_t""$MAGIC_CMD" 1>&6
2094 else
2095   echo "$ac_t""no" 1>&6
2096 fi
2097
2098   else
2099     MAGIC_CMD=:
2100   fi
2101 fi
2102
2103   fi
2104   ;;
2105 esac
2106
2107 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
2108 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
2109 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2110 echo "configure:2111: checking for $ac_word" >&5
2111 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2112   echo $ac_n "(cached) $ac_c" 1>&6
2113 else
2114   if test -n "$RANLIB"; then
2115   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2116 else
2117   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2118   ac_dummy="$PATH"
2119   for ac_dir in $ac_dummy; do
2120     test -z "$ac_dir" && ac_dir=.
2121     if test -f $ac_dir/$ac_word; then
2122       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
2123       break
2124     fi
2125   done
2126   IFS="$ac_save_ifs"
2127 fi
2128 fi
2129 RANLIB="$ac_cv_prog_RANLIB"
2130 if test -n "$RANLIB"; then
2131   echo "$ac_t""$RANLIB" 1>&6
2132 else
2133   echo "$ac_t""no" 1>&6
2134 fi
2135
2136
2137 if test -z "$ac_cv_prog_RANLIB"; then
2138 if test -n "$ac_tool_prefix"; then
2139   # Extract the first word of "ranlib", so it can be a program name with args.
2140 set dummy ranlib; ac_word=$2
2141 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2142 echo "configure:2143: checking for $ac_word" >&5
2143 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2144   echo $ac_n "(cached) $ac_c" 1>&6
2145 else
2146   if test -n "$RANLIB"; then
2147   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2148 else
2149   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2150   ac_dummy="$PATH"
2151   for ac_dir in $ac_dummy; do
2152     test -z "$ac_dir" && ac_dir=.
2153     if test -f $ac_dir/$ac_word; then
2154       ac_cv_prog_RANLIB="ranlib"
2155       break
2156     fi
2157   done
2158   IFS="$ac_save_ifs"
2159   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
2160 fi
2161 fi
2162 RANLIB="$ac_cv_prog_RANLIB"
2163 if test -n "$RANLIB"; then
2164   echo "$ac_t""$RANLIB" 1>&6
2165 else
2166   echo "$ac_t""no" 1>&6
2167 fi
2168
2169 else
2170   RANLIB=":"
2171 fi
2172 fi
2173
2174 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
2175 set dummy ${ac_tool_prefix}strip; ac_word=$2
2176 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2177 echo "configure:2178: checking for $ac_word" >&5
2178 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2179   echo $ac_n "(cached) $ac_c" 1>&6
2180 else
2181   if test -n "$STRIP"; then
2182   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2183 else
2184   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2185   ac_dummy="$PATH"
2186   for ac_dir in $ac_dummy; do
2187     test -z "$ac_dir" && ac_dir=.
2188     if test -f $ac_dir/$ac_word; then
2189       ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2190       break
2191     fi
2192   done
2193   IFS="$ac_save_ifs"
2194 fi
2195 fi
2196 STRIP="$ac_cv_prog_STRIP"
2197 if test -n "$STRIP"; then
2198   echo "$ac_t""$STRIP" 1>&6
2199 else
2200   echo "$ac_t""no" 1>&6
2201 fi
2202
2203
2204 if test -z "$ac_cv_prog_STRIP"; then
2205 if test -n "$ac_tool_prefix"; then
2206   # Extract the first word of "strip", so it can be a program name with args.
2207 set dummy strip; ac_word=$2
2208 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2209 echo "configure:2210: checking for $ac_word" >&5
2210 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2211   echo $ac_n "(cached) $ac_c" 1>&6
2212 else
2213   if test -n "$STRIP"; then
2214   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2215 else
2216   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2217   ac_dummy="$PATH"
2218   for ac_dir in $ac_dummy; do
2219     test -z "$ac_dir" && ac_dir=.
2220     if test -f $ac_dir/$ac_word; then
2221       ac_cv_prog_STRIP="strip"
2222       break
2223     fi
2224   done
2225   IFS="$ac_save_ifs"
2226   test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP=":"
2227 fi
2228 fi
2229 STRIP="$ac_cv_prog_STRIP"
2230 if test -n "$STRIP"; then
2231   echo "$ac_t""$STRIP" 1>&6
2232 else
2233   echo "$ac_t""no" 1>&6
2234 fi
2235
2236 else
2237   STRIP=":"
2238 fi
2239 fi
2240
2241
2242 # Check for any special flags to pass to ltconfig.
2243 libtool_flags="--cache-file=$cache_file"
2244 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
2245 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
2246 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
2247 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
2248 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
2249 libtool_flags="$libtool_flags --enable-dlopen"
2250
2251 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
2252 if test "${enable_libtool_lock+set}" = set; then
2253   enableval="$enable_libtool_lock"
2254   :
2255 fi
2256
2257 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
2258 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
2259
2260 # Check whether --with-pic or --without-pic was given.
2261 if test "${with_pic+set}" = set; then
2262   withval="$with_pic"
2263   pic_mode="$withval"
2264 else
2265   pic_mode=default
2266 fi
2267
2268 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
2269 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
2270
2271 # Some flags need to be propagated to the compiler or linker for good
2272 # libtool support.
2273 case "$host" in
2274 *-*-irix6*)
2275   # Find out which ABI we are using.
2276   echo '#line 2277 "configure"' > conftest.$ac_ext
2277   if { (eval echo configure:2278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2278     case "`/usr/bin/file conftest.o`" in
2279     *32-bit*)
2280       LD="${LD-ld} -32"
2281       ;;
2282     *N32*)
2283       LD="${LD-ld} -n32"
2284       ;;
2285     *64-bit*)
2286       LD="${LD-ld} -64"
2287       ;;
2288     esac
2289   fi
2290   rm -rf conftest*
2291   ;;
2292
2293 *-*-sco3.2v5*)
2294   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
2295   SAVE_CFLAGS="$CFLAGS"
2296   CFLAGS="$CFLAGS -belf"
2297   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
2298 echo "configure:2299: checking whether the C compiler needs -belf" >&5
2299 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
2300   echo $ac_n "(cached) $ac_c" 1>&6
2301 else
2302
2303      ac_ext=c
2304 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2305 ac_cpp='$CPP $CPPFLAGS'
2306 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2307 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2308 cross_compiling=$ac_cv_prog_cc_cross
2309
2310      cat > conftest.$ac_ext <<EOF
2311 #line 2312 "configure"
2312 #include "confdefs.h"
2313
2314 int main() {
2315
2316 ; return 0; }
2317 EOF
2318 if { (eval echo configure:2319: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2319   rm -rf conftest*
2320   lt_cv_cc_needs_belf=yes
2321 else
2322   echo "configure: failed program was:" >&5
2323   cat conftest.$ac_ext >&5
2324   rm -rf conftest*
2325   lt_cv_cc_needs_belf=no
2326 fi
2327 rm -f conftest*
2328      ac_ext=c
2329 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2330 ac_cpp='$CPP $CPPFLAGS'
2331 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2332 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2333 cross_compiling=$ac_cv_prog_cc_cross
2334
2335 fi
2336
2337 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
2338   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
2339     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
2340     CFLAGS="$SAVE_CFLAGS"
2341   fi
2342   ;;
2343
2344
2345 esac
2346
2347 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
2348 echo "configure:2349: checking how to run the C++ preprocessor" >&5
2349 if test -z "$CXXCPP"; then
2350 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
2351   echo $ac_n "(cached) $ac_c" 1>&6
2352 else
2353   ac_ext=C
2354 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2355 ac_cpp='$CXXCPP $CPPFLAGS'
2356 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2357 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2358 cross_compiling=$ac_cv_prog_cxx_cross
2359   CXXCPP="${CXX-g++} -E"
2360   cat > conftest.$ac_ext <<EOF
2361 #line 2362 "configure"
2362 #include "confdefs.h"
2363 #include <stdlib.h>
2364 EOF
2365 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2366 { (eval echo configure:2367: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2367 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2368 if test -z "$ac_err"; then
2369   :
2370 else
2371   echo "$ac_err" >&5
2372   echo "configure: failed program was:" >&5
2373   cat conftest.$ac_ext >&5
2374   rm -rf conftest*
2375   CXXCPP=/lib/cpp
2376 fi
2377 rm -f conftest*
2378   ac_cv_prog_CXXCPP="$CXXCPP"
2379 ac_ext=c
2380 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2381 ac_cpp='$CPP $CPPFLAGS'
2382 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2383 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2384 cross_compiling=$ac_cv_prog_cc_cross
2385 fi
2386 fi
2387 CXXCPP="$ac_cv_prog_CXXCPP"
2388 echo "$ac_t""$CXXCPP" 1>&6
2389
2390
2391 # Save cache, so that ltconfig can load it
2392 cat > confcache <<\EOF
2393 # This file is a shell script that caches the results of configure
2394 # tests run on this system so they can be shared between configure
2395 # scripts and configure runs.  It is not useful on other systems.
2396 # If it contains results you don't want to keep, you may remove or edit it.
2397 #
2398 # By default, configure uses ./config.cache as the cache file,
2399 # creating it if it does not exist already.  You can give configure
2400 # the --cache-file=FILE option to use a different cache file; that is
2401 # what configure does when it calls configure scripts in
2402 # subdirectories, so they share the cache.
2403 # Giving --cache-file=/dev/null disables caching, for debugging configure.
2404 # config.status only pays attention to the cache file if you give it the
2405 # --recheck option to rerun configure.
2406 #
2407 EOF
2408 # The following way of writing the cache mishandles newlines in values,
2409 # but we know of no workaround that is simple, portable, and efficient.
2410 # So, don't put newlines in cache variables' values.
2411 # Ultrix sh set writes to stderr and can't be redirected directly,
2412 # and sets the high bit in the cache file unless we assign to the vars.
2413 (set) 2>&1 |
2414   case `(ac_space=' '; set | grep ac_space) 2>&1` in
2415   *ac_space=\ *)
2416     # `set' does not quote correctly, so add quotes (double-quote substitution
2417     # turns \\\\ into \\, and sed turns \\ into \).
2418     sed -n \
2419       -e "s/'/'\\\\''/g" \
2420       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
2421     ;;
2422   *)
2423     # `set' quotes correctly as required by POSIX, so do not add quotes.
2424     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
2425     ;;
2426   esac >> confcache
2427 if cmp -s $cache_file confcache; then
2428   :
2429 else
2430   if test -w $cache_file; then
2431     echo "updating cache $cache_file"
2432     cat confcache > $cache_file
2433   else
2434     echo "not updating unwritable cache $cache_file"
2435   fi
2436 fi
2437 rm -f confcache
2438
2439
2440 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
2441 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
2442 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2443 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2444 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2445 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2446 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
2447 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2448 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
2449 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2450
2451 # Reload cache, that may have been modified by ltconfig
2452 if test -r "$cache_file"; then
2453   echo "loading cache $cache_file"
2454   . $cache_file
2455 else
2456   echo "creating cache $cache_file"
2457   > $cache_file
2458 fi
2459
2460
2461 # This can be used to rebuild libtool when needed
2462 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
2463
2464 # Always use our own libtool.
2465 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2466
2467 # Redirect the config.log output again, so that the ltconfig log is not
2468 # clobbered by the next message.
2469 exec 5>>./config.log
2470
2471
2472
2473
2474 LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh"
2475 lt_save_CC="$CC"
2476 lt_save_CFLAGS="$CFLAGS"
2477 AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \
2478 MAGIC_CMD="$MAGIC_CMD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2479 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2480 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2481 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2482 deplibs_check_method="$deplibs_check_method" \
2483 file_magic_cmd="$file_magic_cmd" \
2484 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \
2485 --build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \
2486 || { echo "configure: error: libtool tag configuration failed" 1>&2; exit 1; }
2487 CC="$lt_save_CC"
2488 CFLAGS="$lt_save_CFLAGS"
2489
2490 # Redirect the config.log output again, so that the ltconfig log is not
2491 # clobbered by the next message.
2492 exec 5>>./config.log
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
2503 echo "configure:2504: checking for GNU make" >&5
2504 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
2505   echo $ac_n "(cached) $ac_c" 1>&6
2506 else
2507   _cv_gnu_make_command='' ;
2508           for a in "${MAKE:-make}" make gmake gnumake ; do
2509                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2510                   then
2511                           _cv_gnu_make_command=$a ;
2512                           break;
2513                   fi
2514           done ;
2515
2516 fi
2517
2518 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
2519   if test  "x$_cv_gnu_make_command" != "x"  ; then
2520           ifGNUmake='' ;
2521   else
2522           ifGNUmake='#' ;
2523   fi
2524
2525
2526   if test "x$_cv_gnu_make_command" = "x"; then
2527     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
2528   fi
2529
2530
2531
2532
2533 # Check for c++ or library specific bits that don't require linking.
2534 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2535 echo "configure:2536: checking how to run the C preprocessor" >&5
2536 # On Suns, sometimes $CPP names a directory.
2537 if test -n "$CPP" && test -d "$CPP"; then
2538   CPP=
2539 fi
2540 if test -z "$CPP"; then
2541 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2542   echo $ac_n "(cached) $ac_c" 1>&6
2543 else
2544     # This must be in double quotes, not single quotes, because CPP may get
2545   # substituted into the Makefile and "${CC-cc}" will confuse make.
2546   CPP="${CC-cc} -E"
2547   # On the NeXT, cc -E runs the code through the compiler's parser,
2548   # not just through cpp.
2549   cat > conftest.$ac_ext <<EOF
2550 #line 2551 "configure"
2551 #include "confdefs.h"
2552 #include <assert.h>
2553 Syntax Error
2554 EOF
2555 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2556 { (eval echo configure:2557: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2557 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2558 if test -z "$ac_err"; then
2559   :
2560 else
2561   echo "$ac_err" >&5
2562   echo "configure: failed program was:" >&5
2563   cat conftest.$ac_ext >&5
2564   rm -rf conftest*
2565   CPP="${CC-cc} -E -traditional-cpp"
2566   cat > conftest.$ac_ext <<EOF
2567 #line 2568 "configure"
2568 #include "confdefs.h"
2569 #include <assert.h>
2570 Syntax Error
2571 EOF
2572 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2573 { (eval echo configure:2574: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2574 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2575 if test -z "$ac_err"; then
2576   :
2577 else
2578   echo "$ac_err" >&5
2579   echo "configure: failed program was:" >&5
2580   cat conftest.$ac_ext >&5
2581   rm -rf conftest*
2582   CPP="${CC-cc} -nologo -E"
2583   cat > conftest.$ac_ext <<EOF
2584 #line 2585 "configure"
2585 #include "confdefs.h"
2586 #include <assert.h>
2587 Syntax Error
2588 EOF
2589 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2590 { (eval echo configure:2591: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2591 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2592 if test -z "$ac_err"; then
2593   :
2594 else
2595   echo "$ac_err" >&5
2596   echo "configure: failed program was:" >&5
2597   cat conftest.$ac_ext >&5
2598   rm -rf conftest*
2599   CPP=/lib/cpp
2600 fi
2601 rm -f conftest*
2602 fi
2603 rm -f conftest*
2604 fi
2605 rm -f conftest*
2606   ac_cv_prog_CPP="$CPP"
2607 fi
2608   CPP="$ac_cv_prog_CPP"
2609 else
2610   ac_cv_prog_CPP="$CPP"
2611 fi
2612 echo "$ac_t""$CPP" 1>&6
2613
2614
2615   # Sanity check that g++ is capable of dealing with v-3.
2616   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2617 echo "configure:2618: checking for g++ that will successfully compile this code" >&5
2618   cat > conftest.$ac_ext <<EOF
2619 #line 2620 "configure"
2620 #include "confdefs.h"
2621
2622   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2623     ok
2624   #endif
2625
2626 EOF
2627 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2628   egrep "ok" >/dev/null 2>&1; then
2629   rm -rf conftest*
2630   gpp_satisfactory=yes
2631 else
2632   rm -rf conftest*
2633   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2634 fi
2635 rm -f conftest*
2636
2637   echo "$ac_t""$gpp_satisfactory" 1>&6
2638
2639
2640     echo $ac_n "checking for cpu config directory""... $ac_c" 1>&6
2641 echo "configure:2642: checking for cpu config directory" >&5
2642 # Currently unused, but could be useful.
2643 #    CPU_FLAGS=
2644     case "${target_cpu}" in
2645       alpha*)
2646         cpu_include_dir="config/cpu/alpha"
2647         ;;
2648       arm*)
2649         cpu_include_dir="config/cpu/arm"
2650         ;;
2651       ia64)
2652         cpu_include_dir="config/cpu/ia64"
2653         ;;
2654       i386)
2655         cpu_include_dir="config/cpu/i386"
2656         ;;
2657       i486 | i586 | i686 | i786)
2658         cpu_include_dir="config/cpu/i486"
2659         ;;
2660       powerpc | rs6000)
2661         cpu_include_dir="config/cpu/powerpc"
2662         ;;
2663       sparc64 | ultrasparc)
2664         cpu_include_dir="config/cpu/sparc/sparc64"
2665         ;;
2666       sparc*)
2667         cpu_include_dir="config/cpu/sparc/sparc32"
2668         ;;
2669       *)
2670         cpu_include_dir="config/cpu/generic"
2671         ;;
2672     esac
2673     echo "$ac_t""$cpu_include_dir" 1>&6
2674
2675
2676     echo $ac_n "checking for OS config directory""... $ac_c" 1>&6
2677 echo "configure:2678: checking for OS config directory" >&5
2678 # Currently unused, but could be useful.
2679 #    OS_FLAGS=
2680     case "${target_os}" in
2681       aix4.[3456789]* | aix[56789]*)
2682         os_include_dir="config/os/aix"
2683         case "$CXX" in
2684           *pthread*)
2685             enable_threads='posix'
2686             ;;
2687           *)
2688             enable_threads='no'
2689             ;;
2690         esac
2691         ;;
2692       aix*)
2693         os_include_dir="config/os/aix"
2694         ;;
2695       bsd* | freebsd*)
2696         os_include_dir="config/os/bsd"
2697         ;;
2698       linux*)
2699         os_include_dir="config/os/gnu-linux"
2700         ;;
2701       irix*)
2702         os_include_dir="config/os/irix"
2703         ;;
2704       solaris2.5*)
2705         os_include_dir="config/os/solaris/solaris2.5"
2706         ;;
2707       solaris2.6*)
2708         os_include_dir="config/os/solaris/solaris2.6"
2709         ;;
2710       solaris2.7* | solaris2.8*)
2711         os_include_dir="config/os/solaris/solaris2.7"
2712         ;;
2713       *)
2714         os_include_dir="config/os/generic"
2715         ;;
2716     esac
2717     echo "$ac_t""$os_include_dir" 1>&6
2718
2719
2720
2721 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2722 # Check whether --enable-debug or --disable-debug was given.
2723 if test "${enable_debug+set}" = set; then
2724   enableval="$enable_debug"
2725   case "${enableval}" in
2726  yes) enable_debug=yes ;;
2727  no)  enable_debug=no ;;
2728  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2729  esac
2730 else
2731   enable_debug=no
2732 fi
2733
2734 case "${enable_debug}" in
2735     yes)
2736         DEBUG_FLAGS='-O0 -ggdb3'
2737         ;;
2738     no)
2739         DEBUG_FLAGS='-g'
2740         ;;
2741 esac
2742
2743
2744 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2745 if test "${enable_c_mbchar+set}" = set; then
2746   enableval="$enable_c_mbchar"
2747   case "$enableval" in
2748  yes) enable_c_mbchar=yes ;;
2749  no)  enable_c_mbchar=no ;;
2750  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2751  esac
2752 else
2753   enable_c_mbchar=yes
2754 fi
2755
2756
2757   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2758 echo "configure:2759: checking for cstdio to use" >&5
2759   # Check whether --enable-cstdio or --disable-cstdio was given.
2760 if test "${enable_cstdio+set}" = set; then
2761   enableval="$enable_cstdio"
2762   if test x$enable_cstdio = xno; then
2763      enable_cstdio=libio
2764   fi
2765 else
2766   enable_cstdio=libio
2767 fi
2768
2769
2770   enable_cstdio_flag=$enable_cstdio
2771
2772     case x${enable_cstdio_flag} in
2773     xlibio | x | xno | xnone | xyes)
2774       # default
2775       CSTDIO_H=config/c_io_libio.h
2776       CSTDIO_CC=config/c_io_libio.cc
2777       echo "$ac_t""libio" 1>&6
2778
2779       # see if we are on a system with libio native (ie, linux)
2780       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2781 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2782 echo "configure:2783: checking for libio.h" >&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 <libio.h>
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   has_libio=yes
2809 else
2810   echo "$ac_t""no" 1>&6
2811 has_libio=no
2812 fi
2813
2814
2815       # Need to check and see what version of glibc is being used. If
2816       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2817       # compile most of libio for linux systems.
2818       if test x$has_libio = x"yes"; then
2819         case "$target" in
2820           *-*-linux*)
2821               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2822 echo "configure:2823: checking for glibc version >= 2.2" >&5
2823               cat > conftest.$ac_ext <<EOF
2824 #line 2825 "configure"
2825 #include "confdefs.h"
2826
2827             #include <features.h>
2828               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2829                     ok
2830               #endif
2831
2832 EOF
2833 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2834   egrep "ok" >/dev/null 2>&1; then
2835   rm -rf conftest*
2836   glibc_satisfactory=yes
2837 else
2838   rm -rf conftest*
2839   glibc_satisfactory=no
2840 fi
2841 rm -f conftest*
2842
2843               echo "$ac_t""$glibc_satisfactory" 1>&6
2844             ;;
2845         esac
2846
2847         # XXX at the moment, admit defeat and force the recompilation
2848         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2849         glibc_satisfactory=no
2850
2851         if test x$glibc_satisfactory = x"yes"; then
2852            need_libio=no
2853            need_wlibio=no
2854         else
2855            need_libio=yes
2856            # bkoz XXX need to add checks to enable this
2857            # pme XXX here's a first pass at such a check
2858            if test x$enable_c_mbchar != xno; then
2859               need_wlibio=yes
2860            else
2861               need_wlibio=no
2862            fi
2863         fi
2864
2865       else
2866          # Using libio, but <libio.h> doesn't exist on the target system. . .
2867          need_libio=yes
2868          # bkoz XXX need to add checks to enable this
2869          # pme XXX here's a first pass at such a check
2870          if test x$enable_c_mbchar != xno; then
2871              need_wlibio=yes
2872          else
2873              need_wlibio=no
2874          fi
2875       fi
2876       ;;
2877     xstdio)
2878       CSTDIO_H=config/c_io_stdio.h
2879       CSTDIO_CC=config/c_io_stdio.cc
2880       echo "$ac_t""stdio" 1>&6
2881
2882       need_libio=no
2883       ;;
2884     *)
2885       echo "$enable_cstdio is an unknown io package" 1>&2
2886       exit 1
2887       ;;
2888   esac
2889
2890
2891
2892   # 2000-08-04 bkoz hack
2893   CCODECVT_C=config/c_io_libio_codecvt.c
2894
2895   # 2000-08-04 bkoz hack
2896
2897
2898
2899 if test "$need_libio" = yes; then
2900   GLIBCPP_NEED_LIBIO_TRUE=
2901   GLIBCPP_NEED_LIBIO_FALSE='#'
2902 else
2903   GLIBCPP_NEED_LIBIO_TRUE='#'
2904   GLIBCPP_NEED_LIBIO_FALSE=
2905 fi
2906
2907
2908 if test "$need_wlibio" = yes; then
2909   GLIBCPP_NEED_WLIBIO_TRUE=
2910   GLIBCPP_NEED_WLIBIO_FALSE='#'
2911 else
2912   GLIBCPP_NEED_WLIBIO_TRUE='#'
2913   GLIBCPP_NEED_WLIBIO_FALSE=
2914 fi
2915
2916
2917   # Check whether --enable-long-long or --disable-long-long was given.
2918 if test "${enable_long_long+set}" = set; then
2919   enableval="$enable_long_long"
2920     case "$enableval" in
2921    yes) enable_long_long=yes ;;
2922    no)  enable_long_long=no ;;
2923    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2924    esac
2925 else
2926   enable_long_long=yes
2927 fi
2928
2929   # Check for the existance of functions used if long long is enabled.
2930   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2931 echo "configure:2932: checking for strtoll" >&5
2932 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2933   echo $ac_n "(cached) $ac_c" 1>&6
2934 else
2935   cat > conftest.$ac_ext <<EOF
2936 #line 2937 "configure"
2937 #include "confdefs.h"
2938 /* System header to define __stub macros and hopefully few prototypes,
2939     which can conflict with char strtoll(); below.  */
2940 #include <assert.h>
2941 /* Override any gcc2 internal prototype to avoid an error.  */
2942 /* We use char because int might match the return type of a gcc2
2943     builtin and then its argument prototype would still apply.  */
2944 char strtoll();
2945
2946 int main() {
2947
2948 /* The GNU C library defines this for functions which it implements
2949     to always fail with ENOSYS.  Some functions are actually named
2950     something starting with __ and the normal name is an alias.  */
2951 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2952 choke me
2953 #else
2954 strtoll();
2955 #endif
2956
2957 ; return 0; }
2958 EOF
2959 if { (eval echo configure:2960: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2960   rm -rf conftest*
2961   eval "ac_cv_func_strtoll=yes"
2962 else
2963   echo "configure: failed program was:" >&5
2964   cat conftest.$ac_ext >&5
2965   rm -rf conftest*
2966   eval "ac_cv_func_strtoll=no"
2967 fi
2968 rm -f conftest*
2969 fi
2970
2971 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2972   echo "$ac_t""yes" 1>&6
2973   :
2974 else
2975   echo "$ac_t""no" 1>&6
2976 ac_strtoll=no
2977 fi
2978
2979   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2980 echo "configure:2981: checking for strtoull" >&5
2981 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2982   echo $ac_n "(cached) $ac_c" 1>&6
2983 else
2984   cat > conftest.$ac_ext <<EOF
2985 #line 2986 "configure"
2986 #include "confdefs.h"
2987 /* System header to define __stub macros and hopefully few prototypes,
2988     which can conflict with char strtoull(); below.  */
2989 #include <assert.h>
2990 /* Override any gcc2 internal prototype to avoid an error.  */
2991 /* We use char because int might match the return type of a gcc2
2992     builtin and then its argument prototype would still apply.  */
2993 char strtoull();
2994
2995 int main() {
2996
2997 /* The GNU C library defines this for functions which it implements
2998     to always fail with ENOSYS.  Some functions are actually named
2999     something starting with __ and the normal name is an alias.  */
3000 #if defined (__stub_strtoull) || defined (__stub___strtoull)
3001 choke me
3002 #else
3003 strtoull();
3004 #endif
3005
3006 ; return 0; }
3007 EOF
3008 if { (eval echo configure:3009: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3009   rm -rf conftest*
3010   eval "ac_cv_func_strtoull=yes"
3011 else
3012   echo "configure: failed program was:" >&5
3013   cat conftest.$ac_ext >&5
3014   rm -rf conftest*
3015   eval "ac_cv_func_strtoull=no"
3016 fi
3017 rm -f conftest*
3018 fi
3019
3020 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
3021   echo "$ac_t""yes" 1>&6
3022   :
3023 else
3024   echo "$ac_t""no" 1>&6
3025 ac_strtoull=no
3026 fi
3027
3028
3029   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
3030 echo "configure:3031: checking for enabled long long" >&5
3031   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
3032     enable_long_long=no;
3033   fi;
3034   echo "$ac_t""$enable_long_long" 1>&6
3035
3036     if test x"$enable_long_long" = xyes; then
3037     cat >> confdefs.h <<\EOF
3038 #define _GLIBCPP_USE_LONG_LONG 1
3039 EOF
3040
3041   fi
3042
3043 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
3044 echo "configure:3045: checking for enabled cshadow headers" >&5
3045 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
3046 if test "${enable_cshadow_headers+set}" = set; then
3047   enableval="$enable_cshadow_headers"
3048
3049   case "$enableval" in
3050    yes) enable_cshadow_headers=yes
3051         ;;
3052    no)  enable_cshadow_headers=no
3053         ;;
3054    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3055         ;;
3056   esac
3057 else
3058   enable_cshadow_headers=no
3059 fi
3060
3061   echo "$ac_t""$enable_cshadow_headers" 1>&6
3062
3063       case "$enable_cshadow_headers" in
3064     yes)
3065         CSHADOW_FLAGS="-fno-builtin"
3066         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3067         cat >> confdefs.h <<\EOF
3068 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3069 EOF
3070
3071         ;;
3072     no)
3073         CSHADOW_FLAGS=""
3074         C_INCLUDE_DIR='${top_srcdir}/include/c'
3075         ;;
3076   esac
3077
3078
3079
3080
3081
3082 if test "$enable_cshadow_headers" = yes; then
3083   GLIBCPP_USE_CSHADOW_TRUE=
3084   GLIBCPP_USE_CSHADOW_FALSE='#'
3085 else
3086   GLIBCPP_USE_CSHADOW_TRUE='#'
3087   GLIBCPP_USE_CSHADOW_FALSE=
3088 fi
3089
3090
3091       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3092 echo "configure:3093: checking for threads package to use" >&5
3093   # Check whether --enable-threads or --disable-threads was given.
3094 if test "${enable_threads+set}" = set; then
3095   enableval="$enable_threads"
3096   if test x$enable_threads = xno; then
3097     enable_threads=''
3098   fi
3099 else
3100   enable_threads=''
3101 fi
3102
3103
3104   enable_threads_flag=$enable_threads
3105
3106     case x${enable_threads_flag} in
3107         x | xno | xnone)
3108                 # No threads
3109                 target_thread_file='single'
3110                 ;;
3111         xyes)
3112                 # default
3113                 target_thread_file=''
3114                 ;;
3115         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3116         xsolaris | xwin32 | xdce | xvxworks)
3117                 target_thread_file=$enable_threads_flag
3118                 ;;
3119         *)
3120                 echo "$enable_threads is an unknown thread package" 1>&2
3121                 exit 1
3122                 ;;
3123   esac
3124
3125     THREADH=
3126   case "$target_thread_file" in
3127     no | none | single)
3128       THREADH=threads-no.h
3129       ;;
3130     posix | pthreads)
3131       THREADH=threads-posix.h
3132       ;;
3133     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3134       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3135       ;;
3136     *)
3137       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
3138       ;;
3139   esac
3140   echo "$ac_t""$THREADH" 1>&6
3141
3142
3143   if test $THREADH != threads-no.h; then
3144     cat >> confdefs.h <<\EOF
3145 #define _GLIBCPP_USE_THREADS 1
3146 EOF
3147
3148   fi
3149
3150
3151     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3152 echo "configure:3153: checking for atomicity.h" >&5
3153     case "$target" in
3154       *-*-linux* | sparc*-*-*)
3155         ATOMICITYH=$cpu_include_dir
3156         ;;
3157       *-*-aix* | *-*-irix*)
3158         ATOMICITYH=$os_include_dir
3159         ;;
3160       *)
3161         # bit of overkill on this text...
3162         { echo "configure: error: Atomic locking requested, but $enable_threads is an unknown thread package and atomic operations are not present in the CPU" 1>&2; exit 1; }
3163         ;;
3164     esac
3165     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3166
3167
3168 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3169 if test "${enable_cxx_flags+set}" = set; then
3170   enableval="$enable_cxx_flags"
3171   case "x$enableval" in
3172  xyes)
3173         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3174  xno|x)
3175         enable_cxx_flags='' ;;
3176  *)
3177         enable_cxx_flags="$enableval" ;;
3178  esac
3179 else
3180   enable_cxx_flags='none'
3181 fi
3182
3183
3184 if test "$enable_cxx_flags" = "none"; then
3185   enable_cxx_flags='';
3186 fi
3187
3188 if test -n "$enable_cxx_flags"; then
3189     for f in $enable_cxx_flags; do
3190         case "$f" in
3191             -fhonor-std)  ;;
3192             -*)  ;;
3193             *)   # and we're trying to pass /what/ exactly?
3194                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3195         esac
3196     done
3197 fi
3198 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3199
3200
3201
3202
3203 if test -n "$with_cross_host"; then
3204
3205   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3206   # may not work correctly, because the compiler may not be able to
3207   # link executables.
3208
3209   xcompiling=1
3210   NATIVE=no
3211   # If Canadian cross, then don't pick up tools from the build
3212   # directory.
3213   if test "$build" != "$with_cross_host"; then
3214     CANADIAN=yes
3215     NULL_TARGET=yes
3216   else
3217     CANADIAN=no
3218     NULL_TARGET=no
3219   fi
3220
3221   case "$target_alias" in
3222     *-wince-*)
3223         # Configure for Microsoft Windows CE, or whatever they are
3224         # currently calling it.
3225         cat >> confdefs.h <<\EOF
3226 #define HAVE_FLOAT_H 1
3227 EOF
3228
3229
3230         cat >> confdefs.h <<\EOF
3231 #define HAVE__FINITE 1
3232 EOF
3233
3234         cat >> confdefs.h <<\EOF
3235 #define HAVE__ISNAN 1
3236 EOF
3237
3238         cat >> confdefs.h <<\EOF
3239 #define HAVE__COPYSIGN 1
3240 EOF
3241
3242         cat >> confdefs.h <<\EOF
3243 #define HAVE__FPCLASS 1
3244 EOF
3245
3246         cat >> confdefs.h <<\EOF
3247 #define HAVE_MODF 1
3248 EOF
3249
3250
3251         ctype_include_dir="config/os/wince"
3252
3253
3254
3255
3256
3257         cat >> confdefs.h <<\EOF
3258 #define _GLIBCPP_NEED_MBSTATE_T 1
3259 EOF
3260
3261
3262         cat >> confdefs.h <<\EOF
3263 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3264 EOF
3265
3266         cat >> confdefs.h <<\EOF
3267 #define _GLIBCPP_BUGGY_COMPLEX 1
3268 EOF
3269
3270         ;;
3271     *)
3272         # We assume newlib.  This lets us hard-code the functions we know
3273         # we'll have.
3274         cat >> confdefs.h <<\EOF
3275 #define HAVE_FINITE 1
3276 EOF
3277
3278         cat >> confdefs.h <<\EOF
3279 #define HAVE_ISNAN 1
3280 EOF
3281
3282         cat >> confdefs.h <<\EOF
3283 #define HAVE_ISNANF 1
3284 EOF
3285
3286         cat >> confdefs.h <<\EOF
3287 #define HAVE_ISINF 1
3288 EOF
3289
3290         cat >> confdefs.h <<\EOF
3291 #define HAVE_ISINFF 1
3292 EOF
3293
3294
3295         ctype_include_dir="config/os/newlib"
3296
3297
3298
3299
3300         cat >> confdefs.h <<\EOF
3301 #define _GLIBCPP_NEED_MBSTATE_T 1
3302 EOF
3303
3304
3305         cat >> confdefs.h <<\EOF
3306 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3307 EOF
3308
3309         cat >> confdefs.h <<\EOF
3310 #define _GLIBCPP_BUGGY_COMPLEX 1
3311 EOF
3312
3313         # need to check for faster f versions of math functions, ie sinf?
3314         ;;
3315   esac
3316 else
3317
3318   # We are being configured natively. We can do more elaborate tests
3319   # that include AC_TRY_COMPILE now, as the linker is assumed to be
3320   # working.
3321
3322   xcompiling=0
3323   NATIVE=yes
3324   CANADIAN=no
3325   NULL_TARGET=no
3326
3327   # Check for available headers.
3328   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
3329   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
3330 do
3331 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3332 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3333 echo "configure:3334: checking for $ac_hdr" >&5
3334 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3335   echo $ac_n "(cached) $ac_c" 1>&6
3336 else
3337   cat > conftest.$ac_ext <<EOF
3338 #line 3339 "configure"
3339 #include "confdefs.h"
3340 #include <$ac_hdr>
3341 EOF
3342 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3343 { (eval echo configure:3344: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3344 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3345 if test -z "$ac_err"; then
3346   rm -rf conftest*
3347   eval "ac_cv_header_$ac_safe=yes"
3348 else
3349   echo "$ac_err" >&5
3350   echo "configure: failed program was:" >&5
3351   cat conftest.$ac_ext >&5
3352   rm -rf conftest*
3353   eval "ac_cv_header_$ac_safe=no"
3354 fi
3355 rm -f conftest*
3356 fi
3357 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3358   echo "$ac_t""yes" 1>&6
3359     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3360   cat >> confdefs.h <<EOF
3361 #define $ac_tr_hdr 1
3362 EOF
3363
3364 else
3365   echo "$ac_t""no" 1>&6
3366 fi
3367 done
3368
3369
3370
3371   # All these tests are for C++; save the language and the compiler flags.
3372   # The CXXFLAGS thing is suspicious, but based on similar bits
3373   # found in GLIBCPP_CONFIGURE.
3374
3375   ac_ext=C
3376 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3377 ac_cpp='$CXXCPP $CPPFLAGS'
3378 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3379 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3380 cross_compiling=$ac_cv_prog_cxx_cross
3381
3382   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3383   ac_save_CXXFLAGS="$CXXFLAGS"
3384
3385   # Check for maintainer-mode bits.
3386   if test x"$USE_MAINTAINER_MODE" = xno; then
3387     WERROR=''
3388   else
3389     WERROR='-Werror'
3390   fi
3391
3392   # Check for more sophisticated diagnostic control.
3393   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
3394 echo "configure:3395: checking for g++ that supports -fdiagnostics-show-location=once" >&5
3395   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
3396   cat > conftest.$ac_ext <<EOF
3397 #line 3398 "configure"
3398 #include "confdefs.h"
3399
3400 int main() {
3401 int foo;
3402
3403 ; return 0; }
3404 EOF
3405 if { (eval echo configure:3406: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3406   rm -rf conftest*
3407   ac_gabydiags=yes
3408 else
3409   echo "configure: failed program was:" >&5
3410   cat conftest.$ac_ext >&5
3411   rm -rf conftest*
3412   ac_gabydiags=no
3413 fi
3414 rm -f conftest*
3415   if test "$ac_test_CXXFLAGS" = set; then
3416     CXXFLAGS="$ac_save_CXXFLAGS"
3417   else
3418     # this is the suspicious part
3419     CXXFLAGS=''
3420   fi
3421   if test "$ac_gabydiags" = "yes"; then
3422     WFMT_FLAGS='-fdiagnostics-show-location=once'
3423   fi
3424   echo "$ac_t""$ac_gabydiags" 1>&6
3425
3426   # Check for -ffunction-sections -fdata-sections
3427   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
3428 echo "configure:3429: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
3429   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
3430   cat > conftest.$ac_ext <<EOF
3431 #line 3432 "configure"
3432 #include "confdefs.h"
3433
3434 int main() {
3435 int foo;
3436
3437 ; return 0; }
3438 EOF
3439 if { (eval echo configure:3440: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3440   rm -rf conftest*
3441   ac_fdsections=yes
3442 else
3443   echo "configure: failed program was:" >&5
3444   cat conftest.$ac_ext >&5
3445   rm -rf conftest*
3446   ac_fdsections=no
3447 fi
3448 rm -f conftest*
3449   if test "$ac_test_CXXFLAGS" = set; then
3450     CXXFLAGS="$ac_save_CXXFLAGS"
3451   else
3452     # this is the suspicious part
3453     CXXFLAGS=''
3454   fi
3455   if test "$ac_fdsections" = "yes"; then
3456     SECTION_FLAGS='-ffunction-sections -fdata-sections'
3457   fi
3458   echo "$ac_t""$ac_fdsections" 1>&6
3459
3460   ac_ext=c
3461 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3462 ac_cpp='$CPP $CPPFLAGS'
3463 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3464 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3465 cross_compiling=$ac_cv_prog_cc_cross
3466
3467
3468
3469
3470
3471
3472   # If we're not using GNU ld, then there's no point in even trying these
3473   # tests.  Check for that first.  We should have already tested for gld
3474   # by now (in libtool), but require it now just to be safe...
3475   SECTION_LDFLAGS=''
3476   OPT_LDFLAGS=''
3477
3478
3479   # Set --gc-sections.
3480   if test "$ac_cv_prog_gnu_ld" = "broken"; then
3481     # GNU ld it is!  Joy and bunny rabbits!
3482
3483     # All these tests are for C++; save the language and the compiler flags.
3484     # Need to do this so that g++ won't try to link in libstdc++
3485     ac_test_CFLAGS="${CFLAGS+set}"
3486     ac_save_CFLAGS="$CFLAGS"
3487     CFLAGS='-x c++  -Wl,--gc-sections'
3488
3489     # Check for -Wl,--gc-sections
3490     # XXX This test is broken at the moment, as symbols required for
3491     # linking are now in libsupc++ (not built yet.....). In addition,
3492     # this test has cored on solaris in the past. In addition,
3493     # --gc-sections doesn't really work at the moment (keeps on discarding
3494     # used sections, first .eh_frame and now some of the glibc sections for
3495     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3496     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3497 echo "configure:3498: checking for ld that supports -Wl,--gc-sections" >&5
3498     if test "$cross_compiling" = yes; then
3499   ac_sectionLDflags=yes
3500 else
3501   cat > conftest.$ac_ext <<EOF
3502 #line 3503 "configure"
3503 #include "confdefs.h"
3504
3505      int main(void)
3506      {
3507        try { throw 1; }
3508        catch (...) { };
3509        return 0;
3510      }
3511
3512 EOF
3513 if { (eval echo configure:3514: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3514 then
3515   ac_sectionLDflags=yes
3516 else
3517   echo "configure: failed program was:" >&5
3518   cat conftest.$ac_ext >&5
3519   rm -fr conftest*
3520   ac_sectionLFflags=no
3521 fi
3522 rm -fr conftest*
3523 fi
3524
3525     if test "$ac_test_CFLAGS" = set; then
3526       CFLAGS="$ac_save_CFLAGS"
3527     else
3528       # this is the suspicious part
3529       CFLAGS=''
3530     fi
3531     if test "$ac_sectionLDflags" = "yes"; then
3532       SECTION_LDFLAGS='-Wl,--gc-sections'
3533     fi
3534     echo "$ac_t""$ac_sectionLDflags" 1>&6
3535   fi
3536
3537   # Set linker optimization flags.
3538   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3539     OPT_LDFLAGS='-Wl,-O1'
3540   fi
3541
3542
3543
3544
3545
3546
3547   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3548 echo "configure:3549: checking for __builtin_abs declaration" >&5
3549   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
3550   echo $ac_n "(cached) $ac_c" 1>&6
3551 else
3552
3553
3554     ac_ext=C
3555 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3556 ac_cpp='$CXXCPP $CPPFLAGS'
3557 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3558 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3559 cross_compiling=$ac_cv_prog_cxx_cross
3560
3561     cat > conftest.$ac_ext <<EOF
3562 #line 3563 "configure"
3563 #include "confdefs.h"
3564 #include <math.h>
3565 int main() {
3566  __builtin_abs(0);
3567 ; return 0; }
3568 EOF
3569 if { (eval echo configure:3570: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3570   rm -rf conftest*
3571   glibcpp_cv_func___builtin_abs_use=yes
3572 else
3573   echo "configure: failed program was:" >&5
3574   cat conftest.$ac_ext >&5
3575   rm -rf conftest*
3576   glibcpp_cv_func___builtin_abs_use=no
3577 fi
3578 rm -f conftest*
3579     ac_ext=c
3580 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3581 ac_cpp='$CPP $CPPFLAGS'
3582 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3583 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3584 cross_compiling=$ac_cv_prog_cc_cross
3585
3586
3587 fi
3588
3589   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
3590   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
3591     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3592 echo "configure:3593: checking for __builtin_abs linkage" >&5
3593     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
3594   echo $ac_n "(cached) $ac_c" 1>&6
3595 else
3596
3597       cat > conftest.$ac_ext <<EOF
3598 #line 3599 "configure"
3599 #include "confdefs.h"
3600 #include <math.h>
3601 int main() {
3602  __builtin_abs(0);
3603 ; return 0; }
3604 EOF
3605 if { (eval echo configure:3606: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3606   rm -rf conftest*
3607   glibcpp_cv_func___builtin_abs_link=yes
3608 else
3609   echo "configure: failed program was:" >&5
3610   cat conftest.$ac_ext >&5
3611   rm -rf conftest*
3612   glibcpp_cv_func___builtin_abs_link=no
3613 fi
3614 rm -f conftest*
3615
3616 fi
3617
3618     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
3619     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
3620       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3621       cat >> confdefs.h <<EOF
3622 #define ${ac_tr_func} 1
3623 EOF
3624
3625     fi
3626   fi
3627
3628
3629   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3630 echo "configure:3631: checking for __builtin_fabsf declaration" >&5
3631   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
3632   echo $ac_n "(cached) $ac_c" 1>&6
3633 else
3634
3635
3636     ac_ext=C
3637 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3638 ac_cpp='$CXXCPP $CPPFLAGS'
3639 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3640 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3641 cross_compiling=$ac_cv_prog_cxx_cross
3642
3643     cat > conftest.$ac_ext <<EOF
3644 #line 3645 "configure"
3645 #include "confdefs.h"
3646 #include <math.h>
3647 int main() {
3648  __builtin_fabsf(0);
3649 ; return 0; }
3650 EOF
3651 if { (eval echo configure:3652: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3652   rm -rf conftest*
3653   glibcpp_cv_func___builtin_fabsf_use=yes
3654 else
3655   echo "configure: failed program was:" >&5
3656   cat conftest.$ac_ext >&5
3657   rm -rf conftest*
3658   glibcpp_cv_func___builtin_fabsf_use=no
3659 fi
3660 rm -f conftest*
3661     ac_ext=c
3662 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3663 ac_cpp='$CPP $CPPFLAGS'
3664 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3665 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3666 cross_compiling=$ac_cv_prog_cc_cross
3667
3668
3669 fi
3670
3671   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
3672   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
3673     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3674 echo "configure:3675: checking for __builtin_fabsf linkage" >&5
3675     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
3676   echo $ac_n "(cached) $ac_c" 1>&6
3677 else
3678
3679       cat > conftest.$ac_ext <<EOF
3680 #line 3681 "configure"
3681 #include "confdefs.h"
3682 #include <math.h>
3683 int main() {
3684  __builtin_fabsf(0);
3685 ; return 0; }
3686 EOF
3687 if { (eval echo configure:3688: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3688   rm -rf conftest*
3689   glibcpp_cv_func___builtin_fabsf_link=yes
3690 else
3691   echo "configure: failed program was:" >&5
3692   cat conftest.$ac_ext >&5
3693   rm -rf conftest*
3694   glibcpp_cv_func___builtin_fabsf_link=no
3695 fi
3696 rm -f conftest*
3697
3698 fi
3699
3700     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
3701     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
3702       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3703       cat >> confdefs.h <<EOF
3704 #define ${ac_tr_func} 1
3705 EOF
3706
3707     fi
3708   fi
3709
3710
3711   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3712 echo "configure:3713: checking for __builtin_fabs declaration" >&5
3713   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
3714   echo $ac_n "(cached) $ac_c" 1>&6
3715 else
3716
3717
3718     ac_ext=C
3719 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3720 ac_cpp='$CXXCPP $CPPFLAGS'
3721 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3722 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3723 cross_compiling=$ac_cv_prog_cxx_cross
3724
3725     cat > conftest.$ac_ext <<EOF
3726 #line 3727 "configure"
3727 #include "confdefs.h"
3728 #include <math.h>
3729 int main() {
3730  __builtin_fabs(0);
3731 ; return 0; }
3732 EOF
3733 if { (eval echo configure:3734: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3734   rm -rf conftest*
3735   glibcpp_cv_func___builtin_fabs_use=yes
3736 else
3737   echo "configure: failed program was:" >&5
3738   cat conftest.$ac_ext >&5
3739   rm -rf conftest*
3740   glibcpp_cv_func___builtin_fabs_use=no
3741 fi
3742 rm -f conftest*
3743     ac_ext=c
3744 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3745 ac_cpp='$CPP $CPPFLAGS'
3746 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3747 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3748 cross_compiling=$ac_cv_prog_cc_cross
3749
3750
3751 fi
3752
3753   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
3754   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
3755     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3756 echo "configure:3757: checking for __builtin_fabs linkage" >&5
3757     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
3758   echo $ac_n "(cached) $ac_c" 1>&6
3759 else
3760
3761       cat > conftest.$ac_ext <<EOF
3762 #line 3763 "configure"
3763 #include "confdefs.h"
3764 #include <math.h>
3765 int main() {
3766  __builtin_fabs(0);
3767 ; return 0; }
3768 EOF
3769 if { (eval echo configure:3770: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3770   rm -rf conftest*
3771   glibcpp_cv_func___builtin_fabs_link=yes
3772 else
3773   echo "configure: failed program was:" >&5
3774   cat conftest.$ac_ext >&5
3775   rm -rf conftest*
3776   glibcpp_cv_func___builtin_fabs_link=no
3777 fi
3778 rm -f conftest*
3779
3780 fi
3781
3782     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
3783     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
3784       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3785       cat >> confdefs.h <<EOF
3786 #define ${ac_tr_func} 1
3787 EOF
3788
3789     fi
3790   fi
3791
3792
3793   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3794 echo "configure:3795: checking for __builtin_fabsl declaration" >&5
3795   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
3796   echo $ac_n "(cached) $ac_c" 1>&6
3797 else
3798
3799
3800     ac_ext=C
3801 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3802 ac_cpp='$CXXCPP $CPPFLAGS'
3803 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3804 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3805 cross_compiling=$ac_cv_prog_cxx_cross
3806
3807     cat > conftest.$ac_ext <<EOF
3808 #line 3809 "configure"
3809 #include "confdefs.h"
3810 #include <math.h>
3811 int main() {
3812  __builtin_fabsl(0);
3813 ; return 0; }
3814 EOF
3815 if { (eval echo configure:3816: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3816   rm -rf conftest*
3817   glibcpp_cv_func___builtin_fabsl_use=yes
3818 else
3819   echo "configure: failed program was:" >&5
3820   cat conftest.$ac_ext >&5
3821   rm -rf conftest*
3822   glibcpp_cv_func___builtin_fabsl_use=no
3823 fi
3824 rm -f conftest*
3825     ac_ext=c
3826 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3827 ac_cpp='$CPP $CPPFLAGS'
3828 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3829 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3830 cross_compiling=$ac_cv_prog_cc_cross
3831
3832
3833 fi
3834
3835   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
3836   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
3837     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3838 echo "configure:3839: checking for __builtin_fabsl linkage" >&5
3839     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
3840   echo $ac_n "(cached) $ac_c" 1>&6
3841 else
3842
3843       cat > conftest.$ac_ext <<EOF
3844 #line 3845 "configure"
3845 #include "confdefs.h"
3846 #include <math.h>
3847 int main() {
3848  __builtin_fabsl(0);
3849 ; return 0; }
3850 EOF
3851 if { (eval echo configure:3852: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3852   rm -rf conftest*
3853   glibcpp_cv_func___builtin_fabsl_link=yes
3854 else
3855   echo "configure: failed program was:" >&5
3856   cat conftest.$ac_ext >&5
3857   rm -rf conftest*
3858   glibcpp_cv_func___builtin_fabsl_link=no
3859 fi
3860 rm -f conftest*
3861
3862 fi
3863
3864     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
3865     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
3866       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3867       cat >> confdefs.h <<EOF
3868 #define ${ac_tr_func} 1
3869 EOF
3870
3871     fi
3872   fi
3873
3874
3875   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3876 echo "configure:3877: checking for __builtin_labs declaration" >&5
3877   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
3878   echo $ac_n "(cached) $ac_c" 1>&6
3879 else
3880
3881
3882     ac_ext=C
3883 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3884 ac_cpp='$CXXCPP $CPPFLAGS'
3885 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3886 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3887 cross_compiling=$ac_cv_prog_cxx_cross
3888
3889     cat > conftest.$ac_ext <<EOF
3890 #line 3891 "configure"
3891 #include "confdefs.h"
3892 #include <math.h>
3893 int main() {
3894  __builtin_labs(0);
3895 ; return 0; }
3896 EOF
3897 if { (eval echo configure:3898: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3898   rm -rf conftest*
3899   glibcpp_cv_func___builtin_labs_use=yes
3900 else
3901   echo "configure: failed program was:" >&5
3902   cat conftest.$ac_ext >&5
3903   rm -rf conftest*
3904   glibcpp_cv_func___builtin_labs_use=no
3905 fi
3906 rm -f conftest*
3907     ac_ext=c
3908 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3909 ac_cpp='$CPP $CPPFLAGS'
3910 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3911 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3912 cross_compiling=$ac_cv_prog_cc_cross
3913
3914
3915 fi
3916
3917   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
3918   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
3919     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3920 echo "configure:3921: checking for __builtin_labs linkage" >&5
3921     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
3922   echo $ac_n "(cached) $ac_c" 1>&6
3923 else
3924
3925       cat > conftest.$ac_ext <<EOF
3926 #line 3927 "configure"
3927 #include "confdefs.h"
3928 #include <math.h>
3929 int main() {
3930  __builtin_labs(0);
3931 ; return 0; }
3932 EOF
3933 if { (eval echo configure:3934: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3934   rm -rf conftest*
3935   glibcpp_cv_func___builtin_labs_link=yes
3936 else
3937   echo "configure: failed program was:" >&5
3938   cat conftest.$ac_ext >&5
3939   rm -rf conftest*
3940   glibcpp_cv_func___builtin_labs_link=no
3941 fi
3942 rm -f conftest*
3943
3944 fi
3945
3946     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
3947     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
3948       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3949       cat >> confdefs.h <<EOF
3950 #define ${ac_tr_func} 1
3951 EOF
3952
3953     fi
3954   fi
3955
3956
3957
3958   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3959 echo "configure:3960: checking for __builtin_sqrtf declaration" >&5
3960   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
3961   echo $ac_n "(cached) $ac_c" 1>&6
3962 else
3963
3964
3965     ac_ext=C
3966 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3967 ac_cpp='$CXXCPP $CPPFLAGS'
3968 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3969 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3970 cross_compiling=$ac_cv_prog_cxx_cross
3971
3972     cat > conftest.$ac_ext <<EOF
3973 #line 3974 "configure"
3974 #include "confdefs.h"
3975 #include <math.h>
3976 int main() {
3977  __builtin_sqrtf(0);
3978 ; return 0; }
3979 EOF
3980 if { (eval echo configure:3981: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3981   rm -rf conftest*
3982   glibcpp_cv_func___builtin_sqrtf_use=yes
3983 else
3984   echo "configure: failed program was:" >&5
3985   cat conftest.$ac_ext >&5
3986   rm -rf conftest*
3987   glibcpp_cv_func___builtin_sqrtf_use=no
3988 fi
3989 rm -f conftest*
3990     ac_ext=c
3991 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3992 ac_cpp='$CPP $CPPFLAGS'
3993 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3994 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3995 cross_compiling=$ac_cv_prog_cc_cross
3996
3997
3998 fi
3999
4000   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
4001   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
4002     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
4003 echo "configure:4004: checking for __builtin_sqrtf linkage" >&5
4004     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
4005   echo $ac_n "(cached) $ac_c" 1>&6
4006 else
4007
4008       cat > conftest.$ac_ext <<EOF
4009 #line 4010 "configure"
4010 #include "confdefs.h"
4011 #include <math.h>
4012 int main() {
4013  __builtin_sqrtf(0);
4014 ; return 0; }
4015 EOF
4016 if { (eval echo configure:4017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4017   rm -rf conftest*
4018   glibcpp_cv_func___builtin_sqrtf_link=yes
4019 else
4020   echo "configure: failed program was:" >&5
4021   cat conftest.$ac_ext >&5
4022   rm -rf conftest*
4023   glibcpp_cv_func___builtin_sqrtf_link=no
4024 fi
4025 rm -f conftest*
4026
4027 fi
4028
4029     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
4030     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
4031       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4032       cat >> confdefs.h <<EOF
4033 #define ${ac_tr_func} 1
4034 EOF
4035
4036     fi
4037   fi
4038
4039
4040   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
4041 echo "configure:4042: checking for __builtin_fsqrt declaration" >&5
4042   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
4043   echo $ac_n "(cached) $ac_c" 1>&6
4044 else
4045
4046
4047     ac_ext=C
4048 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4049 ac_cpp='$CXXCPP $CPPFLAGS'
4050 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4051 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4052 cross_compiling=$ac_cv_prog_cxx_cross
4053
4054     cat > conftest.$ac_ext <<EOF
4055 #line 4056 "configure"
4056 #include "confdefs.h"
4057 #include <math.h>
4058 int main() {
4059  __builtin_fsqrt(0);
4060 ; return 0; }
4061 EOF
4062 if { (eval echo configure:4063: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4063   rm -rf conftest*
4064   glibcpp_cv_func___builtin_fsqrt_use=yes
4065 else
4066   echo "configure: failed program was:" >&5
4067   cat conftest.$ac_ext >&5
4068   rm -rf conftest*
4069   glibcpp_cv_func___builtin_fsqrt_use=no
4070 fi
4071 rm -f conftest*
4072     ac_ext=c
4073 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4074 ac_cpp='$CPP $CPPFLAGS'
4075 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4076 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4077 cross_compiling=$ac_cv_prog_cc_cross
4078
4079
4080 fi
4081
4082   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
4083   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
4084     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
4085 echo "configure:4086: checking for __builtin_fsqrt linkage" >&5
4086     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
4087   echo $ac_n "(cached) $ac_c" 1>&6
4088 else
4089
4090       cat > conftest.$ac_ext <<EOF
4091 #line 4092 "configure"
4092 #include "confdefs.h"
4093 #include <math.h>
4094 int main() {
4095  __builtin_fsqrt(0);
4096 ; return 0; }
4097 EOF
4098 if { (eval echo configure:4099: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4099   rm -rf conftest*
4100   glibcpp_cv_func___builtin_fsqrt_link=yes
4101 else
4102   echo "configure: failed program was:" >&5
4103   cat conftest.$ac_ext >&5
4104   rm -rf conftest*
4105   glibcpp_cv_func___builtin_fsqrt_link=no
4106 fi
4107 rm -f conftest*
4108
4109 fi
4110
4111     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
4112     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
4113       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4114       cat >> confdefs.h <<EOF
4115 #define ${ac_tr_func} 1
4116 EOF
4117
4118     fi
4119   fi
4120
4121
4122   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
4123 echo "configure:4124: checking for __builtin_sqrtl declaration" >&5
4124   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
4125   echo $ac_n "(cached) $ac_c" 1>&6
4126 else
4127
4128
4129     ac_ext=C
4130 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4131 ac_cpp='$CXXCPP $CPPFLAGS'
4132 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4133 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4134 cross_compiling=$ac_cv_prog_cxx_cross
4135
4136     cat > conftest.$ac_ext <<EOF
4137 #line 4138 "configure"
4138 #include "confdefs.h"
4139 #include <math.h>
4140 int main() {
4141  __builtin_sqrtl(0);
4142 ; return 0; }
4143 EOF
4144 if { (eval echo configure:4145: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4145   rm -rf conftest*
4146   glibcpp_cv_func___builtin_sqrtl_use=yes
4147 else
4148   echo "configure: failed program was:" >&5
4149   cat conftest.$ac_ext >&5
4150   rm -rf conftest*
4151   glibcpp_cv_func___builtin_sqrtl_use=no
4152 fi
4153 rm -f conftest*
4154     ac_ext=c
4155 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4156 ac_cpp='$CPP $CPPFLAGS'
4157 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4158 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4159 cross_compiling=$ac_cv_prog_cc_cross
4160
4161
4162 fi
4163
4164   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
4165   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
4166     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
4167 echo "configure:4168: checking for __builtin_sqrtl linkage" >&5
4168     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
4169   echo $ac_n "(cached) $ac_c" 1>&6
4170 else
4171
4172       cat > conftest.$ac_ext <<EOF
4173 #line 4174 "configure"
4174 #include "confdefs.h"
4175 #include <math.h>
4176 int main() {
4177  __builtin_sqrtl(0);
4178 ; return 0; }
4179 EOF
4180 if { (eval echo configure:4181: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4181   rm -rf conftest*
4182   glibcpp_cv_func___builtin_sqrtl_link=yes
4183 else
4184   echo "configure: failed program was:" >&5
4185   cat conftest.$ac_ext >&5
4186   rm -rf conftest*
4187   glibcpp_cv_func___builtin_sqrtl_link=no
4188 fi
4189 rm -f conftest*
4190
4191 fi
4192
4193     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
4194     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
4195       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4196       cat >> confdefs.h <<EOF
4197 #define ${ac_tr_func} 1
4198 EOF
4199
4200     fi
4201   fi
4202
4203
4204
4205   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
4206 echo "configure:4207: checking for __builtin_sinf declaration" >&5
4207   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
4208   echo $ac_n "(cached) $ac_c" 1>&6
4209 else
4210
4211
4212     ac_ext=C
4213 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4214 ac_cpp='$CXXCPP $CPPFLAGS'
4215 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4216 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4217 cross_compiling=$ac_cv_prog_cxx_cross
4218
4219     cat > conftest.$ac_ext <<EOF
4220 #line 4221 "configure"
4221 #include "confdefs.h"
4222 #include <math.h>
4223 int main() {
4224  __builtin_sinf(0);
4225 ; return 0; }
4226 EOF
4227 if { (eval echo configure:4228: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4228   rm -rf conftest*
4229   glibcpp_cv_func___builtin_sinf_use=yes
4230 else
4231   echo "configure: failed program was:" >&5
4232   cat conftest.$ac_ext >&5
4233   rm -rf conftest*
4234   glibcpp_cv_func___builtin_sinf_use=no
4235 fi
4236 rm -f conftest*
4237     ac_ext=c
4238 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4239 ac_cpp='$CPP $CPPFLAGS'
4240 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4241 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4242 cross_compiling=$ac_cv_prog_cc_cross
4243
4244
4245 fi
4246
4247   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
4248   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
4249     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
4250 echo "configure:4251: checking for __builtin_sinf linkage" >&5
4251     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
4252   echo $ac_n "(cached) $ac_c" 1>&6
4253 else
4254
4255       cat > conftest.$ac_ext <<EOF
4256 #line 4257 "configure"
4257 #include "confdefs.h"
4258 #include <math.h>
4259 int main() {
4260  __builtin_sinf(0);
4261 ; return 0; }
4262 EOF
4263 if { (eval echo configure:4264: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4264   rm -rf conftest*
4265   glibcpp_cv_func___builtin_sinf_link=yes
4266 else
4267   echo "configure: failed program was:" >&5
4268   cat conftest.$ac_ext >&5
4269   rm -rf conftest*
4270   glibcpp_cv_func___builtin_sinf_link=no
4271 fi
4272 rm -f conftest*
4273
4274 fi
4275
4276     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
4277     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
4278       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4279       cat >> confdefs.h <<EOF
4280 #define ${ac_tr_func} 1
4281 EOF
4282
4283     fi
4284   fi
4285
4286
4287   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
4288 echo "configure:4289: checking for __builtin_sin declaration" >&5
4289   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
4290   echo $ac_n "(cached) $ac_c" 1>&6
4291 else
4292
4293
4294     ac_ext=C
4295 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4296 ac_cpp='$CXXCPP $CPPFLAGS'
4297 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4298 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4299 cross_compiling=$ac_cv_prog_cxx_cross
4300
4301     cat > conftest.$ac_ext <<EOF
4302 #line 4303 "configure"
4303 #include "confdefs.h"
4304 #include <math.h>
4305 int main() {
4306  __builtin_sin(0);
4307 ; return 0; }
4308 EOF
4309 if { (eval echo configure:4310: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4310   rm -rf conftest*
4311   glibcpp_cv_func___builtin_sin_use=yes
4312 else
4313   echo "configure: failed program was:" >&5
4314   cat conftest.$ac_ext >&5
4315   rm -rf conftest*
4316   glibcpp_cv_func___builtin_sin_use=no
4317 fi
4318 rm -f conftest*
4319     ac_ext=c
4320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4321 ac_cpp='$CPP $CPPFLAGS'
4322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4324 cross_compiling=$ac_cv_prog_cc_cross
4325
4326
4327 fi
4328
4329   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
4330   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
4331     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
4332 echo "configure:4333: checking for __builtin_sin linkage" >&5
4333     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
4334   echo $ac_n "(cached) $ac_c" 1>&6
4335 else
4336
4337       cat > conftest.$ac_ext <<EOF
4338 #line 4339 "configure"
4339 #include "confdefs.h"
4340 #include <math.h>
4341 int main() {
4342  __builtin_sin(0);
4343 ; return 0; }
4344 EOF
4345 if { (eval echo configure:4346: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4346   rm -rf conftest*
4347   glibcpp_cv_func___builtin_sin_link=yes
4348 else
4349   echo "configure: failed program was:" >&5
4350   cat conftest.$ac_ext >&5
4351   rm -rf conftest*
4352   glibcpp_cv_func___builtin_sin_link=no
4353 fi
4354 rm -f conftest*
4355
4356 fi
4357
4358     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
4359     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
4360       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4361       cat >> confdefs.h <<EOF
4362 #define ${ac_tr_func} 1
4363 EOF
4364
4365     fi
4366   fi
4367
4368
4369   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
4370 echo "configure:4371: checking for __builtin_sinl declaration" >&5
4371   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
4372   echo $ac_n "(cached) $ac_c" 1>&6
4373 else
4374
4375
4376     ac_ext=C
4377 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4378 ac_cpp='$CXXCPP $CPPFLAGS'
4379 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4380 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4381 cross_compiling=$ac_cv_prog_cxx_cross
4382
4383     cat > conftest.$ac_ext <<EOF
4384 #line 4385 "configure"
4385 #include "confdefs.h"
4386 #include <math.h>
4387 int main() {
4388  __builtin_sinl(0);
4389 ; return 0; }
4390 EOF
4391 if { (eval echo configure:4392: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4392   rm -rf conftest*
4393   glibcpp_cv_func___builtin_sinl_use=yes
4394 else
4395   echo "configure: failed program was:" >&5
4396   cat conftest.$ac_ext >&5
4397   rm -rf conftest*
4398   glibcpp_cv_func___builtin_sinl_use=no
4399 fi
4400 rm -f conftest*
4401     ac_ext=c
4402 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4403 ac_cpp='$CPP $CPPFLAGS'
4404 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4405 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4406 cross_compiling=$ac_cv_prog_cc_cross
4407
4408
4409 fi
4410
4411   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
4412   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
4413     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
4414 echo "configure:4415: checking for __builtin_sinl linkage" >&5
4415     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
4416   echo $ac_n "(cached) $ac_c" 1>&6
4417 else
4418
4419       cat > conftest.$ac_ext <<EOF
4420 #line 4421 "configure"
4421 #include "confdefs.h"
4422 #include <math.h>
4423 int main() {
4424  __builtin_sinl(0);
4425 ; return 0; }
4426 EOF
4427 if { (eval echo configure:4428: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4428   rm -rf conftest*
4429   glibcpp_cv_func___builtin_sinl_link=yes
4430 else
4431   echo "configure: failed program was:" >&5
4432   cat conftest.$ac_ext >&5
4433   rm -rf conftest*
4434   glibcpp_cv_func___builtin_sinl_link=no
4435 fi
4436 rm -f conftest*
4437
4438 fi
4439
4440     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
4441     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
4442       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4443       cat >> confdefs.h <<EOF
4444 #define ${ac_tr_func} 1
4445 EOF
4446
4447     fi
4448   fi
4449
4450
4451
4452   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
4453 echo "configure:4454: checking for __builtin_cosf declaration" >&5
4454   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
4455   echo $ac_n "(cached) $ac_c" 1>&6
4456 else
4457
4458
4459     ac_ext=C
4460 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4461 ac_cpp='$CXXCPP $CPPFLAGS'
4462 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4463 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4464 cross_compiling=$ac_cv_prog_cxx_cross
4465
4466     cat > conftest.$ac_ext <<EOF
4467 #line 4468 "configure"
4468 #include "confdefs.h"
4469 #include <math.h>
4470 int main() {
4471  __builtin_cosf(0);
4472 ; return 0; }
4473 EOF
4474 if { (eval echo configure:4475: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4475   rm -rf conftest*
4476   glibcpp_cv_func___builtin_cosf_use=yes
4477 else
4478   echo "configure: failed program was:" >&5
4479   cat conftest.$ac_ext >&5
4480   rm -rf conftest*
4481   glibcpp_cv_func___builtin_cosf_use=no
4482 fi
4483 rm -f conftest*
4484     ac_ext=c
4485 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4486 ac_cpp='$CPP $CPPFLAGS'
4487 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4488 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4489 cross_compiling=$ac_cv_prog_cc_cross
4490
4491
4492 fi
4493
4494   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
4495   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
4496     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
4497 echo "configure:4498: checking for __builtin_cosf linkage" >&5
4498     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
4499   echo $ac_n "(cached) $ac_c" 1>&6
4500 else
4501
4502       cat > conftest.$ac_ext <<EOF
4503 #line 4504 "configure"
4504 #include "confdefs.h"
4505 #include <math.h>
4506 int main() {
4507  __builtin_cosf(0);
4508 ; return 0; }
4509 EOF
4510 if { (eval echo configure:4511: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4511   rm -rf conftest*
4512   glibcpp_cv_func___builtin_cosf_link=yes
4513 else
4514   echo "configure: failed program was:" >&5
4515   cat conftest.$ac_ext >&5
4516   rm -rf conftest*
4517   glibcpp_cv_func___builtin_cosf_link=no
4518 fi
4519 rm -f conftest*
4520
4521 fi
4522
4523     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
4524     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
4525       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4526       cat >> confdefs.h <<EOF
4527 #define ${ac_tr_func} 1
4528 EOF
4529
4530     fi
4531   fi
4532
4533
4534   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
4535 echo "configure:4536: checking for __builtin_cos declaration" >&5
4536   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
4537   echo $ac_n "(cached) $ac_c" 1>&6
4538 else
4539
4540
4541     ac_ext=C
4542 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4543 ac_cpp='$CXXCPP $CPPFLAGS'
4544 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4545 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4546 cross_compiling=$ac_cv_prog_cxx_cross
4547
4548     cat > conftest.$ac_ext <<EOF
4549 #line 4550 "configure"
4550 #include "confdefs.h"
4551 #include <math.h>
4552 int main() {
4553  __builtin_cos(0);
4554 ; return 0; }
4555 EOF
4556 if { (eval echo configure:4557: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4557   rm -rf conftest*
4558   glibcpp_cv_func___builtin_cos_use=yes
4559 else
4560   echo "configure: failed program was:" >&5
4561   cat conftest.$ac_ext >&5
4562   rm -rf conftest*
4563   glibcpp_cv_func___builtin_cos_use=no
4564 fi
4565 rm -f conftest*
4566     ac_ext=c
4567 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4568 ac_cpp='$CPP $CPPFLAGS'
4569 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4570 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4571 cross_compiling=$ac_cv_prog_cc_cross
4572
4573
4574 fi
4575
4576   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
4577   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
4578     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
4579 echo "configure:4580: checking for __builtin_cos linkage" >&5
4580     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
4581   echo $ac_n "(cached) $ac_c" 1>&6
4582 else
4583
4584       cat > conftest.$ac_ext <<EOF
4585 #line 4586 "configure"
4586 #include "confdefs.h"
4587 #include <math.h>
4588 int main() {
4589  __builtin_cos(0);
4590 ; return 0; }
4591 EOF
4592 if { (eval echo configure:4593: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4593   rm -rf conftest*
4594   glibcpp_cv_func___builtin_cos_link=yes
4595 else
4596   echo "configure: failed program was:" >&5
4597   cat conftest.$ac_ext >&5
4598   rm -rf conftest*
4599   glibcpp_cv_func___builtin_cos_link=no
4600 fi
4601 rm -f conftest*
4602
4603 fi
4604
4605     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
4606     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
4607       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4608       cat >> confdefs.h <<EOF
4609 #define ${ac_tr_func} 1
4610 EOF
4611
4612     fi
4613   fi
4614
4615
4616   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
4617 echo "configure:4618: checking for __builtin_cosl declaration" >&5
4618   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
4619   echo $ac_n "(cached) $ac_c" 1>&6
4620 else
4621
4622
4623     ac_ext=C
4624 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4625 ac_cpp='$CXXCPP $CPPFLAGS'
4626 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4627 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4628 cross_compiling=$ac_cv_prog_cxx_cross
4629
4630     cat > conftest.$ac_ext <<EOF
4631 #line 4632 "configure"
4632 #include "confdefs.h"
4633 #include <math.h>
4634 int main() {
4635  __builtin_cosl(0);
4636 ; return 0; }
4637 EOF
4638 if { (eval echo configure:4639: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4639   rm -rf conftest*
4640   glibcpp_cv_func___builtin_cosl_use=yes
4641 else
4642   echo "configure: failed program was:" >&5
4643   cat conftest.$ac_ext >&5
4644   rm -rf conftest*
4645   glibcpp_cv_func___builtin_cosl_use=no
4646 fi
4647 rm -f conftest*
4648     ac_ext=c
4649 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4650 ac_cpp='$CPP $CPPFLAGS'
4651 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4652 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4653 cross_compiling=$ac_cv_prog_cc_cross
4654
4655
4656 fi
4657
4658   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
4659   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
4660     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
4661 echo "configure:4662: checking for __builtin_cosl linkage" >&5
4662     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
4663   echo $ac_n "(cached) $ac_c" 1>&6
4664 else
4665
4666       cat > conftest.$ac_ext <<EOF
4667 #line 4668 "configure"
4668 #include "confdefs.h"
4669 #include <math.h>
4670 int main() {
4671  __builtin_cosl(0);
4672 ; return 0; }
4673 EOF
4674 if { (eval echo configure:4675: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4675   rm -rf conftest*
4676   glibcpp_cv_func___builtin_cosl_link=yes
4677 else
4678   echo "configure: failed program was:" >&5
4679   cat conftest.$ac_ext >&5
4680   rm -rf conftest*
4681   glibcpp_cv_func___builtin_cosl_link=no
4682 fi
4683 rm -f conftest*
4684
4685 fi
4686
4687     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
4688     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
4689       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4690       cat >> confdefs.h <<EOF
4691 #define ${ac_tr_func} 1
4692 EOF
4693
4694     fi
4695   fi
4696
4697
4698               dummyvar=no
4699   if test x$dummyvar = x"yes"; then
4700     cat >> confdefs.h <<\EOF
4701 #define HAVE___BUILTIN_ABS 1
4702 EOF
4703
4704     cat >> confdefs.h <<\EOF
4705 #define HAVE___BUILTIN_LABS 1
4706 EOF
4707
4708     cat >> confdefs.h <<\EOF
4709 #define HAVE___BUILTIN_COS 1
4710 EOF
4711
4712     cat >> confdefs.h <<\EOF
4713 #define HAVE___BUILTIN_COSF 1
4714 EOF
4715
4716     cat >> confdefs.h <<\EOF
4717 #define HAVE___BUILTIN_COSL 1
4718 EOF
4719
4720     cat >> confdefs.h <<\EOF
4721 #define HAVE___BUILTIN_FABS 1
4722 EOF
4723
4724     cat >> confdefs.h <<\EOF
4725 #define HAVE___BUILTIN_FABSF 1
4726 EOF
4727
4728     cat >> confdefs.h <<\EOF
4729 #define HAVE___BUILTIN_FABSL 1
4730 EOF
4731
4732     cat >> confdefs.h <<\EOF
4733 #define HAVE___BUILTIN_SIN 1
4734 EOF
4735
4736     cat >> confdefs.h <<\EOF
4737 #define HAVE___BUILTIN_SINF 1
4738 EOF
4739
4740     cat >> confdefs.h <<\EOF
4741 #define HAVE___BUILTIN_SINL 1
4742 EOF
4743
4744     cat >> confdefs.h <<\EOF
4745 #define HAVE___BUILTIN_FSQRT 1
4746 EOF
4747
4748     cat >> confdefs.h <<\EOF
4749 #define HAVE___BUILTIN_SQRTF 1
4750 EOF
4751
4752     cat >> confdefs.h <<\EOF
4753 #define HAVE___BUILTIN_SQRTL 1
4754 EOF
4755
4756   fi
4757
4758
4759   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4760   ac_save_CXXFLAGS="$CXXFLAGS"
4761   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4762
4763     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4764 echo "configure:4765: checking for sin in -lm" >&5
4765 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4766 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4767   echo $ac_n "(cached) $ac_c" 1>&6
4768 else
4769   ac_save_LIBS="$LIBS"
4770 LIBS="-lm  $LIBS"
4771 cat > conftest.$ac_ext <<EOF
4772 #line 4773 "configure"
4773 #include "confdefs.h"
4774 /* Override any gcc2 internal prototype to avoid an error.  */
4775 /* We use char because int might match the return type of a gcc2
4776     builtin and then its argument prototype would still apply.  */
4777 char sin();
4778
4779 int main() {
4780 sin()
4781 ; return 0; }
4782 EOF
4783 if { (eval echo configure:4784: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4784   rm -rf conftest*
4785   eval "ac_cv_lib_$ac_lib_var=yes"
4786 else
4787   echo "configure: failed program was:" >&5
4788   cat conftest.$ac_ext >&5
4789   rm -rf conftest*
4790   eval "ac_cv_lib_$ac_lib_var=no"
4791 fi
4792 rm -f conftest*
4793 LIBS="$ac_save_LIBS"
4794
4795 fi
4796 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4797   echo "$ac_t""yes" 1>&6
4798   libm="-lm"
4799 else
4800   echo "$ac_t""no" 1>&6
4801 fi
4802
4803   ac_save_LIBS="$LIBS"
4804   LIBS="$LIBS $libm"
4805
4806
4807   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4808 echo "configure:4809: checking for isinf declaration" >&5
4809   if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
4810   echo $ac_n "(cached) $ac_c" 1>&6
4811 else
4812
4813
4814     ac_ext=C
4815 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4816 ac_cpp='$CXXCPP $CPPFLAGS'
4817 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4818 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4819 cross_compiling=$ac_cv_prog_cxx_cross
4820
4821     cat > conftest.$ac_ext <<EOF
4822 #line 4823 "configure"
4823 #include "confdefs.h"
4824 #include <math.h>
4825 int main() {
4826  isinf(0);
4827 ; return 0; }
4828 EOF
4829 if { (eval echo configure:4830: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4830   rm -rf conftest*
4831   glibcpp_cv_func_isinf_use=yes
4832 else
4833   echo "configure: failed program was:" >&5
4834   cat conftest.$ac_ext >&5
4835   rm -rf conftest*
4836   glibcpp_cv_func_isinf_use=no
4837 fi
4838 rm -f conftest*
4839     ac_ext=c
4840 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4841 ac_cpp='$CPP $CPPFLAGS'
4842 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4843 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4844 cross_compiling=$ac_cv_prog_cc_cross
4845
4846
4847 fi
4848
4849   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
4850   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
4851     for ac_func in isinf
4852 do
4853 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4854 echo "configure:4855: checking for $ac_func" >&5
4855 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4856   echo $ac_n "(cached) $ac_c" 1>&6
4857 else
4858   cat > conftest.$ac_ext <<EOF
4859 #line 4860 "configure"
4860 #include "confdefs.h"
4861 /* System header to define __stub macros and hopefully few prototypes,
4862     which can conflict with char $ac_func(); below.  */
4863 #include <assert.h>
4864 /* Override any gcc2 internal prototype to avoid an error.  */
4865 /* We use char because int might match the return type of a gcc2
4866     builtin and then its argument prototype would still apply.  */
4867 char $ac_func();
4868
4869 int main() {
4870
4871 /* The GNU C library defines this for functions which it implements
4872     to always fail with ENOSYS.  Some functions are actually named
4873     something starting with __ and the normal name is an alias.  */
4874 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4875 choke me
4876 #else
4877 $ac_func();
4878 #endif
4879
4880 ; return 0; }
4881 EOF
4882 if { (eval echo configure:4883: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4883   rm -rf conftest*
4884   eval "ac_cv_func_$ac_func=yes"
4885 else
4886   echo "configure: failed program was:" >&5
4887   cat conftest.$ac_ext >&5
4888   rm -rf conftest*
4889   eval "ac_cv_func_$ac_func=no"
4890 fi
4891 rm -f conftest*
4892 fi
4893
4894 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4895   echo "$ac_t""yes" 1>&6
4896     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4897   cat >> confdefs.h <<EOF
4898 #define $ac_tr_func 1
4899 EOF
4900
4901 else
4902   echo "$ac_t""no" 1>&6
4903 fi
4904 done
4905
4906   fi
4907
4908
4909   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4910 echo "configure:4911: checking for isnan declaration" >&5
4911   if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
4912   echo $ac_n "(cached) $ac_c" 1>&6
4913 else
4914
4915
4916     ac_ext=C
4917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4918 ac_cpp='$CXXCPP $CPPFLAGS'
4919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4921 cross_compiling=$ac_cv_prog_cxx_cross
4922
4923     cat > conftest.$ac_ext <<EOF
4924 #line 4925 "configure"
4925 #include "confdefs.h"
4926 #include <math.h>
4927 int main() {
4928  isnan(0);
4929 ; return 0; }
4930 EOF
4931 if { (eval echo configure:4932: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4932   rm -rf conftest*
4933   glibcpp_cv_func_isnan_use=yes
4934 else
4935   echo "configure: failed program was:" >&5
4936   cat conftest.$ac_ext >&5
4937   rm -rf conftest*
4938   glibcpp_cv_func_isnan_use=no
4939 fi
4940 rm -f conftest*
4941     ac_ext=c
4942 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4943 ac_cpp='$CPP $CPPFLAGS'
4944 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4945 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4946 cross_compiling=$ac_cv_prog_cc_cross
4947
4948
4949 fi
4950
4951   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
4952   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
4953     for ac_func in isnan
4954 do
4955 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4956 echo "configure:4957: checking for $ac_func" >&5
4957 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4958   echo $ac_n "(cached) $ac_c" 1>&6
4959 else
4960   cat > conftest.$ac_ext <<EOF
4961 #line 4962 "configure"
4962 #include "confdefs.h"
4963 /* System header to define __stub macros and hopefully few prototypes,
4964     which can conflict with char $ac_func(); below.  */
4965 #include <assert.h>
4966 /* Override any gcc2 internal prototype to avoid an error.  */
4967 /* We use char because int might match the return type of a gcc2
4968     builtin and then its argument prototype would still apply.  */
4969 char $ac_func();
4970
4971 int main() {
4972
4973 /* The GNU C library defines this for functions which it implements
4974     to always fail with ENOSYS.  Some functions are actually named
4975     something starting with __ and the normal name is an alias.  */
4976 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4977 choke me
4978 #else
4979 $ac_func();
4980 #endif
4981
4982 ; return 0; }
4983 EOF
4984 if { (eval echo configure:4985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4985   rm -rf conftest*
4986   eval "ac_cv_func_$ac_func=yes"
4987 else
4988   echo "configure: failed program was:" >&5
4989   cat conftest.$ac_ext >&5
4990   rm -rf conftest*
4991   eval "ac_cv_func_$ac_func=no"
4992 fi
4993 rm -f conftest*
4994 fi
4995
4996 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4997   echo "$ac_t""yes" 1>&6
4998     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4999   cat >> confdefs.h <<EOF
5000 #define $ac_tr_func 1
5001 EOF
5002
5003 else
5004   echo "$ac_t""no" 1>&6
5005 fi
5006 done
5007
5008   fi
5009
5010
5011   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
5012 echo "configure:5013: checking for finite declaration" >&5
5013   if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
5014   echo $ac_n "(cached) $ac_c" 1>&6
5015 else
5016
5017
5018     ac_ext=C
5019 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5020 ac_cpp='$CXXCPP $CPPFLAGS'
5021 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5022 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5023 cross_compiling=$ac_cv_prog_cxx_cross
5024
5025     cat > conftest.$ac_ext <<EOF
5026 #line 5027 "configure"
5027 #include "confdefs.h"
5028 #include <math.h>
5029 int main() {
5030  finite(0);
5031 ; return 0; }
5032 EOF
5033 if { (eval echo configure:5034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5034   rm -rf conftest*
5035   glibcpp_cv_func_finite_use=yes
5036 else
5037   echo "configure: failed program was:" >&5
5038   cat conftest.$ac_ext >&5
5039   rm -rf conftest*
5040   glibcpp_cv_func_finite_use=no
5041 fi
5042 rm -f conftest*
5043     ac_ext=c
5044 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5045 ac_cpp='$CPP $CPPFLAGS'
5046 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5047 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5048 cross_compiling=$ac_cv_prog_cc_cross
5049
5050
5051 fi
5052
5053   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
5054   if test x$glibcpp_cv_func_finite_use = x"yes"; then
5055     for ac_func in finite
5056 do
5057 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5058 echo "configure:5059: checking for $ac_func" >&5
5059 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5060   echo $ac_n "(cached) $ac_c" 1>&6
5061 else
5062   cat > conftest.$ac_ext <<EOF
5063 #line 5064 "configure"
5064 #include "confdefs.h"
5065 /* System header to define __stub macros and hopefully few prototypes,
5066     which can conflict with char $ac_func(); below.  */
5067 #include <assert.h>
5068 /* Override any gcc2 internal prototype to avoid an error.  */
5069 /* We use char because int might match the return type of a gcc2
5070     builtin and then its argument prototype would still apply.  */
5071 char $ac_func();
5072
5073 int main() {
5074
5075 /* The GNU C library defines this for functions which it implements
5076     to always fail with ENOSYS.  Some functions are actually named
5077     something starting with __ and the normal name is an alias.  */
5078 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5079 choke me
5080 #else
5081 $ac_func();
5082 #endif
5083
5084 ; return 0; }
5085 EOF
5086 if { (eval echo configure:5087: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5087   rm -rf conftest*
5088   eval "ac_cv_func_$ac_func=yes"
5089 else
5090   echo "configure: failed program was:" >&5
5091   cat conftest.$ac_ext >&5
5092   rm -rf conftest*
5093   eval "ac_cv_func_$ac_func=no"
5094 fi
5095 rm -f conftest*
5096 fi
5097
5098 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5099   echo "$ac_t""yes" 1>&6
5100     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5101   cat >> confdefs.h <<EOF
5102 #define $ac_tr_func 1
5103 EOF
5104
5105 else
5106   echo "$ac_t""no" 1>&6
5107 fi
5108 done
5109
5110   fi
5111
5112
5113   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
5114 echo "configure:5115: checking for copysign declaration" >&5
5115   if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
5116   echo $ac_n "(cached) $ac_c" 1>&6
5117 else
5118
5119
5120     ac_ext=C
5121 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5122 ac_cpp='$CXXCPP $CPPFLAGS'
5123 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5124 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5125 cross_compiling=$ac_cv_prog_cxx_cross
5126
5127     cat > conftest.$ac_ext <<EOF
5128 #line 5129 "configure"
5129 #include "confdefs.h"
5130 #include <math.h>
5131 int main() {
5132  copysign(0, 0);
5133 ; return 0; }
5134 EOF
5135 if { (eval echo configure:5136: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5136   rm -rf conftest*
5137   glibcpp_cv_func_copysign_use=yes
5138 else
5139   echo "configure: failed program was:" >&5
5140   cat conftest.$ac_ext >&5
5141   rm -rf conftest*
5142   glibcpp_cv_func_copysign_use=no
5143 fi
5144 rm -f conftest*
5145     ac_ext=c
5146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5147 ac_cpp='$CPP $CPPFLAGS'
5148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5150 cross_compiling=$ac_cv_prog_cc_cross
5151
5152
5153 fi
5154
5155   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
5156   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
5157     for ac_func in copysign
5158 do
5159 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5160 echo "configure:5161: checking for $ac_func" >&5
5161 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5162   echo $ac_n "(cached) $ac_c" 1>&6
5163 else
5164   cat > conftest.$ac_ext <<EOF
5165 #line 5166 "configure"
5166 #include "confdefs.h"
5167 /* System header to define __stub macros and hopefully few prototypes,
5168     which can conflict with char $ac_func(); below.  */
5169 #include <assert.h>
5170 /* Override any gcc2 internal prototype to avoid an error.  */
5171 /* We use char because int might match the return type of a gcc2
5172     builtin and then its argument prototype would still apply.  */
5173 char $ac_func();
5174
5175 int main() {
5176
5177 /* The GNU C library defines this for functions which it implements
5178     to always fail with ENOSYS.  Some functions are actually named
5179     something starting with __ and the normal name is an alias.  */
5180 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5181 choke me
5182 #else
5183 $ac_func();
5184 #endif
5185
5186 ; return 0; }
5187 EOF
5188 if { (eval echo configure:5189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5189   rm -rf conftest*
5190   eval "ac_cv_func_$ac_func=yes"
5191 else
5192   echo "configure: failed program was:" >&5
5193   cat conftest.$ac_ext >&5
5194   rm -rf conftest*
5195   eval "ac_cv_func_$ac_func=no"
5196 fi
5197 rm -f conftest*
5198 fi
5199
5200 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5201   echo "$ac_t""yes" 1>&6
5202     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5203   cat >> confdefs.h <<EOF
5204 #define $ac_tr_func 1
5205 EOF
5206
5207 else
5208   echo "$ac_t""no" 1>&6
5209 fi
5210 done
5211
5212   fi
5213
5214
5215   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
5216 echo "configure:5217: checking for sincos declaration" >&5
5217   if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
5218   echo $ac_n "(cached) $ac_c" 1>&6
5219 else
5220
5221
5222     ac_ext=C
5223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5224 ac_cpp='$CXXCPP $CPPFLAGS'
5225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5227 cross_compiling=$ac_cv_prog_cxx_cross
5228
5229     cat > conftest.$ac_ext <<EOF
5230 #line 5231 "configure"
5231 #include "confdefs.h"
5232 #include <math.h>
5233 int main() {
5234  sincos(0, 0, 0);
5235 ; return 0; }
5236 EOF
5237 if { (eval echo configure:5238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5238   rm -rf conftest*
5239   glibcpp_cv_func_sincos_use=yes
5240 else
5241   echo "configure: failed program was:" >&5
5242   cat conftest.$ac_ext >&5
5243   rm -rf conftest*
5244   glibcpp_cv_func_sincos_use=no
5245 fi
5246 rm -f conftest*
5247     ac_ext=c
5248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5249 ac_cpp='$CPP $CPPFLAGS'
5250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5252 cross_compiling=$ac_cv_prog_cc_cross
5253
5254
5255 fi
5256
5257   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
5258   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
5259     for ac_func in sincos
5260 do
5261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5262 echo "configure:5263: checking for $ac_func" >&5
5263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5264   echo $ac_n "(cached) $ac_c" 1>&6
5265 else
5266   cat > conftest.$ac_ext <<EOF
5267 #line 5268 "configure"
5268 #include "confdefs.h"
5269 /* System header to define __stub macros and hopefully few prototypes,
5270     which can conflict with char $ac_func(); below.  */
5271 #include <assert.h>
5272 /* Override any gcc2 internal prototype to avoid an error.  */
5273 /* We use char because int might match the return type of a gcc2
5274     builtin and then its argument prototype would still apply.  */
5275 char $ac_func();
5276
5277 int main() {
5278
5279 /* The GNU C library defines this for functions which it implements
5280     to always fail with ENOSYS.  Some functions are actually named
5281     something starting with __ and the normal name is an alias.  */
5282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5283 choke me
5284 #else
5285 $ac_func();
5286 #endif
5287
5288 ; return 0; }
5289 EOF
5290 if { (eval echo configure:5291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5291   rm -rf conftest*
5292   eval "ac_cv_func_$ac_func=yes"
5293 else
5294   echo "configure: failed program was:" >&5
5295   cat conftest.$ac_ext >&5
5296   rm -rf conftest*
5297   eval "ac_cv_func_$ac_func=no"
5298 fi
5299 rm -f conftest*
5300 fi
5301
5302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5303   echo "$ac_t""yes" 1>&6
5304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5305   cat >> confdefs.h <<EOF
5306 #define $ac_tr_func 1
5307 EOF
5308
5309 else
5310   echo "$ac_t""no" 1>&6
5311 fi
5312 done
5313
5314   fi
5315
5316
5317   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
5318 echo "configure:5319: checking for fpclass declaration" >&5
5319   if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
5320   echo $ac_n "(cached) $ac_c" 1>&6
5321 else
5322
5323
5324     ac_ext=C
5325 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5326 ac_cpp='$CXXCPP $CPPFLAGS'
5327 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5328 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5329 cross_compiling=$ac_cv_prog_cxx_cross
5330
5331     cat > conftest.$ac_ext <<EOF
5332 #line 5333 "configure"
5333 #include "confdefs.h"
5334 #include <math.h>
5335 int main() {
5336  fpclass(0);
5337 ; return 0; }
5338 EOF
5339 if { (eval echo configure:5340: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5340   rm -rf conftest*
5341   glibcpp_cv_func_fpclass_use=yes
5342 else
5343   echo "configure: failed program was:" >&5
5344   cat conftest.$ac_ext >&5
5345   rm -rf conftest*
5346   glibcpp_cv_func_fpclass_use=no
5347 fi
5348 rm -f conftest*
5349     ac_ext=c
5350 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5351 ac_cpp='$CPP $CPPFLAGS'
5352 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5353 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5354 cross_compiling=$ac_cv_prog_cc_cross
5355
5356
5357 fi
5358
5359   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
5360   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
5361     for ac_func in fpclass
5362 do
5363 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5364 echo "configure:5365: checking for $ac_func" >&5
5365 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5366   echo $ac_n "(cached) $ac_c" 1>&6
5367 else
5368   cat > conftest.$ac_ext <<EOF
5369 #line 5370 "configure"
5370 #include "confdefs.h"
5371 /* System header to define __stub macros and hopefully few prototypes,
5372     which can conflict with char $ac_func(); below.  */
5373 #include <assert.h>
5374 /* Override any gcc2 internal prototype to avoid an error.  */
5375 /* We use char because int might match the return type of a gcc2
5376     builtin and then its argument prototype would still apply.  */
5377 char $ac_func();
5378
5379 int main() {
5380
5381 /* The GNU C library defines this for functions which it implements
5382     to always fail with ENOSYS.  Some functions are actually named
5383     something starting with __ and the normal name is an alias.  */
5384 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5385 choke me
5386 #else
5387 $ac_func();
5388 #endif
5389
5390 ; return 0; }
5391 EOF
5392 if { (eval echo configure:5393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5393   rm -rf conftest*
5394   eval "ac_cv_func_$ac_func=yes"
5395 else
5396   echo "configure: failed program was:" >&5
5397   cat conftest.$ac_ext >&5
5398   rm -rf conftest*
5399   eval "ac_cv_func_$ac_func=no"
5400 fi
5401 rm -f conftest*
5402 fi
5403
5404 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5405   echo "$ac_t""yes" 1>&6
5406     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5407   cat >> confdefs.h <<EOF
5408 #define $ac_tr_func 1
5409 EOF
5410
5411 else
5412   echo "$ac_t""no" 1>&6
5413 fi
5414 done
5415
5416   fi
5417
5418
5419   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
5420 echo "configure:5421: checking for qfpclass declaration" >&5
5421   if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
5422   echo $ac_n "(cached) $ac_c" 1>&6
5423 else
5424
5425
5426     ac_ext=C
5427 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5428 ac_cpp='$CXXCPP $CPPFLAGS'
5429 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5430 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5431 cross_compiling=$ac_cv_prog_cxx_cross
5432
5433     cat > conftest.$ac_ext <<EOF
5434 #line 5435 "configure"
5435 #include "confdefs.h"
5436 #include <math.h>
5437 int main() {
5438  qfpclass(0);
5439 ; return 0; }
5440 EOF
5441 if { (eval echo configure:5442: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5442   rm -rf conftest*
5443   glibcpp_cv_func_qfpclass_use=yes
5444 else
5445   echo "configure: failed program was:" >&5
5446   cat conftest.$ac_ext >&5
5447   rm -rf conftest*
5448   glibcpp_cv_func_qfpclass_use=no
5449 fi
5450 rm -f conftest*
5451     ac_ext=c
5452 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5453 ac_cpp='$CPP $CPPFLAGS'
5454 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5455 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5456 cross_compiling=$ac_cv_prog_cc_cross
5457
5458
5459 fi
5460
5461   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
5462   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
5463     for ac_func in qfpclass
5464 do
5465 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5466 echo "configure:5467: checking for $ac_func" >&5
5467 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5468   echo $ac_n "(cached) $ac_c" 1>&6
5469 else
5470   cat > conftest.$ac_ext <<EOF
5471 #line 5472 "configure"
5472 #include "confdefs.h"
5473 /* System header to define __stub macros and hopefully few prototypes,
5474     which can conflict with char $ac_func(); below.  */
5475 #include <assert.h>
5476 /* Override any gcc2 internal prototype to avoid an error.  */
5477 /* We use char because int might match the return type of a gcc2
5478     builtin and then its argument prototype would still apply.  */
5479 char $ac_func();
5480
5481 int main() {
5482
5483 /* The GNU C library defines this for functions which it implements
5484     to always fail with ENOSYS.  Some functions are actually named
5485     something starting with __ and the normal name is an alias.  */
5486 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5487 choke me
5488 #else
5489 $ac_func();
5490 #endif
5491
5492 ; return 0; }
5493 EOF
5494 if { (eval echo configure:5495: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5495   rm -rf conftest*
5496   eval "ac_cv_func_$ac_func=yes"
5497 else
5498   echo "configure: failed program was:" >&5
5499   cat conftest.$ac_ext >&5
5500   rm -rf conftest*
5501   eval "ac_cv_func_$ac_func=no"
5502 fi
5503 rm -f conftest*
5504 fi
5505
5506 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5507   echo "$ac_t""yes" 1>&6
5508     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5509   cat >> confdefs.h <<EOF
5510 #define $ac_tr_func 1
5511 EOF
5512
5513 else
5514   echo "$ac_t""no" 1>&6
5515 fi
5516 done
5517
5518   fi
5519
5520
5521
5522   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5523 echo "configure:5524: checking for isnanf declaration" >&5
5524   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
5525   echo $ac_n "(cached) $ac_c" 1>&6
5526 else
5527
5528
5529     ac_ext=C
5530 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5531 ac_cpp='$CXXCPP $CPPFLAGS'
5532 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5533 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5534 cross_compiling=$ac_cv_prog_cxx_cross
5535
5536     cat > conftest.$ac_ext <<EOF
5537 #line 5538 "configure"
5538 #include "confdefs.h"
5539 #include <math.h>
5540 int main() {
5541  isnanf(0);
5542 ; return 0; }
5543 EOF
5544 if { (eval echo configure:5545: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5545   rm -rf conftest*
5546   glibcpp_cv_func_isnanf_use=yes
5547 else
5548   echo "configure: failed program was:" >&5
5549   cat conftest.$ac_ext >&5
5550   rm -rf conftest*
5551   glibcpp_cv_func_isnanf_use=no
5552 fi
5553 rm -f conftest*
5554     ac_ext=c
5555 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5556 ac_cpp='$CPP $CPPFLAGS'
5557 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5558 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5559 cross_compiling=$ac_cv_prog_cc_cross
5560
5561
5562 fi
5563
5564   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
5565   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
5566     for ac_func in isnanf
5567 do
5568 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5569 echo "configure:5570: checking for $ac_func" >&5
5570 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5571   echo $ac_n "(cached) $ac_c" 1>&6
5572 else
5573   cat > conftest.$ac_ext <<EOF
5574 #line 5575 "configure"
5575 #include "confdefs.h"
5576 /* System header to define __stub macros and hopefully few prototypes,
5577     which can conflict with char $ac_func(); below.  */
5578 #include <assert.h>
5579 /* Override any gcc2 internal prototype to avoid an error.  */
5580 /* We use char because int might match the return type of a gcc2
5581     builtin and then its argument prototype would still apply.  */
5582 char $ac_func();
5583
5584 int main() {
5585
5586 /* The GNU C library defines this for functions which it implements
5587     to always fail with ENOSYS.  Some functions are actually named
5588     something starting with __ and the normal name is an alias.  */
5589 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5590 choke me
5591 #else
5592 $ac_func();
5593 #endif
5594
5595 ; return 0; }
5596 EOF
5597 if { (eval echo configure:5598: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5598   rm -rf conftest*
5599   eval "ac_cv_func_$ac_func=yes"
5600 else
5601   echo "configure: failed program was:" >&5
5602   cat conftest.$ac_ext >&5
5603   rm -rf conftest*
5604   eval "ac_cv_func_$ac_func=no"
5605 fi
5606 rm -f conftest*
5607 fi
5608
5609 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5610   echo "$ac_t""yes" 1>&6
5611     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5612   cat >> confdefs.h <<EOF
5613 #define $ac_tr_func 1
5614 EOF
5615
5616 else
5617   echo "$ac_t""no" 1>&6
5618 fi
5619 done
5620
5621   fi
5622
5623
5624   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5625 echo "configure:5626: checking for isinff declaration" >&5
5626   if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
5627   echo $ac_n "(cached) $ac_c" 1>&6
5628 else
5629
5630
5631     ac_ext=C
5632 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5633 ac_cpp='$CXXCPP $CPPFLAGS'
5634 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5635 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5636 cross_compiling=$ac_cv_prog_cxx_cross
5637
5638     cat > conftest.$ac_ext <<EOF
5639 #line 5640 "configure"
5640 #include "confdefs.h"
5641 #include <math.h>
5642 int main() {
5643  isinff(0);
5644 ; return 0; }
5645 EOF
5646 if { (eval echo configure:5647: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5647   rm -rf conftest*
5648   glibcpp_cv_func_isinff_use=yes
5649 else
5650   echo "configure: failed program was:" >&5
5651   cat conftest.$ac_ext >&5
5652   rm -rf conftest*
5653   glibcpp_cv_func_isinff_use=no
5654 fi
5655 rm -f conftest*
5656     ac_ext=c
5657 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5658 ac_cpp='$CPP $CPPFLAGS'
5659 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5660 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5661 cross_compiling=$ac_cv_prog_cc_cross
5662
5663
5664 fi
5665
5666   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
5667   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
5668     for ac_func in isinff
5669 do
5670 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5671 echo "configure:5672: checking for $ac_func" >&5
5672 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5673   echo $ac_n "(cached) $ac_c" 1>&6
5674 else
5675   cat > conftest.$ac_ext <<EOF
5676 #line 5677 "configure"
5677 #include "confdefs.h"
5678 /* System header to define __stub macros and hopefully few prototypes,
5679     which can conflict with char $ac_func(); below.  */
5680 #include <assert.h>
5681 /* Override any gcc2 internal prototype to avoid an error.  */
5682 /* We use char because int might match the return type of a gcc2
5683     builtin and then its argument prototype would still apply.  */
5684 char $ac_func();
5685
5686 int main() {
5687
5688 /* The GNU C library defines this for functions which it implements
5689     to always fail with ENOSYS.  Some functions are actually named
5690     something starting with __ and the normal name is an alias.  */
5691 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5692 choke me
5693 #else
5694 $ac_func();
5695 #endif
5696
5697 ; return 0; }
5698 EOF
5699 if { (eval echo configure:5700: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5700   rm -rf conftest*
5701   eval "ac_cv_func_$ac_func=yes"
5702 else
5703   echo "configure: failed program was:" >&5
5704   cat conftest.$ac_ext >&5
5705   rm -rf conftest*
5706   eval "ac_cv_func_$ac_func=no"
5707 fi
5708 rm -f conftest*
5709 fi
5710
5711 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5712   echo "$ac_t""yes" 1>&6
5713     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5714   cat >> confdefs.h <<EOF
5715 #define $ac_tr_func 1
5716 EOF
5717
5718 else
5719   echo "$ac_t""no" 1>&6
5720 fi
5721 done
5722
5723   fi
5724
5725
5726   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5727 echo "configure:5728: checking for acosf declaration" >&5
5728   if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
5729   echo $ac_n "(cached) $ac_c" 1>&6
5730 else
5731
5732
5733     ac_ext=C
5734 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5735 ac_cpp='$CXXCPP $CPPFLAGS'
5736 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5737 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5738 cross_compiling=$ac_cv_prog_cxx_cross
5739
5740     cat > conftest.$ac_ext <<EOF
5741 #line 5742 "configure"
5742 #include "confdefs.h"
5743 #include <math.h>
5744 int main() {
5745  acosf(0);
5746 ; return 0; }
5747 EOF
5748 if { (eval echo configure:5749: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5749   rm -rf conftest*
5750   glibcpp_cv_func_acosf_use=yes
5751 else
5752   echo "configure: failed program was:" >&5
5753   cat conftest.$ac_ext >&5
5754   rm -rf conftest*
5755   glibcpp_cv_func_acosf_use=no
5756 fi
5757 rm -f conftest*
5758     ac_ext=c
5759 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5760 ac_cpp='$CPP $CPPFLAGS'
5761 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5762 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5763 cross_compiling=$ac_cv_prog_cc_cross
5764
5765
5766 fi
5767
5768   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
5769   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
5770     for ac_func in acosf
5771 do
5772 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5773 echo "configure:5774: checking for $ac_func" >&5
5774 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5775   echo $ac_n "(cached) $ac_c" 1>&6
5776 else
5777   cat > conftest.$ac_ext <<EOF
5778 #line 5779 "configure"
5779 #include "confdefs.h"
5780 /* System header to define __stub macros and hopefully few prototypes,
5781     which can conflict with char $ac_func(); below.  */
5782 #include <assert.h>
5783 /* Override any gcc2 internal prototype to avoid an error.  */
5784 /* We use char because int might match the return type of a gcc2
5785     builtin and then its argument prototype would still apply.  */
5786 char $ac_func();
5787
5788 int main() {
5789
5790 /* The GNU C library defines this for functions which it implements
5791     to always fail with ENOSYS.  Some functions are actually named
5792     something starting with __ and the normal name is an alias.  */
5793 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5794 choke me
5795 #else
5796 $ac_func();
5797 #endif
5798
5799 ; return 0; }
5800 EOF
5801 if { (eval echo configure:5802: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5802   rm -rf conftest*
5803   eval "ac_cv_func_$ac_func=yes"
5804 else
5805   echo "configure: failed program was:" >&5
5806   cat conftest.$ac_ext >&5
5807   rm -rf conftest*
5808   eval "ac_cv_func_$ac_func=no"
5809 fi
5810 rm -f conftest*
5811 fi
5812
5813 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5814   echo "$ac_t""yes" 1>&6
5815     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5816   cat >> confdefs.h <<EOF
5817 #define $ac_tr_func 1
5818 EOF
5819
5820 else
5821   echo "$ac_t""no" 1>&6
5822 fi
5823 done
5824
5825   fi
5826
5827
5828   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5829 echo "configure:5830: checking for asinf declaration" >&5
5830   if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
5831   echo $ac_n "(cached) $ac_c" 1>&6
5832 else
5833
5834
5835     ac_ext=C
5836 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5837 ac_cpp='$CXXCPP $CPPFLAGS'
5838 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5839 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5840 cross_compiling=$ac_cv_prog_cxx_cross
5841
5842     cat > conftest.$ac_ext <<EOF
5843 #line 5844 "configure"
5844 #include "confdefs.h"
5845 #include <math.h>
5846 int main() {
5847  asinf(0);
5848 ; return 0; }
5849 EOF
5850 if { (eval echo configure:5851: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5851   rm -rf conftest*
5852   glibcpp_cv_func_asinf_use=yes
5853 else
5854   echo "configure: failed program was:" >&5
5855   cat conftest.$ac_ext >&5
5856   rm -rf conftest*
5857   glibcpp_cv_func_asinf_use=no
5858 fi
5859 rm -f conftest*
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
5868 fi
5869
5870   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
5871   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
5872     for ac_func in asinf
5873 do
5874 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5875 echo "configure:5876: checking for $ac_func" >&5
5876 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5877   echo $ac_n "(cached) $ac_c" 1>&6
5878 else
5879   cat > conftest.$ac_ext <<EOF
5880 #line 5881 "configure"
5881 #include "confdefs.h"
5882 /* System header to define __stub macros and hopefully few prototypes,
5883     which can conflict with char $ac_func(); below.  */
5884 #include <assert.h>
5885 /* Override any gcc2 internal prototype to avoid an error.  */
5886 /* We use char because int might match the return type of a gcc2
5887     builtin and then its argument prototype would still apply.  */
5888 char $ac_func();
5889
5890 int main() {
5891
5892 /* The GNU C library defines this for functions which it implements
5893     to always fail with ENOSYS.  Some functions are actually named
5894     something starting with __ and the normal name is an alias.  */
5895 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5896 choke me
5897 #else
5898 $ac_func();
5899 #endif
5900
5901 ; return 0; }
5902 EOF
5903 if { (eval echo configure:5904: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5904   rm -rf conftest*
5905   eval "ac_cv_func_$ac_func=yes"
5906 else
5907   echo "configure: failed program was:" >&5
5908   cat conftest.$ac_ext >&5
5909   rm -rf conftest*
5910   eval "ac_cv_func_$ac_func=no"
5911 fi
5912 rm -f conftest*
5913 fi
5914
5915 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5916   echo "$ac_t""yes" 1>&6
5917     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5918   cat >> confdefs.h <<EOF
5919 #define $ac_tr_func 1
5920 EOF
5921
5922 else
5923   echo "$ac_t""no" 1>&6
5924 fi
5925 done
5926
5927   fi
5928
5929
5930   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5931 echo "configure:5932: checking for atanf declaration" >&5
5932   if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
5933   echo $ac_n "(cached) $ac_c" 1>&6
5934 else
5935
5936
5937     ac_ext=C
5938 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5939 ac_cpp='$CXXCPP $CPPFLAGS'
5940 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5941 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5942 cross_compiling=$ac_cv_prog_cxx_cross
5943
5944     cat > conftest.$ac_ext <<EOF
5945 #line 5946 "configure"
5946 #include "confdefs.h"
5947 #include <math.h>
5948 int main() {
5949  atanf(0);
5950 ; return 0; }
5951 EOF
5952 if { (eval echo configure:5953: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5953   rm -rf conftest*
5954   glibcpp_cv_func_atanf_use=yes
5955 else
5956   echo "configure: failed program was:" >&5
5957   cat conftest.$ac_ext >&5
5958   rm -rf conftest*
5959   glibcpp_cv_func_atanf_use=no
5960 fi
5961 rm -f conftest*
5962     ac_ext=c
5963 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5964 ac_cpp='$CPP $CPPFLAGS'
5965 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5966 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5967 cross_compiling=$ac_cv_prog_cc_cross
5968
5969
5970 fi
5971
5972   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
5973   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
5974     for ac_func in atanf
5975 do
5976 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5977 echo "configure:5978: checking for $ac_func" >&5
5978 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5979   echo $ac_n "(cached) $ac_c" 1>&6
5980 else
5981   cat > conftest.$ac_ext <<EOF
5982 #line 5983 "configure"
5983 #include "confdefs.h"
5984 /* System header to define __stub macros and hopefully few prototypes,
5985     which can conflict with char $ac_func(); below.  */
5986 #include <assert.h>
5987 /* Override any gcc2 internal prototype to avoid an error.  */
5988 /* We use char because int might match the return type of a gcc2
5989     builtin and then its argument prototype would still apply.  */
5990 char $ac_func();
5991
5992 int main() {
5993
5994 /* The GNU C library defines this for functions which it implements
5995     to always fail with ENOSYS.  Some functions are actually named
5996     something starting with __ and the normal name is an alias.  */
5997 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5998 choke me
5999 #else
6000 $ac_func();
6001 #endif
6002
6003 ; return 0; }
6004 EOF
6005 if { (eval echo configure:6006: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6006   rm -rf conftest*
6007   eval "ac_cv_func_$ac_func=yes"
6008 else
6009   echo "configure: failed program was:" >&5
6010   cat conftest.$ac_ext >&5
6011   rm -rf conftest*
6012   eval "ac_cv_func_$ac_func=no"
6013 fi
6014 rm -f conftest*
6015 fi
6016
6017 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6018   echo "$ac_t""yes" 1>&6
6019     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6020   cat >> confdefs.h <<EOF
6021 #define $ac_tr_func 1
6022 EOF
6023
6024 else
6025   echo "$ac_t""no" 1>&6
6026 fi
6027 done
6028
6029   fi
6030
6031
6032   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
6033 echo "configure:6034: checking for atan2f declaration" >&5
6034   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
6035   echo $ac_n "(cached) $ac_c" 1>&6
6036 else
6037
6038
6039     ac_ext=C
6040 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6041 ac_cpp='$CXXCPP $CPPFLAGS'
6042 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6043 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6044 cross_compiling=$ac_cv_prog_cxx_cross
6045
6046     cat > conftest.$ac_ext <<EOF
6047 #line 6048 "configure"
6048 #include "confdefs.h"
6049 #include <math.h>
6050 int main() {
6051  atan2f(0, 0);
6052 ; return 0; }
6053 EOF
6054 if { (eval echo configure:6055: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6055   rm -rf conftest*
6056   glibcpp_cv_func_atan2f_use=yes
6057 else
6058   echo "configure: failed program was:" >&5
6059   cat conftest.$ac_ext >&5
6060   rm -rf conftest*
6061   glibcpp_cv_func_atan2f_use=no
6062 fi
6063 rm -f conftest*
6064     ac_ext=c
6065 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6066 ac_cpp='$CPP $CPPFLAGS'
6067 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6068 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6069 cross_compiling=$ac_cv_prog_cc_cross
6070
6071
6072 fi
6073
6074   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
6075   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
6076     for ac_func in atan2f
6077 do
6078 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6079 echo "configure:6080: checking for $ac_func" >&5
6080 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6081   echo $ac_n "(cached) $ac_c" 1>&6
6082 else
6083   cat > conftest.$ac_ext <<EOF
6084 #line 6085 "configure"
6085 #include "confdefs.h"
6086 /* System header to define __stub macros and hopefully few prototypes,
6087     which can conflict with char $ac_func(); below.  */
6088 #include <assert.h>
6089 /* Override any gcc2 internal prototype to avoid an error.  */
6090 /* We use char because int might match the return type of a gcc2
6091     builtin and then its argument prototype would still apply.  */
6092 char $ac_func();
6093
6094 int main() {
6095
6096 /* The GNU C library defines this for functions which it implements
6097     to always fail with ENOSYS.  Some functions are actually named
6098     something starting with __ and the normal name is an alias.  */
6099 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6100 choke me
6101 #else
6102 $ac_func();
6103 #endif
6104
6105 ; return 0; }
6106 EOF
6107 if { (eval echo configure:6108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6108   rm -rf conftest*
6109   eval "ac_cv_func_$ac_func=yes"
6110 else
6111   echo "configure: failed program was:" >&5
6112   cat conftest.$ac_ext >&5
6113   rm -rf conftest*
6114   eval "ac_cv_func_$ac_func=no"
6115 fi
6116 rm -f conftest*
6117 fi
6118
6119 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6120   echo "$ac_t""yes" 1>&6
6121     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6122   cat >> confdefs.h <<EOF
6123 #define $ac_tr_func 1
6124 EOF
6125
6126 else
6127   echo "$ac_t""no" 1>&6
6128 fi
6129 done
6130
6131   fi
6132
6133
6134   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6135 echo "configure:6136: checking for ceilf declaration" >&5
6136   if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
6137   echo $ac_n "(cached) $ac_c" 1>&6
6138 else
6139
6140
6141     ac_ext=C
6142 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6143 ac_cpp='$CXXCPP $CPPFLAGS'
6144 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6145 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6146 cross_compiling=$ac_cv_prog_cxx_cross
6147
6148     cat > conftest.$ac_ext <<EOF
6149 #line 6150 "configure"
6150 #include "confdefs.h"
6151 #include <math.h>
6152 int main() {
6153  ceilf(0);
6154 ; return 0; }
6155 EOF
6156 if { (eval echo configure:6157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6157   rm -rf conftest*
6158   glibcpp_cv_func_ceilf_use=yes
6159 else
6160   echo "configure: failed program was:" >&5
6161   cat conftest.$ac_ext >&5
6162   rm -rf conftest*
6163   glibcpp_cv_func_ceilf_use=no
6164 fi
6165 rm -f conftest*
6166     ac_ext=c
6167 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6168 ac_cpp='$CPP $CPPFLAGS'
6169 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6170 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6171 cross_compiling=$ac_cv_prog_cc_cross
6172
6173
6174 fi
6175
6176   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
6177   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
6178     for ac_func in ceilf
6179 do
6180 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6181 echo "configure:6182: checking for $ac_func" >&5
6182 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6183   echo $ac_n "(cached) $ac_c" 1>&6
6184 else
6185   cat > conftest.$ac_ext <<EOF
6186 #line 6187 "configure"
6187 #include "confdefs.h"
6188 /* System header to define __stub macros and hopefully few prototypes,
6189     which can conflict with char $ac_func(); below.  */
6190 #include <assert.h>
6191 /* Override any gcc2 internal prototype to avoid an error.  */
6192 /* We use char because int might match the return type of a gcc2
6193     builtin and then its argument prototype would still apply.  */
6194 char $ac_func();
6195
6196 int main() {
6197
6198 /* The GNU C library defines this for functions which it implements
6199     to always fail with ENOSYS.  Some functions are actually named
6200     something starting with __ and the normal name is an alias.  */
6201 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6202 choke me
6203 #else
6204 $ac_func();
6205 #endif
6206
6207 ; return 0; }
6208 EOF
6209 if { (eval echo configure:6210: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6210   rm -rf conftest*
6211   eval "ac_cv_func_$ac_func=yes"
6212 else
6213   echo "configure: failed program was:" >&5
6214   cat conftest.$ac_ext >&5
6215   rm -rf conftest*
6216   eval "ac_cv_func_$ac_func=no"
6217 fi
6218 rm -f conftest*
6219 fi
6220
6221 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6222   echo "$ac_t""yes" 1>&6
6223     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6224   cat >> confdefs.h <<EOF
6225 #define $ac_tr_func 1
6226 EOF
6227
6228 else
6229   echo "$ac_t""no" 1>&6
6230 fi
6231 done
6232
6233   fi
6234
6235
6236   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6237 echo "configure:6238: checking for cosf declaration" >&5
6238   if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
6239   echo $ac_n "(cached) $ac_c" 1>&6
6240 else
6241
6242
6243     ac_ext=C
6244 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6245 ac_cpp='$CXXCPP $CPPFLAGS'
6246 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6247 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6248 cross_compiling=$ac_cv_prog_cxx_cross
6249
6250     cat > conftest.$ac_ext <<EOF
6251 #line 6252 "configure"
6252 #include "confdefs.h"
6253 #include <math.h>
6254 int main() {
6255  cosf(0);
6256 ; return 0; }
6257 EOF
6258 if { (eval echo configure:6259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6259   rm -rf conftest*
6260   glibcpp_cv_func_cosf_use=yes
6261 else
6262   echo "configure: failed program was:" >&5
6263   cat conftest.$ac_ext >&5
6264   rm -rf conftest*
6265   glibcpp_cv_func_cosf_use=no
6266 fi
6267 rm -f conftest*
6268     ac_ext=c
6269 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6270 ac_cpp='$CPP $CPPFLAGS'
6271 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6272 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6273 cross_compiling=$ac_cv_prog_cc_cross
6274
6275
6276 fi
6277
6278   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
6279   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
6280     for ac_func in cosf
6281 do
6282 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6283 echo "configure:6284: checking for $ac_func" >&5
6284 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6285   echo $ac_n "(cached) $ac_c" 1>&6
6286 else
6287   cat > conftest.$ac_ext <<EOF
6288 #line 6289 "configure"
6289 #include "confdefs.h"
6290 /* System header to define __stub macros and hopefully few prototypes,
6291     which can conflict with char $ac_func(); below.  */
6292 #include <assert.h>
6293 /* Override any gcc2 internal prototype to avoid an error.  */
6294 /* We use char because int might match the return type of a gcc2
6295     builtin and then its argument prototype would still apply.  */
6296 char $ac_func();
6297
6298 int main() {
6299
6300 /* The GNU C library defines this for functions which it implements
6301     to always fail with ENOSYS.  Some functions are actually named
6302     something starting with __ and the normal name is an alias.  */
6303 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6304 choke me
6305 #else
6306 $ac_func();
6307 #endif
6308
6309 ; return 0; }
6310 EOF
6311 if { (eval echo configure:6312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6312   rm -rf conftest*
6313   eval "ac_cv_func_$ac_func=yes"
6314 else
6315   echo "configure: failed program was:" >&5
6316   cat conftest.$ac_ext >&5
6317   rm -rf conftest*
6318   eval "ac_cv_func_$ac_func=no"
6319 fi
6320 rm -f conftest*
6321 fi
6322
6323 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6324   echo "$ac_t""yes" 1>&6
6325     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6326   cat >> confdefs.h <<EOF
6327 #define $ac_tr_func 1
6328 EOF
6329
6330 else
6331   echo "$ac_t""no" 1>&6
6332 fi
6333 done
6334
6335   fi
6336
6337
6338   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6339 echo "configure:6340: checking for coshf declaration" >&5
6340   if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
6341   echo $ac_n "(cached) $ac_c" 1>&6
6342 else
6343
6344
6345     ac_ext=C
6346 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6347 ac_cpp='$CXXCPP $CPPFLAGS'
6348 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6349 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6350 cross_compiling=$ac_cv_prog_cxx_cross
6351
6352     cat > conftest.$ac_ext <<EOF
6353 #line 6354 "configure"
6354 #include "confdefs.h"
6355 #include <math.h>
6356 int main() {
6357  coshf(0);
6358 ; return 0; }
6359 EOF
6360 if { (eval echo configure:6361: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6361   rm -rf conftest*
6362   glibcpp_cv_func_coshf_use=yes
6363 else
6364   echo "configure: failed program was:" >&5
6365   cat conftest.$ac_ext >&5
6366   rm -rf conftest*
6367   glibcpp_cv_func_coshf_use=no
6368 fi
6369 rm -f conftest*
6370     ac_ext=c
6371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6372 ac_cpp='$CPP $CPPFLAGS'
6373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6375 cross_compiling=$ac_cv_prog_cc_cross
6376
6377
6378 fi
6379
6380   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
6381   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
6382     for ac_func in coshf
6383 do
6384 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6385 echo "configure:6386: checking for $ac_func" >&5
6386 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6387   echo $ac_n "(cached) $ac_c" 1>&6
6388 else
6389   cat > conftest.$ac_ext <<EOF
6390 #line 6391 "configure"
6391 #include "confdefs.h"
6392 /* System header to define __stub macros and hopefully few prototypes,
6393     which can conflict with char $ac_func(); below.  */
6394 #include <assert.h>
6395 /* Override any gcc2 internal prototype to avoid an error.  */
6396 /* We use char because int might match the return type of a gcc2
6397     builtin and then its argument prototype would still apply.  */
6398 char $ac_func();
6399
6400 int main() {
6401
6402 /* The GNU C library defines this for functions which it implements
6403     to always fail with ENOSYS.  Some functions are actually named
6404     something starting with __ and the normal name is an alias.  */
6405 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6406 choke me
6407 #else
6408 $ac_func();
6409 #endif
6410
6411 ; return 0; }
6412 EOF
6413 if { (eval echo configure:6414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6414   rm -rf conftest*
6415   eval "ac_cv_func_$ac_func=yes"
6416 else
6417   echo "configure: failed program was:" >&5
6418   cat conftest.$ac_ext >&5
6419   rm -rf conftest*
6420   eval "ac_cv_func_$ac_func=no"
6421 fi
6422 rm -f conftest*
6423 fi
6424
6425 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6426   echo "$ac_t""yes" 1>&6
6427     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6428   cat >> confdefs.h <<EOF
6429 #define $ac_tr_func 1
6430 EOF
6431
6432 else
6433   echo "$ac_t""no" 1>&6
6434 fi
6435 done
6436
6437   fi
6438
6439
6440   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6441 echo "configure:6442: checking for expf declaration" >&5
6442   if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
6443   echo $ac_n "(cached) $ac_c" 1>&6
6444 else
6445
6446
6447     ac_ext=C
6448 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6449 ac_cpp='$CXXCPP $CPPFLAGS'
6450 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6451 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6452 cross_compiling=$ac_cv_prog_cxx_cross
6453
6454     cat > conftest.$ac_ext <<EOF
6455 #line 6456 "configure"
6456 #include "confdefs.h"
6457 #include <math.h>
6458 int main() {
6459  expf(0);
6460 ; return 0; }
6461 EOF
6462 if { (eval echo configure:6463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6463   rm -rf conftest*
6464   glibcpp_cv_func_expf_use=yes
6465 else
6466   echo "configure: failed program was:" >&5
6467   cat conftest.$ac_ext >&5
6468   rm -rf conftest*
6469   glibcpp_cv_func_expf_use=no
6470 fi
6471 rm -f conftest*
6472     ac_ext=c
6473 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6474 ac_cpp='$CPP $CPPFLAGS'
6475 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6476 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6477 cross_compiling=$ac_cv_prog_cc_cross
6478
6479
6480 fi
6481
6482   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
6483   if test x$glibcpp_cv_func_expf_use = x"yes"; then
6484     for ac_func in expf
6485 do
6486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6487 echo "configure:6488: checking for $ac_func" >&5
6488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6489   echo $ac_n "(cached) $ac_c" 1>&6
6490 else
6491   cat > conftest.$ac_ext <<EOF
6492 #line 6493 "configure"
6493 #include "confdefs.h"
6494 /* System header to define __stub macros and hopefully few prototypes,
6495     which can conflict with char $ac_func(); below.  */
6496 #include <assert.h>
6497 /* Override any gcc2 internal prototype to avoid an error.  */
6498 /* We use char because int might match the return type of a gcc2
6499     builtin and then its argument prototype would still apply.  */
6500 char $ac_func();
6501
6502 int main() {
6503
6504 /* The GNU C library defines this for functions which it implements
6505     to always fail with ENOSYS.  Some functions are actually named
6506     something starting with __ and the normal name is an alias.  */
6507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6508 choke me
6509 #else
6510 $ac_func();
6511 #endif
6512
6513 ; return 0; }
6514 EOF
6515 if { (eval echo configure:6516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6516   rm -rf conftest*
6517   eval "ac_cv_func_$ac_func=yes"
6518 else
6519   echo "configure: failed program was:" >&5
6520   cat conftest.$ac_ext >&5
6521   rm -rf conftest*
6522   eval "ac_cv_func_$ac_func=no"
6523 fi
6524 rm -f conftest*
6525 fi
6526
6527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6528   echo "$ac_t""yes" 1>&6
6529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6530   cat >> confdefs.h <<EOF
6531 #define $ac_tr_func 1
6532 EOF
6533
6534 else
6535   echo "$ac_t""no" 1>&6
6536 fi
6537 done
6538
6539   fi
6540
6541
6542   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6543 echo "configure:6544: checking for fabsf declaration" >&5
6544   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
6545   echo $ac_n "(cached) $ac_c" 1>&6
6546 else
6547
6548
6549     ac_ext=C
6550 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6551 ac_cpp='$CXXCPP $CPPFLAGS'
6552 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6553 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6554 cross_compiling=$ac_cv_prog_cxx_cross
6555
6556     cat > conftest.$ac_ext <<EOF
6557 #line 6558 "configure"
6558 #include "confdefs.h"
6559 #include <math.h>
6560 int main() {
6561  fabsf(0);
6562 ; return 0; }
6563 EOF
6564 if { (eval echo configure:6565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6565   rm -rf conftest*
6566   glibcpp_cv_func_fabsf_use=yes
6567 else
6568   echo "configure: failed program was:" >&5
6569   cat conftest.$ac_ext >&5
6570   rm -rf conftest*
6571   glibcpp_cv_func_fabsf_use=no
6572 fi
6573 rm -f conftest*
6574     ac_ext=c
6575 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6576 ac_cpp='$CPP $CPPFLAGS'
6577 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6578 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6579 cross_compiling=$ac_cv_prog_cc_cross
6580
6581
6582 fi
6583
6584   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
6585   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
6586     for ac_func in fabsf
6587 do
6588 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6589 echo "configure:6590: checking for $ac_func" >&5
6590 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6591   echo $ac_n "(cached) $ac_c" 1>&6
6592 else
6593   cat > conftest.$ac_ext <<EOF
6594 #line 6595 "configure"
6595 #include "confdefs.h"
6596 /* System header to define __stub macros and hopefully few prototypes,
6597     which can conflict with char $ac_func(); below.  */
6598 #include <assert.h>
6599 /* Override any gcc2 internal prototype to avoid an error.  */
6600 /* We use char because int might match the return type of a gcc2
6601     builtin and then its argument prototype would still apply.  */
6602 char $ac_func();
6603
6604 int main() {
6605
6606 /* The GNU C library defines this for functions which it implements
6607     to always fail with ENOSYS.  Some functions are actually named
6608     something starting with __ and the normal name is an alias.  */
6609 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6610 choke me
6611 #else
6612 $ac_func();
6613 #endif
6614
6615 ; return 0; }
6616 EOF
6617 if { (eval echo configure:6618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6618   rm -rf conftest*
6619   eval "ac_cv_func_$ac_func=yes"
6620 else
6621   echo "configure: failed program was:" >&5
6622   cat conftest.$ac_ext >&5
6623   rm -rf conftest*
6624   eval "ac_cv_func_$ac_func=no"
6625 fi
6626 rm -f conftest*
6627 fi
6628
6629 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6630   echo "$ac_t""yes" 1>&6
6631     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6632   cat >> confdefs.h <<EOF
6633 #define $ac_tr_func 1
6634 EOF
6635
6636 else
6637   echo "$ac_t""no" 1>&6
6638 fi
6639 done
6640
6641   fi
6642
6643
6644   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6645 echo "configure:6646: checking for floorf declaration" >&5
6646   if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
6647   echo $ac_n "(cached) $ac_c" 1>&6
6648 else
6649
6650
6651     ac_ext=C
6652 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6653 ac_cpp='$CXXCPP $CPPFLAGS'
6654 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6655 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6656 cross_compiling=$ac_cv_prog_cxx_cross
6657
6658     cat > conftest.$ac_ext <<EOF
6659 #line 6660 "configure"
6660 #include "confdefs.h"
6661 #include <math.h>
6662 int main() {
6663  floorf(0);
6664 ; return 0; }
6665 EOF
6666 if { (eval echo configure:6667: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6667   rm -rf conftest*
6668   glibcpp_cv_func_floorf_use=yes
6669 else
6670   echo "configure: failed program was:" >&5
6671   cat conftest.$ac_ext >&5
6672   rm -rf conftest*
6673   glibcpp_cv_func_floorf_use=no
6674 fi
6675 rm -f conftest*
6676     ac_ext=c
6677 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6678 ac_cpp='$CPP $CPPFLAGS'
6679 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6680 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6681 cross_compiling=$ac_cv_prog_cc_cross
6682
6683
6684 fi
6685
6686   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
6687   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
6688     for ac_func in floorf
6689 do
6690 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6691 echo "configure:6692: checking for $ac_func" >&5
6692 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6693   echo $ac_n "(cached) $ac_c" 1>&6
6694 else
6695   cat > conftest.$ac_ext <<EOF
6696 #line 6697 "configure"
6697 #include "confdefs.h"
6698 /* System header to define __stub macros and hopefully few prototypes,
6699     which can conflict with char $ac_func(); below.  */
6700 #include <assert.h>
6701 /* Override any gcc2 internal prototype to avoid an error.  */
6702 /* We use char because int might match the return type of a gcc2
6703     builtin and then its argument prototype would still apply.  */
6704 char $ac_func();
6705
6706 int main() {
6707
6708 /* The GNU C library defines this for functions which it implements
6709     to always fail with ENOSYS.  Some functions are actually named
6710     something starting with __ and the normal name is an alias.  */
6711 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6712 choke me
6713 #else
6714 $ac_func();
6715 #endif
6716
6717 ; return 0; }
6718 EOF
6719 if { (eval echo configure:6720: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6720   rm -rf conftest*
6721   eval "ac_cv_func_$ac_func=yes"
6722 else
6723   echo "configure: failed program was:" >&5
6724   cat conftest.$ac_ext >&5
6725   rm -rf conftest*
6726   eval "ac_cv_func_$ac_func=no"
6727 fi
6728 rm -f conftest*
6729 fi
6730
6731 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6732   echo "$ac_t""yes" 1>&6
6733     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6734   cat >> confdefs.h <<EOF
6735 #define $ac_tr_func 1
6736 EOF
6737
6738 else
6739   echo "$ac_t""no" 1>&6
6740 fi
6741 done
6742
6743   fi
6744
6745
6746   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6747 echo "configure:6748: checking for fmodf declaration" >&5
6748   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
6749   echo $ac_n "(cached) $ac_c" 1>&6
6750 else
6751
6752
6753     ac_ext=C
6754 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6755 ac_cpp='$CXXCPP $CPPFLAGS'
6756 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6757 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6758 cross_compiling=$ac_cv_prog_cxx_cross
6759
6760     cat > conftest.$ac_ext <<EOF
6761 #line 6762 "configure"
6762 #include "confdefs.h"
6763 #include <math.h>
6764 int main() {
6765  fmodf(0, 0);
6766 ; return 0; }
6767 EOF
6768 if { (eval echo configure:6769: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6769   rm -rf conftest*
6770   glibcpp_cv_func_fmodf_use=yes
6771 else
6772   echo "configure: failed program was:" >&5
6773   cat conftest.$ac_ext >&5
6774   rm -rf conftest*
6775   glibcpp_cv_func_fmodf_use=no
6776 fi
6777 rm -f conftest*
6778     ac_ext=c
6779 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6780 ac_cpp='$CPP $CPPFLAGS'
6781 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6782 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6783 cross_compiling=$ac_cv_prog_cc_cross
6784
6785
6786 fi
6787
6788   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
6789   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
6790     for ac_func in fmodf
6791 do
6792 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6793 echo "configure:6794: checking for $ac_func" >&5
6794 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6795   echo $ac_n "(cached) $ac_c" 1>&6
6796 else
6797   cat > conftest.$ac_ext <<EOF
6798 #line 6799 "configure"
6799 #include "confdefs.h"
6800 /* System header to define __stub macros and hopefully few prototypes,
6801     which can conflict with char $ac_func(); below.  */
6802 #include <assert.h>
6803 /* Override any gcc2 internal prototype to avoid an error.  */
6804 /* We use char because int might match the return type of a gcc2
6805     builtin and then its argument prototype would still apply.  */
6806 char $ac_func();
6807
6808 int main() {
6809
6810 /* The GNU C library defines this for functions which it implements
6811     to always fail with ENOSYS.  Some functions are actually named
6812     something starting with __ and the normal name is an alias.  */
6813 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6814 choke me
6815 #else
6816 $ac_func();
6817 #endif
6818
6819 ; return 0; }
6820 EOF
6821 if { (eval echo configure:6822: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6822   rm -rf conftest*
6823   eval "ac_cv_func_$ac_func=yes"
6824 else
6825   echo "configure: failed program was:" >&5
6826   cat conftest.$ac_ext >&5
6827   rm -rf conftest*
6828   eval "ac_cv_func_$ac_func=no"
6829 fi
6830 rm -f conftest*
6831 fi
6832
6833 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6834   echo "$ac_t""yes" 1>&6
6835     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6836   cat >> confdefs.h <<EOF
6837 #define $ac_tr_func 1
6838 EOF
6839
6840 else
6841   echo "$ac_t""no" 1>&6
6842 fi
6843 done
6844
6845   fi
6846
6847
6848   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6849 echo "configure:6850: checking for frexpf declaration" >&5
6850   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
6851   echo $ac_n "(cached) $ac_c" 1>&6
6852 else
6853
6854
6855     ac_ext=C
6856 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6857 ac_cpp='$CXXCPP $CPPFLAGS'
6858 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6859 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6860 cross_compiling=$ac_cv_prog_cxx_cross
6861
6862     cat > conftest.$ac_ext <<EOF
6863 #line 6864 "configure"
6864 #include "confdefs.h"
6865 #include <math.h>
6866 int main() {
6867  frexpf(0, 0);
6868 ; return 0; }
6869 EOF
6870 if { (eval echo configure:6871: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6871   rm -rf conftest*
6872   glibcpp_cv_func_frexpf_use=yes
6873 else
6874   echo "configure: failed program was:" >&5
6875   cat conftest.$ac_ext >&5
6876   rm -rf conftest*
6877   glibcpp_cv_func_frexpf_use=no
6878 fi
6879 rm -f conftest*
6880     ac_ext=c
6881 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6882 ac_cpp='$CPP $CPPFLAGS'
6883 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6884 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6885 cross_compiling=$ac_cv_prog_cc_cross
6886
6887
6888 fi
6889
6890   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
6891   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
6892     for ac_func in frexpf
6893 do
6894 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6895 echo "configure:6896: checking for $ac_func" >&5
6896 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6897   echo $ac_n "(cached) $ac_c" 1>&6
6898 else
6899   cat > conftest.$ac_ext <<EOF
6900 #line 6901 "configure"
6901 #include "confdefs.h"
6902 /* System header to define __stub macros and hopefully few prototypes,
6903     which can conflict with char $ac_func(); below.  */
6904 #include <assert.h>
6905 /* Override any gcc2 internal prototype to avoid an error.  */
6906 /* We use char because int might match the return type of a gcc2
6907     builtin and then its argument prototype would still apply.  */
6908 char $ac_func();
6909
6910 int main() {
6911
6912 /* The GNU C library defines this for functions which it implements
6913     to always fail with ENOSYS.  Some functions are actually named
6914     something starting with __ and the normal name is an alias.  */
6915 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6916 choke me
6917 #else
6918 $ac_func();
6919 #endif
6920
6921 ; return 0; }
6922 EOF
6923 if { (eval echo configure:6924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6924   rm -rf conftest*
6925   eval "ac_cv_func_$ac_func=yes"
6926 else
6927   echo "configure: failed program was:" >&5
6928   cat conftest.$ac_ext >&5
6929   rm -rf conftest*
6930   eval "ac_cv_func_$ac_func=no"
6931 fi
6932 rm -f conftest*
6933 fi
6934
6935 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6936   echo "$ac_t""yes" 1>&6
6937     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6938   cat >> confdefs.h <<EOF
6939 #define $ac_tr_func 1
6940 EOF
6941
6942 else
6943   echo "$ac_t""no" 1>&6
6944 fi
6945 done
6946
6947   fi
6948
6949
6950   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6951 echo "configure:6952: checking for ldexpf declaration" >&5
6952   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
6953   echo $ac_n "(cached) $ac_c" 1>&6
6954 else
6955
6956
6957     ac_ext=C
6958 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6959 ac_cpp='$CXXCPP $CPPFLAGS'
6960 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6961 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6962 cross_compiling=$ac_cv_prog_cxx_cross
6963
6964     cat > conftest.$ac_ext <<EOF
6965 #line 6966 "configure"
6966 #include "confdefs.h"
6967 #include <math.h>
6968 int main() {
6969  ldexpf(0, 0);
6970 ; return 0; }
6971 EOF
6972 if { (eval echo configure:6973: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6973   rm -rf conftest*
6974   glibcpp_cv_func_ldexpf_use=yes
6975 else
6976   echo "configure: failed program was:" >&5
6977   cat conftest.$ac_ext >&5
6978   rm -rf conftest*
6979   glibcpp_cv_func_ldexpf_use=no
6980 fi
6981 rm -f conftest*
6982     ac_ext=c
6983 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6984 ac_cpp='$CPP $CPPFLAGS'
6985 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6986 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6987 cross_compiling=$ac_cv_prog_cc_cross
6988
6989
6990 fi
6991
6992   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
6993   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
6994     for ac_func in ldexpf
6995 do
6996 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6997 echo "configure:6998: checking for $ac_func" >&5
6998 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6999   echo $ac_n "(cached) $ac_c" 1>&6
7000 else
7001   cat > conftest.$ac_ext <<EOF
7002 #line 7003 "configure"
7003 #include "confdefs.h"
7004 /* System header to define __stub macros and hopefully few prototypes,
7005     which can conflict with char $ac_func(); below.  */
7006 #include <assert.h>
7007 /* Override any gcc2 internal prototype to avoid an error.  */
7008 /* We use char because int might match the return type of a gcc2
7009     builtin and then its argument prototype would still apply.  */
7010 char $ac_func();
7011
7012 int main() {
7013
7014 /* The GNU C library defines this for functions which it implements
7015     to always fail with ENOSYS.  Some functions are actually named
7016     something starting with __ and the normal name is an alias.  */
7017 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7018 choke me
7019 #else
7020 $ac_func();
7021 #endif
7022
7023 ; return 0; }
7024 EOF
7025 if { (eval echo configure:7026: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7026   rm -rf conftest*
7027   eval "ac_cv_func_$ac_func=yes"
7028 else
7029   echo "configure: failed program was:" >&5
7030   cat conftest.$ac_ext >&5
7031   rm -rf conftest*
7032   eval "ac_cv_func_$ac_func=no"
7033 fi
7034 rm -f conftest*
7035 fi
7036
7037 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7038   echo "$ac_t""yes" 1>&6
7039     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7040   cat >> confdefs.h <<EOF
7041 #define $ac_tr_func 1
7042 EOF
7043
7044 else
7045   echo "$ac_t""no" 1>&6
7046 fi
7047 done
7048
7049   fi
7050
7051
7052   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
7053 echo "configure:7054: checking for logf declaration" >&5
7054   if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
7055   echo $ac_n "(cached) $ac_c" 1>&6
7056 else
7057
7058
7059     ac_ext=C
7060 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7061 ac_cpp='$CXXCPP $CPPFLAGS'
7062 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7063 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7064 cross_compiling=$ac_cv_prog_cxx_cross
7065
7066     cat > conftest.$ac_ext <<EOF
7067 #line 7068 "configure"
7068 #include "confdefs.h"
7069 #include <math.h>
7070 int main() {
7071  logf(0);
7072 ; return 0; }
7073 EOF
7074 if { (eval echo configure:7075: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7075   rm -rf conftest*
7076   glibcpp_cv_func_logf_use=yes
7077 else
7078   echo "configure: failed program was:" >&5
7079   cat conftest.$ac_ext >&5
7080   rm -rf conftest*
7081   glibcpp_cv_func_logf_use=no
7082 fi
7083 rm -f conftest*
7084     ac_ext=c
7085 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7086 ac_cpp='$CPP $CPPFLAGS'
7087 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7088 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7089 cross_compiling=$ac_cv_prog_cc_cross
7090
7091
7092 fi
7093
7094   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
7095   if test x$glibcpp_cv_func_logf_use = x"yes"; then
7096     for ac_func in logf
7097 do
7098 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7099 echo "configure:7100: checking for $ac_func" >&5
7100 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7101   echo $ac_n "(cached) $ac_c" 1>&6
7102 else
7103   cat > conftest.$ac_ext <<EOF
7104 #line 7105 "configure"
7105 #include "confdefs.h"
7106 /* System header to define __stub macros and hopefully few prototypes,
7107     which can conflict with char $ac_func(); below.  */
7108 #include <assert.h>
7109 /* Override any gcc2 internal prototype to avoid an error.  */
7110 /* We use char because int might match the return type of a gcc2
7111     builtin and then its argument prototype would still apply.  */
7112 char $ac_func();
7113
7114 int main() {
7115
7116 /* The GNU C library defines this for functions which it implements
7117     to always fail with ENOSYS.  Some functions are actually named
7118     something starting with __ and the normal name is an alias.  */
7119 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7120 choke me
7121 #else
7122 $ac_func();
7123 #endif
7124
7125 ; return 0; }
7126 EOF
7127 if { (eval echo configure:7128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7128   rm -rf conftest*
7129   eval "ac_cv_func_$ac_func=yes"
7130 else
7131   echo "configure: failed program was:" >&5
7132   cat conftest.$ac_ext >&5
7133   rm -rf conftest*
7134   eval "ac_cv_func_$ac_func=no"
7135 fi
7136 rm -f conftest*
7137 fi
7138
7139 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7140   echo "$ac_t""yes" 1>&6
7141     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7142   cat >> confdefs.h <<EOF
7143 #define $ac_tr_func 1
7144 EOF
7145
7146 else
7147   echo "$ac_t""no" 1>&6
7148 fi
7149 done
7150
7151   fi
7152
7153
7154   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7155 echo "configure:7156: checking for log10f declaration" >&5
7156   if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
7157   echo $ac_n "(cached) $ac_c" 1>&6
7158 else
7159
7160
7161     ac_ext=C
7162 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7163 ac_cpp='$CXXCPP $CPPFLAGS'
7164 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7165 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7166 cross_compiling=$ac_cv_prog_cxx_cross
7167
7168     cat > conftest.$ac_ext <<EOF
7169 #line 7170 "configure"
7170 #include "confdefs.h"
7171 #include <math.h>
7172 int main() {
7173  log10f(0);
7174 ; return 0; }
7175 EOF
7176 if { (eval echo configure:7177: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7177   rm -rf conftest*
7178   glibcpp_cv_func_log10f_use=yes
7179 else
7180   echo "configure: failed program was:" >&5
7181   cat conftest.$ac_ext >&5
7182   rm -rf conftest*
7183   glibcpp_cv_func_log10f_use=no
7184 fi
7185 rm -f conftest*
7186     ac_ext=c
7187 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7188 ac_cpp='$CPP $CPPFLAGS'
7189 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7190 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7191 cross_compiling=$ac_cv_prog_cc_cross
7192
7193
7194 fi
7195
7196   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
7197   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
7198     for ac_func in log10f
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   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7257 echo "configure:7258: checking for modff declaration" >&5
7258   if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
7259   echo $ac_n "(cached) $ac_c" 1>&6
7260 else
7261
7262
7263     ac_ext=C
7264 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7265 ac_cpp='$CXXCPP $CPPFLAGS'
7266 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7267 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7268 cross_compiling=$ac_cv_prog_cxx_cross
7269
7270     cat > conftest.$ac_ext <<EOF
7271 #line 7272 "configure"
7272 #include "confdefs.h"
7273 #include <math.h>
7274 int main() {
7275  modff(0, 0);
7276 ; return 0; }
7277 EOF
7278 if { (eval echo configure:7279: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7279   rm -rf conftest*
7280   glibcpp_cv_func_modff_use=yes
7281 else
7282   echo "configure: failed program was:" >&5
7283   cat conftest.$ac_ext >&5
7284   rm -rf conftest*
7285   glibcpp_cv_func_modff_use=no
7286 fi
7287 rm -f conftest*
7288     ac_ext=c
7289 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7290 ac_cpp='$CPP $CPPFLAGS'
7291 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7292 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7293 cross_compiling=$ac_cv_prog_cc_cross
7294
7295
7296 fi
7297
7298   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
7299   if test x$glibcpp_cv_func_modff_use = x"yes"; then
7300     for ac_func in modff
7301 do
7302 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7303 echo "configure:7304: checking for $ac_func" >&5
7304 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7305   echo $ac_n "(cached) $ac_c" 1>&6
7306 else
7307   cat > conftest.$ac_ext <<EOF
7308 #line 7309 "configure"
7309 #include "confdefs.h"
7310 /* System header to define __stub macros and hopefully few prototypes,
7311     which can conflict with char $ac_func(); below.  */
7312 #include <assert.h>
7313 /* Override any gcc2 internal prototype to avoid an error.  */
7314 /* We use char because int might match the return type of a gcc2
7315     builtin and then its argument prototype would still apply.  */
7316 char $ac_func();
7317
7318 int main() {
7319
7320 /* The GNU C library defines this for functions which it implements
7321     to always fail with ENOSYS.  Some functions are actually named
7322     something starting with __ and the normal name is an alias.  */
7323 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7324 choke me
7325 #else
7326 $ac_func();
7327 #endif
7328
7329 ; return 0; }
7330 EOF
7331 if { (eval echo configure:7332: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7332   rm -rf conftest*
7333   eval "ac_cv_func_$ac_func=yes"
7334 else
7335   echo "configure: failed program was:" >&5
7336   cat conftest.$ac_ext >&5
7337   rm -rf conftest*
7338   eval "ac_cv_func_$ac_func=no"
7339 fi
7340 rm -f conftest*
7341 fi
7342
7343 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7344   echo "$ac_t""yes" 1>&6
7345     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7346   cat >> confdefs.h <<EOF
7347 #define $ac_tr_func 1
7348 EOF
7349
7350 else
7351   echo "$ac_t""no" 1>&6
7352 fi
7353 done
7354
7355   fi
7356
7357
7358   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
7359 echo "configure:7360: checking for powf declaration" >&5
7360   if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
7361   echo $ac_n "(cached) $ac_c" 1>&6
7362 else
7363
7364
7365     ac_ext=C
7366 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7367 ac_cpp='$CXXCPP $CPPFLAGS'
7368 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7369 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7370 cross_compiling=$ac_cv_prog_cxx_cross
7371
7372     cat > conftest.$ac_ext <<EOF
7373 #line 7374 "configure"
7374 #include "confdefs.h"
7375 #include <math.h>
7376 int main() {
7377  powf(0, 0);
7378 ; return 0; }
7379 EOF
7380 if { (eval echo configure:7381: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7381   rm -rf conftest*
7382   glibcpp_cv_func_powf_use=yes
7383 else
7384   echo "configure: failed program was:" >&5
7385   cat conftest.$ac_ext >&5
7386   rm -rf conftest*
7387   glibcpp_cv_func_powf_use=no
7388 fi
7389 rm -f conftest*
7390     ac_ext=c
7391 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7392 ac_cpp='$CPP $CPPFLAGS'
7393 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7394 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7395 cross_compiling=$ac_cv_prog_cc_cross
7396
7397
7398 fi
7399
7400   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
7401   if test x$glibcpp_cv_func_powf_use = x"yes"; then
7402     for ac_func in powf
7403 do
7404 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7405 echo "configure:7406: checking for $ac_func" >&5
7406 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7407   echo $ac_n "(cached) $ac_c" 1>&6
7408 else
7409   cat > conftest.$ac_ext <<EOF
7410 #line 7411 "configure"
7411 #include "confdefs.h"
7412 /* System header to define __stub macros and hopefully few prototypes,
7413     which can conflict with char $ac_func(); below.  */
7414 #include <assert.h>
7415 /* Override any gcc2 internal prototype to avoid an error.  */
7416 /* We use char because int might match the return type of a gcc2
7417     builtin and then its argument prototype would still apply.  */
7418 char $ac_func();
7419
7420 int main() {
7421
7422 /* The GNU C library defines this for functions which it implements
7423     to always fail with ENOSYS.  Some functions are actually named
7424     something starting with __ and the normal name is an alias.  */
7425 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7426 choke me
7427 #else
7428 $ac_func();
7429 #endif
7430
7431 ; return 0; }
7432 EOF
7433 if { (eval echo configure:7434: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7434   rm -rf conftest*
7435   eval "ac_cv_func_$ac_func=yes"
7436 else
7437   echo "configure: failed program was:" >&5
7438   cat conftest.$ac_ext >&5
7439   rm -rf conftest*
7440   eval "ac_cv_func_$ac_func=no"
7441 fi
7442 rm -f conftest*
7443 fi
7444
7445 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7446   echo "$ac_t""yes" 1>&6
7447     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7448   cat >> confdefs.h <<EOF
7449 #define $ac_tr_func 1
7450 EOF
7451
7452 else
7453   echo "$ac_t""no" 1>&6
7454 fi
7455 done
7456
7457   fi
7458
7459
7460   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
7461 echo "configure:7462: checking for sinf declaration" >&5
7462   if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
7463   echo $ac_n "(cached) $ac_c" 1>&6
7464 else
7465
7466
7467     ac_ext=C
7468 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7469 ac_cpp='$CXXCPP $CPPFLAGS'
7470 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7471 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7472 cross_compiling=$ac_cv_prog_cxx_cross
7473
7474     cat > conftest.$ac_ext <<EOF
7475 #line 7476 "configure"
7476 #include "confdefs.h"
7477 #include <math.h>
7478 int main() {
7479  sinf(0);
7480 ; return 0; }
7481 EOF
7482 if { (eval echo configure:7483: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7483   rm -rf conftest*
7484   glibcpp_cv_func_sinf_use=yes
7485 else
7486   echo "configure: failed program was:" >&5
7487   cat conftest.$ac_ext >&5
7488   rm -rf conftest*
7489   glibcpp_cv_func_sinf_use=no
7490 fi
7491 rm -f conftest*
7492     ac_ext=c
7493 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7494 ac_cpp='$CPP $CPPFLAGS'
7495 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7496 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7497 cross_compiling=$ac_cv_prog_cc_cross
7498
7499
7500 fi
7501
7502   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
7503   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
7504     for ac_func in sinf
7505 do
7506 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7507 echo "configure:7508: checking for $ac_func" >&5
7508 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7509   echo $ac_n "(cached) $ac_c" 1>&6
7510 else
7511   cat > conftest.$ac_ext <<EOF
7512 #line 7513 "configure"
7513 #include "confdefs.h"
7514 /* System header to define __stub macros and hopefully few prototypes,
7515     which can conflict with char $ac_func(); below.  */
7516 #include <assert.h>
7517 /* Override any gcc2 internal prototype to avoid an error.  */
7518 /* We use char because int might match the return type of a gcc2
7519     builtin and then its argument prototype would still apply.  */
7520 char $ac_func();
7521
7522 int main() {
7523
7524 /* The GNU C library defines this for functions which it implements
7525     to always fail with ENOSYS.  Some functions are actually named
7526     something starting with __ and the normal name is an alias.  */
7527 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7528 choke me
7529 #else
7530 $ac_func();
7531 #endif
7532
7533 ; return 0; }
7534 EOF
7535 if { (eval echo configure:7536: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7536   rm -rf conftest*
7537   eval "ac_cv_func_$ac_func=yes"
7538 else
7539   echo "configure: failed program was:" >&5
7540   cat conftest.$ac_ext >&5
7541   rm -rf conftest*
7542   eval "ac_cv_func_$ac_func=no"
7543 fi
7544 rm -f conftest*
7545 fi
7546
7547 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7548   echo "$ac_t""yes" 1>&6
7549     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7550   cat >> confdefs.h <<EOF
7551 #define $ac_tr_func 1
7552 EOF
7553
7554 else
7555   echo "$ac_t""no" 1>&6
7556 fi
7557 done
7558
7559   fi
7560
7561
7562   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
7563 echo "configure:7564: checking for sinhf declaration" >&5
7564   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
7565   echo $ac_n "(cached) $ac_c" 1>&6
7566 else
7567
7568
7569     ac_ext=C
7570 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7571 ac_cpp='$CXXCPP $CPPFLAGS'
7572 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7573 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7574 cross_compiling=$ac_cv_prog_cxx_cross
7575
7576     cat > conftest.$ac_ext <<EOF
7577 #line 7578 "configure"
7578 #include "confdefs.h"
7579 #include <math.h>
7580 int main() {
7581  sinhf(0);
7582 ; return 0; }
7583 EOF
7584 if { (eval echo configure:7585: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7585   rm -rf conftest*
7586   glibcpp_cv_func_sinhf_use=yes
7587 else
7588   echo "configure: failed program was:" >&5
7589   cat conftest.$ac_ext >&5
7590   rm -rf conftest*
7591   glibcpp_cv_func_sinhf_use=no
7592 fi
7593 rm -f conftest*
7594     ac_ext=c
7595 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7596 ac_cpp='$CPP $CPPFLAGS'
7597 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7598 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7599 cross_compiling=$ac_cv_prog_cc_cross
7600
7601
7602 fi
7603
7604   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
7605   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
7606     for ac_func in sinhf
7607 do
7608 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7609 echo "configure:7610: checking for $ac_func" >&5
7610 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7611   echo $ac_n "(cached) $ac_c" 1>&6
7612 else
7613   cat > conftest.$ac_ext <<EOF
7614 #line 7615 "configure"
7615 #include "confdefs.h"
7616 /* System header to define __stub macros and hopefully few prototypes,
7617     which can conflict with char $ac_func(); below.  */
7618 #include <assert.h>
7619 /* Override any gcc2 internal prototype to avoid an error.  */
7620 /* We use char because int might match the return type of a gcc2
7621     builtin and then its argument prototype would still apply.  */
7622 char $ac_func();
7623
7624 int main() {
7625
7626 /* The GNU C library defines this for functions which it implements
7627     to always fail with ENOSYS.  Some functions are actually named
7628     something starting with __ and the normal name is an alias.  */
7629 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7630 choke me
7631 #else
7632 $ac_func();
7633 #endif
7634
7635 ; return 0; }
7636 EOF
7637 if { (eval echo configure:7638: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7638   rm -rf conftest*
7639   eval "ac_cv_func_$ac_func=yes"
7640 else
7641   echo "configure: failed program was:" >&5
7642   cat conftest.$ac_ext >&5
7643   rm -rf conftest*
7644   eval "ac_cv_func_$ac_func=no"
7645 fi
7646 rm -f conftest*
7647 fi
7648
7649 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7650   echo "$ac_t""yes" 1>&6
7651     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7652   cat >> confdefs.h <<EOF
7653 #define $ac_tr_func 1
7654 EOF
7655
7656 else
7657   echo "$ac_t""no" 1>&6
7658 fi
7659 done
7660
7661   fi
7662
7663
7664   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
7665 echo "configure:7666: checking for sqrtf declaration" >&5
7666   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
7667   echo $ac_n "(cached) $ac_c" 1>&6
7668 else
7669
7670
7671     ac_ext=C
7672 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7673 ac_cpp='$CXXCPP $CPPFLAGS'
7674 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7675 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7676 cross_compiling=$ac_cv_prog_cxx_cross
7677
7678     cat > conftest.$ac_ext <<EOF
7679 #line 7680 "configure"
7680 #include "confdefs.h"
7681 #include <math.h>
7682 int main() {
7683  sqrtf(0);
7684 ; return 0; }
7685 EOF
7686 if { (eval echo configure:7687: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7687   rm -rf conftest*
7688   glibcpp_cv_func_sqrtf_use=yes
7689 else
7690   echo "configure: failed program was:" >&5
7691   cat conftest.$ac_ext >&5
7692   rm -rf conftest*
7693   glibcpp_cv_func_sqrtf_use=no
7694 fi
7695 rm -f conftest*
7696     ac_ext=c
7697 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7698 ac_cpp='$CPP $CPPFLAGS'
7699 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7700 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7701 cross_compiling=$ac_cv_prog_cc_cross
7702
7703
7704 fi
7705
7706   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
7707   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
7708     for ac_func in sqrtf
7709 do
7710 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7711 echo "configure:7712: checking for $ac_func" >&5
7712 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7713   echo $ac_n "(cached) $ac_c" 1>&6
7714 else
7715   cat > conftest.$ac_ext <<EOF
7716 #line 7717 "configure"
7717 #include "confdefs.h"
7718 /* System header to define __stub macros and hopefully few prototypes,
7719     which can conflict with char $ac_func(); below.  */
7720 #include <assert.h>
7721 /* Override any gcc2 internal prototype to avoid an error.  */
7722 /* We use char because int might match the return type of a gcc2
7723     builtin and then its argument prototype would still apply.  */
7724 char $ac_func();
7725
7726 int main() {
7727
7728 /* The GNU C library defines this for functions which it implements
7729     to always fail with ENOSYS.  Some functions are actually named
7730     something starting with __ and the normal name is an alias.  */
7731 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7732 choke me
7733 #else
7734 $ac_func();
7735 #endif
7736
7737 ; return 0; }
7738 EOF
7739 if { (eval echo configure:7740: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7740   rm -rf conftest*
7741   eval "ac_cv_func_$ac_func=yes"
7742 else
7743   echo "configure: failed program was:" >&5
7744   cat conftest.$ac_ext >&5
7745   rm -rf conftest*
7746   eval "ac_cv_func_$ac_func=no"
7747 fi
7748 rm -f conftest*
7749 fi
7750
7751 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7752   echo "$ac_t""yes" 1>&6
7753     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7754   cat >> confdefs.h <<EOF
7755 #define $ac_tr_func 1
7756 EOF
7757
7758 else
7759   echo "$ac_t""no" 1>&6
7760 fi
7761 done
7762
7763   fi
7764
7765
7766   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
7767 echo "configure:7768: checking for tanf declaration" >&5
7768   if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
7769   echo $ac_n "(cached) $ac_c" 1>&6
7770 else
7771
7772
7773     ac_ext=C
7774 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7775 ac_cpp='$CXXCPP $CPPFLAGS'
7776 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7777 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7778 cross_compiling=$ac_cv_prog_cxx_cross
7779
7780     cat > conftest.$ac_ext <<EOF
7781 #line 7782 "configure"
7782 #include "confdefs.h"
7783 #include <math.h>
7784 int main() {
7785  tanf(0);
7786 ; return 0; }
7787 EOF
7788 if { (eval echo configure:7789: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7789   rm -rf conftest*
7790   glibcpp_cv_func_tanf_use=yes
7791 else
7792   echo "configure: failed program was:" >&5
7793   cat conftest.$ac_ext >&5
7794   rm -rf conftest*
7795   glibcpp_cv_func_tanf_use=no
7796 fi
7797 rm -f conftest*
7798     ac_ext=c
7799 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7800 ac_cpp='$CPP $CPPFLAGS'
7801 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7802 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7803 cross_compiling=$ac_cv_prog_cc_cross
7804
7805
7806 fi
7807
7808   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
7809   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
7810     for ac_func in tanf
7811 do
7812 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7813 echo "configure:7814: checking for $ac_func" >&5
7814 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7815   echo $ac_n "(cached) $ac_c" 1>&6
7816 else
7817   cat > conftest.$ac_ext <<EOF
7818 #line 7819 "configure"
7819 #include "confdefs.h"
7820 /* System header to define __stub macros and hopefully few prototypes,
7821     which can conflict with char $ac_func(); below.  */
7822 #include <assert.h>
7823 /* Override any gcc2 internal prototype to avoid an error.  */
7824 /* We use char because int might match the return type of a gcc2
7825     builtin and then its argument prototype would still apply.  */
7826 char $ac_func();
7827
7828 int main() {
7829
7830 /* The GNU C library defines this for functions which it implements
7831     to always fail with ENOSYS.  Some functions are actually named
7832     something starting with __ and the normal name is an alias.  */
7833 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7834 choke me
7835 #else
7836 $ac_func();
7837 #endif
7838
7839 ; return 0; }
7840 EOF
7841 if { (eval echo configure:7842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7842   rm -rf conftest*
7843   eval "ac_cv_func_$ac_func=yes"
7844 else
7845   echo "configure: failed program was:" >&5
7846   cat conftest.$ac_ext >&5
7847   rm -rf conftest*
7848   eval "ac_cv_func_$ac_func=no"
7849 fi
7850 rm -f conftest*
7851 fi
7852
7853 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7854   echo "$ac_t""yes" 1>&6
7855     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7856   cat >> confdefs.h <<EOF
7857 #define $ac_tr_func 1
7858 EOF
7859
7860 else
7861   echo "$ac_t""no" 1>&6
7862 fi
7863 done
7864
7865   fi
7866
7867
7868   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
7869 echo "configure:7870: checking for tanhf declaration" >&5
7870   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
7871   echo $ac_n "(cached) $ac_c" 1>&6
7872 else
7873
7874
7875     ac_ext=C
7876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7877 ac_cpp='$CXXCPP $CPPFLAGS'
7878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7880 cross_compiling=$ac_cv_prog_cxx_cross
7881
7882     cat > conftest.$ac_ext <<EOF
7883 #line 7884 "configure"
7884 #include "confdefs.h"
7885 #include <math.h>
7886 int main() {
7887  tanhf(0);
7888 ; return 0; }
7889 EOF
7890 if { (eval echo configure:7891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7891   rm -rf conftest*
7892   glibcpp_cv_func_tanhf_use=yes
7893 else
7894   echo "configure: failed program was:" >&5
7895   cat conftest.$ac_ext >&5
7896   rm -rf conftest*
7897   glibcpp_cv_func_tanhf_use=no
7898 fi
7899 rm -f conftest*
7900     ac_ext=c
7901 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7902 ac_cpp='$CPP $CPPFLAGS'
7903 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7904 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7905 cross_compiling=$ac_cv_prog_cc_cross
7906
7907
7908 fi
7909
7910   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
7911   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
7912     for ac_func in tanhf
7913 do
7914 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7915 echo "configure:7916: checking for $ac_func" >&5
7916 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7917   echo $ac_n "(cached) $ac_c" 1>&6
7918 else
7919   cat > conftest.$ac_ext <<EOF
7920 #line 7921 "configure"
7921 #include "confdefs.h"
7922 /* System header to define __stub macros and hopefully few prototypes,
7923     which can conflict with char $ac_func(); below.  */
7924 #include <assert.h>
7925 /* Override any gcc2 internal prototype to avoid an error.  */
7926 /* We use char because int might match the return type of a gcc2
7927     builtin and then its argument prototype would still apply.  */
7928 char $ac_func();
7929
7930 int main() {
7931
7932 /* The GNU C library defines this for functions which it implements
7933     to always fail with ENOSYS.  Some functions are actually named
7934     something starting with __ and the normal name is an alias.  */
7935 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7936 choke me
7937 #else
7938 $ac_func();
7939 #endif
7940
7941 ; return 0; }
7942 EOF
7943 if { (eval echo configure:7944: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7944   rm -rf conftest*
7945   eval "ac_cv_func_$ac_func=yes"
7946 else
7947   echo "configure: failed program was:" >&5
7948   cat conftest.$ac_ext >&5
7949   rm -rf conftest*
7950   eval "ac_cv_func_$ac_func=no"
7951 fi
7952 rm -f conftest*
7953 fi
7954
7955 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7956   echo "$ac_t""yes" 1>&6
7957     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7958   cat >> confdefs.h <<EOF
7959 #define $ac_tr_func 1
7960 EOF
7961
7962 else
7963   echo "$ac_t""no" 1>&6
7964 fi
7965 done
7966
7967   fi
7968
7969
7970   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7971 echo "configure:7972: checking for sincosf declaration" >&5
7972   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
7973   echo $ac_n "(cached) $ac_c" 1>&6
7974 else
7975
7976
7977     ac_ext=C
7978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7979 ac_cpp='$CXXCPP $CPPFLAGS'
7980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7982 cross_compiling=$ac_cv_prog_cxx_cross
7983
7984     cat > conftest.$ac_ext <<EOF
7985 #line 7986 "configure"
7986 #include "confdefs.h"
7987 #include <math.h>
7988 int main() {
7989  sincosf(0, 0, 0);
7990 ; return 0; }
7991 EOF
7992 if { (eval echo configure:7993: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7993   rm -rf conftest*
7994   glibcpp_cv_func_sincosf_use=yes
7995 else
7996   echo "configure: failed program was:" >&5
7997   cat conftest.$ac_ext >&5
7998   rm -rf conftest*
7999   glibcpp_cv_func_sincosf_use=no
8000 fi
8001 rm -f conftest*
8002     ac_ext=c
8003 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8004 ac_cpp='$CPP $CPPFLAGS'
8005 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8006 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8007 cross_compiling=$ac_cv_prog_cc_cross
8008
8009
8010 fi
8011
8012   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
8013   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
8014     for ac_func in sincosf
8015 do
8016 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8017 echo "configure:8018: checking for $ac_func" >&5
8018 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8019   echo $ac_n "(cached) $ac_c" 1>&6
8020 else
8021   cat > conftest.$ac_ext <<EOF
8022 #line 8023 "configure"
8023 #include "confdefs.h"
8024 /* System header to define __stub macros and hopefully few prototypes,
8025     which can conflict with char $ac_func(); below.  */
8026 #include <assert.h>
8027 /* Override any gcc2 internal prototype to avoid an error.  */
8028 /* We use char because int might match the return type of a gcc2
8029     builtin and then its argument prototype would still apply.  */
8030 char $ac_func();
8031
8032 int main() {
8033
8034 /* The GNU C library defines this for functions which it implements
8035     to always fail with ENOSYS.  Some functions are actually named
8036     something starting with __ and the normal name is an alias.  */
8037 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8038 choke me
8039 #else
8040 $ac_func();
8041 #endif
8042
8043 ; return 0; }
8044 EOF
8045 if { (eval echo configure:8046: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8046   rm -rf conftest*
8047   eval "ac_cv_func_$ac_func=yes"
8048 else
8049   echo "configure: failed program was:" >&5
8050   cat conftest.$ac_ext >&5
8051   rm -rf conftest*
8052   eval "ac_cv_func_$ac_func=no"
8053 fi
8054 rm -f conftest*
8055 fi
8056
8057 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8058   echo "$ac_t""yes" 1>&6
8059     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8060   cat >> confdefs.h <<EOF
8061 #define $ac_tr_func 1
8062 EOF
8063
8064 else
8065   echo "$ac_t""no" 1>&6
8066 fi
8067 done
8068
8069   fi
8070
8071
8072   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
8073 echo "configure:8074: checking for finitef declaration" >&5
8074   if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
8075   echo $ac_n "(cached) $ac_c" 1>&6
8076 else
8077
8078
8079     ac_ext=C
8080 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8081 ac_cpp='$CXXCPP $CPPFLAGS'
8082 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8083 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8084 cross_compiling=$ac_cv_prog_cxx_cross
8085
8086     cat > conftest.$ac_ext <<EOF
8087 #line 8088 "configure"
8088 #include "confdefs.h"
8089 #include <math.h>
8090 int main() {
8091  finitef(0);
8092 ; return 0; }
8093 EOF
8094 if { (eval echo configure:8095: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8095   rm -rf conftest*
8096   glibcpp_cv_func_finitef_use=yes
8097 else
8098   echo "configure: failed program was:" >&5
8099   cat conftest.$ac_ext >&5
8100   rm -rf conftest*
8101   glibcpp_cv_func_finitef_use=no
8102 fi
8103 rm -f conftest*
8104     ac_ext=c
8105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8106 ac_cpp='$CPP $CPPFLAGS'
8107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8109 cross_compiling=$ac_cv_prog_cc_cross
8110
8111
8112 fi
8113
8114   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
8115   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
8116     for ac_func in finitef
8117 do
8118 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8119 echo "configure:8120: checking for $ac_func" >&5
8120 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8121   echo $ac_n "(cached) $ac_c" 1>&6
8122 else
8123   cat > conftest.$ac_ext <<EOF
8124 #line 8125 "configure"
8125 #include "confdefs.h"
8126 /* System header to define __stub macros and hopefully few prototypes,
8127     which can conflict with char $ac_func(); below.  */
8128 #include <assert.h>
8129 /* Override any gcc2 internal prototype to avoid an error.  */
8130 /* We use char because int might match the return type of a gcc2
8131     builtin and then its argument prototype would still apply.  */
8132 char $ac_func();
8133
8134 int main() {
8135
8136 /* The GNU C library defines this for functions which it implements
8137     to always fail with ENOSYS.  Some functions are actually named
8138     something starting with __ and the normal name is an alias.  */
8139 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8140 choke me
8141 #else
8142 $ac_func();
8143 #endif
8144
8145 ; return 0; }
8146 EOF
8147 if { (eval echo configure:8148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8148   rm -rf conftest*
8149   eval "ac_cv_func_$ac_func=yes"
8150 else
8151   echo "configure: failed program was:" >&5
8152   cat conftest.$ac_ext >&5
8153   rm -rf conftest*
8154   eval "ac_cv_func_$ac_func=no"
8155 fi
8156 rm -f conftest*
8157 fi
8158
8159 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8160   echo "$ac_t""yes" 1>&6
8161     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8162   cat >> confdefs.h <<EOF
8163 #define $ac_tr_func 1
8164 EOF
8165
8166 else
8167   echo "$ac_t""no" 1>&6
8168 fi
8169 done
8170
8171   fi
8172
8173
8174
8175   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8176 echo "configure:8177: checking for isnanl declaration" >&5
8177   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
8178   echo $ac_n "(cached) $ac_c" 1>&6
8179 else
8180
8181
8182     ac_ext=C
8183 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8184 ac_cpp='$CXXCPP $CPPFLAGS'
8185 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8186 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8187 cross_compiling=$ac_cv_prog_cxx_cross
8188
8189     cat > conftest.$ac_ext <<EOF
8190 #line 8191 "configure"
8191 #include "confdefs.h"
8192 #include <math.h>
8193 int main() {
8194  isnanl(0);
8195 ; return 0; }
8196 EOF
8197 if { (eval echo configure:8198: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8198   rm -rf conftest*
8199   glibcpp_cv_func_isnanl_use=yes
8200 else
8201   echo "configure: failed program was:" >&5
8202   cat conftest.$ac_ext >&5
8203   rm -rf conftest*
8204   glibcpp_cv_func_isnanl_use=no
8205 fi
8206 rm -f conftest*
8207     ac_ext=c
8208 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8209 ac_cpp='$CPP $CPPFLAGS'
8210 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8211 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8212 cross_compiling=$ac_cv_prog_cc_cross
8213
8214
8215 fi
8216
8217   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
8218   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
8219     for ac_func in isnanl
8220 do
8221 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8222 echo "configure:8223: checking for $ac_func" >&5
8223 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8224   echo $ac_n "(cached) $ac_c" 1>&6
8225 else
8226   cat > conftest.$ac_ext <<EOF
8227 #line 8228 "configure"
8228 #include "confdefs.h"
8229 /* System header to define __stub macros and hopefully few prototypes,
8230     which can conflict with char $ac_func(); below.  */
8231 #include <assert.h>
8232 /* Override any gcc2 internal prototype to avoid an error.  */
8233 /* We use char because int might match the return type of a gcc2
8234     builtin and then its argument prototype would still apply.  */
8235 char $ac_func();
8236
8237 int main() {
8238
8239 /* The GNU C library defines this for functions which it implements
8240     to always fail with ENOSYS.  Some functions are actually named
8241     something starting with __ and the normal name is an alias.  */
8242 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8243 choke me
8244 #else
8245 $ac_func();
8246 #endif
8247
8248 ; return 0; }
8249 EOF
8250 if { (eval echo configure:8251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8251   rm -rf conftest*
8252   eval "ac_cv_func_$ac_func=yes"
8253 else
8254   echo "configure: failed program was:" >&5
8255   cat conftest.$ac_ext >&5
8256   rm -rf conftest*
8257   eval "ac_cv_func_$ac_func=no"
8258 fi
8259 rm -f conftest*
8260 fi
8261
8262 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8263   echo "$ac_t""yes" 1>&6
8264     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8265   cat >> confdefs.h <<EOF
8266 #define $ac_tr_func 1
8267 EOF
8268
8269 else
8270   echo "$ac_t""no" 1>&6
8271 fi
8272 done
8273
8274   fi
8275
8276
8277   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8278 echo "configure:8279: checking for isinfl declaration" >&5
8279   if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
8280   echo $ac_n "(cached) $ac_c" 1>&6
8281 else
8282
8283
8284     ac_ext=C
8285 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8286 ac_cpp='$CXXCPP $CPPFLAGS'
8287 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8288 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8289 cross_compiling=$ac_cv_prog_cxx_cross
8290
8291     cat > conftest.$ac_ext <<EOF
8292 #line 8293 "configure"
8293 #include "confdefs.h"
8294 #include <math.h>
8295 int main() {
8296  isinfl(0);
8297 ; return 0; }
8298 EOF
8299 if { (eval echo configure:8300: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8300   rm -rf conftest*
8301   glibcpp_cv_func_isinfl_use=yes
8302 else
8303   echo "configure: failed program was:" >&5
8304   cat conftest.$ac_ext >&5
8305   rm -rf conftest*
8306   glibcpp_cv_func_isinfl_use=no
8307 fi
8308 rm -f conftest*
8309     ac_ext=c
8310 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8311 ac_cpp='$CPP $CPPFLAGS'
8312 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8313 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8314 cross_compiling=$ac_cv_prog_cc_cross
8315
8316
8317 fi
8318
8319   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
8320   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
8321     for ac_func in isinfl
8322 do
8323 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8324 echo "configure:8325: checking for $ac_func" >&5
8325 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8326   echo $ac_n "(cached) $ac_c" 1>&6
8327 else
8328   cat > conftest.$ac_ext <<EOF
8329 #line 8330 "configure"
8330 #include "confdefs.h"
8331 /* System header to define __stub macros and hopefully few prototypes,
8332     which can conflict with char $ac_func(); below.  */
8333 #include <assert.h>
8334 /* Override any gcc2 internal prototype to avoid an error.  */
8335 /* We use char because int might match the return type of a gcc2
8336     builtin and then its argument prototype would still apply.  */
8337 char $ac_func();
8338
8339 int main() {
8340
8341 /* The GNU C library defines this for functions which it implements
8342     to always fail with ENOSYS.  Some functions are actually named
8343     something starting with __ and the normal name is an alias.  */
8344 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8345 choke me
8346 #else
8347 $ac_func();
8348 #endif
8349
8350 ; return 0; }
8351 EOF
8352 if { (eval echo configure:8353: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8353   rm -rf conftest*
8354   eval "ac_cv_func_$ac_func=yes"
8355 else
8356   echo "configure: failed program was:" >&5
8357   cat conftest.$ac_ext >&5
8358   rm -rf conftest*
8359   eval "ac_cv_func_$ac_func=no"
8360 fi
8361 rm -f conftest*
8362 fi
8363
8364 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8365   echo "$ac_t""yes" 1>&6
8366     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8367   cat >> confdefs.h <<EOF
8368 #define $ac_tr_func 1
8369 EOF
8370
8371 else
8372   echo "$ac_t""no" 1>&6
8373 fi
8374 done
8375
8376   fi
8377
8378
8379   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8380 echo "configure:8381: checking for copysignl declaration" >&5
8381   if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
8382   echo $ac_n "(cached) $ac_c" 1>&6
8383 else
8384
8385
8386     ac_ext=C
8387 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8388 ac_cpp='$CXXCPP $CPPFLAGS'
8389 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8390 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8391 cross_compiling=$ac_cv_prog_cxx_cross
8392
8393     cat > conftest.$ac_ext <<EOF
8394 #line 8395 "configure"
8395 #include "confdefs.h"
8396 #include <math.h>
8397 int main() {
8398  copysignl(0, 0);
8399 ; return 0; }
8400 EOF
8401 if { (eval echo configure:8402: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8402   rm -rf conftest*
8403   glibcpp_cv_func_copysignl_use=yes
8404 else
8405   echo "configure: failed program was:" >&5
8406   cat conftest.$ac_ext >&5
8407   rm -rf conftest*
8408   glibcpp_cv_func_copysignl_use=no
8409 fi
8410 rm -f conftest*
8411     ac_ext=c
8412 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8413 ac_cpp='$CPP $CPPFLAGS'
8414 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8415 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8416 cross_compiling=$ac_cv_prog_cc_cross
8417
8418
8419 fi
8420
8421   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
8422   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
8423     for ac_func in copysignl
8424 do
8425 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8426 echo "configure:8427: checking for $ac_func" >&5
8427 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8428   echo $ac_n "(cached) $ac_c" 1>&6
8429 else
8430   cat > conftest.$ac_ext <<EOF
8431 #line 8432 "configure"
8432 #include "confdefs.h"
8433 /* System header to define __stub macros and hopefully few prototypes,
8434     which can conflict with char $ac_func(); below.  */
8435 #include <assert.h>
8436 /* Override any gcc2 internal prototype to avoid an error.  */
8437 /* We use char because int might match the return type of a gcc2
8438     builtin and then its argument prototype would still apply.  */
8439 char $ac_func();
8440
8441 int main() {
8442
8443 /* The GNU C library defines this for functions which it implements
8444     to always fail with ENOSYS.  Some functions are actually named
8445     something starting with __ and the normal name is an alias.  */
8446 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8447 choke me
8448 #else
8449 $ac_func();
8450 #endif
8451
8452 ; return 0; }
8453 EOF
8454 if { (eval echo configure:8455: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8455   rm -rf conftest*
8456   eval "ac_cv_func_$ac_func=yes"
8457 else
8458   echo "configure: failed program was:" >&5
8459   cat conftest.$ac_ext >&5
8460   rm -rf conftest*
8461   eval "ac_cv_func_$ac_func=no"
8462 fi
8463 rm -f conftest*
8464 fi
8465
8466 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8467   echo "$ac_t""yes" 1>&6
8468     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8469   cat >> confdefs.h <<EOF
8470 #define $ac_tr_func 1
8471 EOF
8472
8473 else
8474   echo "$ac_t""no" 1>&6
8475 fi
8476 done
8477
8478   fi
8479
8480
8481   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8482 echo "configure:8483: checking for acosl declaration" >&5
8483   if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
8484   echo $ac_n "(cached) $ac_c" 1>&6
8485 else
8486
8487
8488     ac_ext=C
8489 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8490 ac_cpp='$CXXCPP $CPPFLAGS'
8491 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8492 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8493 cross_compiling=$ac_cv_prog_cxx_cross
8494
8495     cat > conftest.$ac_ext <<EOF
8496 #line 8497 "configure"
8497 #include "confdefs.h"
8498 #include <math.h>
8499 int main() {
8500  acosl(0);
8501 ; return 0; }
8502 EOF
8503 if { (eval echo configure:8504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8504   rm -rf conftest*
8505   glibcpp_cv_func_acosl_use=yes
8506 else
8507   echo "configure: failed program was:" >&5
8508   cat conftest.$ac_ext >&5
8509   rm -rf conftest*
8510   glibcpp_cv_func_acosl_use=no
8511 fi
8512 rm -f conftest*
8513     ac_ext=c
8514 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8515 ac_cpp='$CPP $CPPFLAGS'
8516 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8517 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8518 cross_compiling=$ac_cv_prog_cc_cross
8519
8520
8521 fi
8522
8523   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
8524   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
8525     for ac_func in acosl
8526 do
8527 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8528 echo "configure:8529: checking for $ac_func" >&5
8529 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8530   echo $ac_n "(cached) $ac_c" 1>&6
8531 else
8532   cat > conftest.$ac_ext <<EOF
8533 #line 8534 "configure"
8534 #include "confdefs.h"
8535 /* System header to define __stub macros and hopefully few prototypes,
8536     which can conflict with char $ac_func(); below.  */
8537 #include <assert.h>
8538 /* Override any gcc2 internal prototype to avoid an error.  */
8539 /* We use char because int might match the return type of a gcc2
8540     builtin and then its argument prototype would still apply.  */
8541 char $ac_func();
8542
8543 int main() {
8544
8545 /* The GNU C library defines this for functions which it implements
8546     to always fail with ENOSYS.  Some functions are actually named
8547     something starting with __ and the normal name is an alias.  */
8548 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8549 choke me
8550 #else
8551 $ac_func();
8552 #endif
8553
8554 ; return 0; }
8555 EOF
8556 if { (eval echo configure:8557: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8557   rm -rf conftest*
8558   eval "ac_cv_func_$ac_func=yes"
8559 else
8560   echo "configure: failed program was:" >&5
8561   cat conftest.$ac_ext >&5
8562   rm -rf conftest*
8563   eval "ac_cv_func_$ac_func=no"
8564 fi
8565 rm -f conftest*
8566 fi
8567
8568 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8569   echo "$ac_t""yes" 1>&6
8570     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8571   cat >> confdefs.h <<EOF
8572 #define $ac_tr_func 1
8573 EOF
8574
8575 else
8576   echo "$ac_t""no" 1>&6
8577 fi
8578 done
8579
8580   fi
8581
8582
8583   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8584 echo "configure:8585: checking for asinl declaration" >&5
8585   if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
8586   echo $ac_n "(cached) $ac_c" 1>&6
8587 else
8588
8589
8590     ac_ext=C
8591 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8592 ac_cpp='$CXXCPP $CPPFLAGS'
8593 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8594 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8595 cross_compiling=$ac_cv_prog_cxx_cross
8596
8597     cat > conftest.$ac_ext <<EOF
8598 #line 8599 "configure"
8599 #include "confdefs.h"
8600 #include <math.h>
8601 int main() {
8602  asinl(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   glibcpp_cv_func_asinl_use=yes
8608 else
8609   echo "configure: failed program was:" >&5
8610   cat conftest.$ac_ext >&5
8611   rm -rf conftest*
8612   glibcpp_cv_func_asinl_use=no
8613 fi
8614 rm -f conftest*
8615     ac_ext=c
8616 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8617 ac_cpp='$CPP $CPPFLAGS'
8618 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8619 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8620 cross_compiling=$ac_cv_prog_cc_cross
8621
8622
8623 fi
8624
8625   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
8626   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
8627     for ac_func in asinl
8628 do
8629 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8630 echo "configure:8631: checking for $ac_func" >&5
8631 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8632   echo $ac_n "(cached) $ac_c" 1>&6
8633 else
8634   cat > conftest.$ac_ext <<EOF
8635 #line 8636 "configure"
8636 #include "confdefs.h"
8637 /* System header to define __stub macros and hopefully few prototypes,
8638     which can conflict with char $ac_func(); below.  */
8639 #include <assert.h>
8640 /* Override any gcc2 internal prototype to avoid an error.  */
8641 /* We use char because int might match the return type of a gcc2
8642     builtin and then its argument prototype would still apply.  */
8643 char $ac_func();
8644
8645 int main() {
8646
8647 /* The GNU C library defines this for functions which it implements
8648     to always fail with ENOSYS.  Some functions are actually named
8649     something starting with __ and the normal name is an alias.  */
8650 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8651 choke me
8652 #else
8653 $ac_func();
8654 #endif
8655
8656 ; return 0; }
8657 EOF
8658 if { (eval echo configure:8659: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8659   rm -rf conftest*
8660   eval "ac_cv_func_$ac_func=yes"
8661 else
8662   echo "configure: failed program was:" >&5
8663   cat conftest.$ac_ext >&5
8664   rm -rf conftest*
8665   eval "ac_cv_func_$ac_func=no"
8666 fi
8667 rm -f conftest*
8668 fi
8669
8670 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8671   echo "$ac_t""yes" 1>&6
8672     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8673   cat >> confdefs.h <<EOF
8674 #define $ac_tr_func 1
8675 EOF
8676
8677 else
8678   echo "$ac_t""no" 1>&6
8679 fi
8680 done
8681
8682   fi
8683
8684
8685   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8686 echo "configure:8687: checking for atanl declaration" >&5
8687   if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
8688   echo $ac_n "(cached) $ac_c" 1>&6
8689 else
8690
8691
8692     ac_ext=C
8693 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8694 ac_cpp='$CXXCPP $CPPFLAGS'
8695 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8696 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8697 cross_compiling=$ac_cv_prog_cxx_cross
8698
8699     cat > conftest.$ac_ext <<EOF
8700 #line 8701 "configure"
8701 #include "confdefs.h"
8702 #include <math.h>
8703 int main() {
8704  atanl(0);
8705 ; return 0; }
8706 EOF
8707 if { (eval echo configure:8708: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8708   rm -rf conftest*
8709   glibcpp_cv_func_atanl_use=yes
8710 else
8711   echo "configure: failed program was:" >&5
8712   cat conftest.$ac_ext >&5
8713   rm -rf conftest*
8714   glibcpp_cv_func_atanl_use=no
8715 fi
8716 rm -f conftest*
8717     ac_ext=c
8718 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8719 ac_cpp='$CPP $CPPFLAGS'
8720 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8721 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8722 cross_compiling=$ac_cv_prog_cc_cross
8723
8724
8725 fi
8726
8727   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
8728   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
8729     for ac_func in atanl
8730 do
8731 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8732 echo "configure:8733: checking for $ac_func" >&5
8733 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8734   echo $ac_n "(cached) $ac_c" 1>&6
8735 else
8736   cat > conftest.$ac_ext <<EOF
8737 #line 8738 "configure"
8738 #include "confdefs.h"
8739 /* System header to define __stub macros and hopefully few prototypes,
8740     which can conflict with char $ac_func(); below.  */
8741 #include <assert.h>
8742 /* Override any gcc2 internal prototype to avoid an error.  */
8743 /* We use char because int might match the return type of a gcc2
8744     builtin and then its argument prototype would still apply.  */
8745 char $ac_func();
8746
8747 int main() {
8748
8749 /* The GNU C library defines this for functions which it implements
8750     to always fail with ENOSYS.  Some functions are actually named
8751     something starting with __ and the normal name is an alias.  */
8752 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8753 choke me
8754 #else
8755 $ac_func();
8756 #endif
8757
8758 ; return 0; }
8759 EOF
8760 if { (eval echo configure:8761: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8761   rm -rf conftest*
8762   eval "ac_cv_func_$ac_func=yes"
8763 else
8764   echo "configure: failed program was:" >&5
8765   cat conftest.$ac_ext >&5
8766   rm -rf conftest*
8767   eval "ac_cv_func_$ac_func=no"
8768 fi
8769 rm -f conftest*
8770 fi
8771
8772 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8773   echo "$ac_t""yes" 1>&6
8774     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8775   cat >> confdefs.h <<EOF
8776 #define $ac_tr_func 1
8777 EOF
8778
8779 else
8780   echo "$ac_t""no" 1>&6
8781 fi
8782 done
8783
8784   fi
8785
8786
8787   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8788 echo "configure:8789: checking for atan2l declaration" >&5
8789   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
8790   echo $ac_n "(cached) $ac_c" 1>&6
8791 else
8792
8793
8794     ac_ext=C
8795 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8796 ac_cpp='$CXXCPP $CPPFLAGS'
8797 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8798 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8799 cross_compiling=$ac_cv_prog_cxx_cross
8800
8801     cat > conftest.$ac_ext <<EOF
8802 #line 8803 "configure"
8803 #include "confdefs.h"
8804 #include <math.h>
8805 int main() {
8806  atan2l(0, 0);
8807 ; return 0; }
8808 EOF
8809 if { (eval echo configure:8810: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8810   rm -rf conftest*
8811   glibcpp_cv_func_atan2l_use=yes
8812 else
8813   echo "configure: failed program was:" >&5
8814   cat conftest.$ac_ext >&5
8815   rm -rf conftest*
8816   glibcpp_cv_func_atan2l_use=no
8817 fi
8818 rm -f conftest*
8819     ac_ext=c
8820 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8821 ac_cpp='$CPP $CPPFLAGS'
8822 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8823 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8824 cross_compiling=$ac_cv_prog_cc_cross
8825
8826
8827 fi
8828
8829   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
8830   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
8831     for ac_func in atan2l
8832 do
8833 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8834 echo "configure:8835: checking for $ac_func" >&5
8835 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8836   echo $ac_n "(cached) $ac_c" 1>&6
8837 else
8838   cat > conftest.$ac_ext <<EOF
8839 #line 8840 "configure"
8840 #include "confdefs.h"
8841 /* System header to define __stub macros and hopefully few prototypes,
8842     which can conflict with char $ac_func(); below.  */
8843 #include <assert.h>
8844 /* Override any gcc2 internal prototype to avoid an error.  */
8845 /* We use char because int might match the return type of a gcc2
8846     builtin and then its argument prototype would still apply.  */
8847 char $ac_func();
8848
8849 int main() {
8850
8851 /* The GNU C library defines this for functions which it implements
8852     to always fail with ENOSYS.  Some functions are actually named
8853     something starting with __ and the normal name is an alias.  */
8854 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8855 choke me
8856 #else
8857 $ac_func();
8858 #endif
8859
8860 ; return 0; }
8861 EOF
8862 if { (eval echo configure:8863: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8863   rm -rf conftest*
8864   eval "ac_cv_func_$ac_func=yes"
8865 else
8866   echo "configure: failed program was:" >&5
8867   cat conftest.$ac_ext >&5
8868   rm -rf conftest*
8869   eval "ac_cv_func_$ac_func=no"
8870 fi
8871 rm -f conftest*
8872 fi
8873
8874 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8875   echo "$ac_t""yes" 1>&6
8876     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8877   cat >> confdefs.h <<EOF
8878 #define $ac_tr_func 1
8879 EOF
8880
8881 else
8882   echo "$ac_t""no" 1>&6
8883 fi
8884 done
8885
8886   fi
8887
8888
8889   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8890 echo "configure:8891: checking for ceill declaration" >&5
8891   if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
8892   echo $ac_n "(cached) $ac_c" 1>&6
8893 else
8894
8895
8896     ac_ext=C
8897 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8898 ac_cpp='$CXXCPP $CPPFLAGS'
8899 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8900 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8901 cross_compiling=$ac_cv_prog_cxx_cross
8902
8903     cat > conftest.$ac_ext <<EOF
8904 #line 8905 "configure"
8905 #include "confdefs.h"
8906 #include <math.h>
8907 int main() {
8908  ceill(0);
8909 ; return 0; }
8910 EOF
8911 if { (eval echo configure:8912: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8912   rm -rf conftest*
8913   glibcpp_cv_func_ceill_use=yes
8914 else
8915   echo "configure: failed program was:" >&5
8916   cat conftest.$ac_ext >&5
8917   rm -rf conftest*
8918   glibcpp_cv_func_ceill_use=no
8919 fi
8920 rm -f conftest*
8921     ac_ext=c
8922 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8923 ac_cpp='$CPP $CPPFLAGS'
8924 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8925 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8926 cross_compiling=$ac_cv_prog_cc_cross
8927
8928
8929 fi
8930
8931   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
8932   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
8933     for ac_func in ceill
8934 do
8935 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8936 echo "configure:8937: checking for $ac_func" >&5
8937 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8938   echo $ac_n "(cached) $ac_c" 1>&6
8939 else
8940   cat > conftest.$ac_ext <<EOF
8941 #line 8942 "configure"
8942 #include "confdefs.h"
8943 /* System header to define __stub macros and hopefully few prototypes,
8944     which can conflict with char $ac_func(); below.  */
8945 #include <assert.h>
8946 /* Override any gcc2 internal prototype to avoid an error.  */
8947 /* We use char because int might match the return type of a gcc2
8948     builtin and then its argument prototype would still apply.  */
8949 char $ac_func();
8950
8951 int main() {
8952
8953 /* The GNU C library defines this for functions which it implements
8954     to always fail with ENOSYS.  Some functions are actually named
8955     something starting with __ and the normal name is an alias.  */
8956 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8957 choke me
8958 #else
8959 $ac_func();
8960 #endif
8961
8962 ; return 0; }
8963 EOF
8964 if { (eval echo configure:8965: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8965   rm -rf conftest*
8966   eval "ac_cv_func_$ac_func=yes"
8967 else
8968   echo "configure: failed program was:" >&5
8969   cat conftest.$ac_ext >&5
8970   rm -rf conftest*
8971   eval "ac_cv_func_$ac_func=no"
8972 fi
8973 rm -f conftest*
8974 fi
8975
8976 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8977   echo "$ac_t""yes" 1>&6
8978     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8979   cat >> confdefs.h <<EOF
8980 #define $ac_tr_func 1
8981 EOF
8982
8983 else
8984   echo "$ac_t""no" 1>&6
8985 fi
8986 done
8987
8988   fi
8989
8990
8991   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8992 echo "configure:8993: checking for cosl declaration" >&5
8993   if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
8994   echo $ac_n "(cached) $ac_c" 1>&6
8995 else
8996
8997
8998     ac_ext=C
8999 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9000 ac_cpp='$CXXCPP $CPPFLAGS'
9001 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9002 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9003 cross_compiling=$ac_cv_prog_cxx_cross
9004
9005     cat > conftest.$ac_ext <<EOF
9006 #line 9007 "configure"
9007 #include "confdefs.h"
9008 #include <math.h>
9009 int main() {
9010  cosl(0);
9011 ; return 0; }
9012 EOF
9013 if { (eval echo configure:9014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9014   rm -rf conftest*
9015   glibcpp_cv_func_cosl_use=yes
9016 else
9017   echo "configure: failed program was:" >&5
9018   cat conftest.$ac_ext >&5
9019   rm -rf conftest*
9020   glibcpp_cv_func_cosl_use=no
9021 fi
9022 rm -f conftest*
9023     ac_ext=c
9024 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9025 ac_cpp='$CPP $CPPFLAGS'
9026 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9027 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9028 cross_compiling=$ac_cv_prog_cc_cross
9029
9030
9031 fi
9032
9033   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
9034   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
9035     for ac_func in cosl
9036 do
9037 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9038 echo "configure:9039: checking for $ac_func" >&5
9039 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9040   echo $ac_n "(cached) $ac_c" 1>&6
9041 else
9042   cat > conftest.$ac_ext <<EOF
9043 #line 9044 "configure"
9044 #include "confdefs.h"
9045 /* System header to define __stub macros and hopefully few prototypes,
9046     which can conflict with char $ac_func(); below.  */
9047 #include <assert.h>
9048 /* Override any gcc2 internal prototype to avoid an error.  */
9049 /* We use char because int might match the return type of a gcc2
9050     builtin and then its argument prototype would still apply.  */
9051 char $ac_func();
9052
9053 int main() {
9054
9055 /* The GNU C library defines this for functions which it implements
9056     to always fail with ENOSYS.  Some functions are actually named
9057     something starting with __ and the normal name is an alias.  */
9058 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9059 choke me
9060 #else
9061 $ac_func();
9062 #endif
9063
9064 ; return 0; }
9065 EOF
9066 if { (eval echo configure:9067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9067   rm -rf conftest*
9068   eval "ac_cv_func_$ac_func=yes"
9069 else
9070   echo "configure: failed program was:" >&5
9071   cat conftest.$ac_ext >&5
9072   rm -rf conftest*
9073   eval "ac_cv_func_$ac_func=no"
9074 fi
9075 rm -f conftest*
9076 fi
9077
9078 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9079   echo "$ac_t""yes" 1>&6
9080     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9081   cat >> confdefs.h <<EOF
9082 #define $ac_tr_func 1
9083 EOF
9084
9085 else
9086   echo "$ac_t""no" 1>&6
9087 fi
9088 done
9089
9090   fi
9091
9092
9093   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
9094 echo "configure:9095: checking for coshl declaration" >&5
9095   if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
9096   echo $ac_n "(cached) $ac_c" 1>&6
9097 else
9098
9099
9100     ac_ext=C
9101 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9102 ac_cpp='$CXXCPP $CPPFLAGS'
9103 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9104 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9105 cross_compiling=$ac_cv_prog_cxx_cross
9106
9107     cat > conftest.$ac_ext <<EOF
9108 #line 9109 "configure"
9109 #include "confdefs.h"
9110 #include <math.h>
9111 int main() {
9112  coshl(0);
9113 ; return 0; }
9114 EOF
9115 if { (eval echo configure:9116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9116   rm -rf conftest*
9117   glibcpp_cv_func_coshl_use=yes
9118 else
9119   echo "configure: failed program was:" >&5
9120   cat conftest.$ac_ext >&5
9121   rm -rf conftest*
9122   glibcpp_cv_func_coshl_use=no
9123 fi
9124 rm -f conftest*
9125     ac_ext=c
9126 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9127 ac_cpp='$CPP $CPPFLAGS'
9128 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9129 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9130 cross_compiling=$ac_cv_prog_cc_cross
9131
9132
9133 fi
9134
9135   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
9136   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
9137     for ac_func in coshl
9138 do
9139 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9140 echo "configure:9141: checking for $ac_func" >&5
9141 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9142   echo $ac_n "(cached) $ac_c" 1>&6
9143 else
9144   cat > conftest.$ac_ext <<EOF
9145 #line 9146 "configure"
9146 #include "confdefs.h"
9147 /* System header to define __stub macros and hopefully few prototypes,
9148     which can conflict with char $ac_func(); below.  */
9149 #include <assert.h>
9150 /* Override any gcc2 internal prototype to avoid an error.  */
9151 /* We use char because int might match the return type of a gcc2
9152     builtin and then its argument prototype would still apply.  */
9153 char $ac_func();
9154
9155 int main() {
9156
9157 /* The GNU C library defines this for functions which it implements
9158     to always fail with ENOSYS.  Some functions are actually named
9159     something starting with __ and the normal name is an alias.  */
9160 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9161 choke me
9162 #else
9163 $ac_func();
9164 #endif
9165
9166 ; return 0; }
9167 EOF
9168 if { (eval echo configure:9169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9169   rm -rf conftest*
9170   eval "ac_cv_func_$ac_func=yes"
9171 else
9172   echo "configure: failed program was:" >&5
9173   cat conftest.$ac_ext >&5
9174   rm -rf conftest*
9175   eval "ac_cv_func_$ac_func=no"
9176 fi
9177 rm -f conftest*
9178 fi
9179
9180 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9181   echo "$ac_t""yes" 1>&6
9182     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9183   cat >> confdefs.h <<EOF
9184 #define $ac_tr_func 1
9185 EOF
9186
9187 else
9188   echo "$ac_t""no" 1>&6
9189 fi
9190 done
9191
9192   fi
9193
9194
9195   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
9196 echo "configure:9197: checking for expl declaration" >&5
9197   if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
9198   echo $ac_n "(cached) $ac_c" 1>&6
9199 else
9200
9201
9202     ac_ext=C
9203 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9204 ac_cpp='$CXXCPP $CPPFLAGS'
9205 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9206 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9207 cross_compiling=$ac_cv_prog_cxx_cross
9208
9209     cat > conftest.$ac_ext <<EOF
9210 #line 9211 "configure"
9211 #include "confdefs.h"
9212 #include <math.h>
9213 int main() {
9214  expl(0);
9215 ; return 0; }
9216 EOF
9217 if { (eval echo configure:9218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9218   rm -rf conftest*
9219   glibcpp_cv_func_expl_use=yes
9220 else
9221   echo "configure: failed program was:" >&5
9222   cat conftest.$ac_ext >&5
9223   rm -rf conftest*
9224   glibcpp_cv_func_expl_use=no
9225 fi
9226 rm -f conftest*
9227     ac_ext=c
9228 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9229 ac_cpp='$CPP $CPPFLAGS'
9230 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9231 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9232 cross_compiling=$ac_cv_prog_cc_cross
9233
9234
9235 fi
9236
9237   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
9238   if test x$glibcpp_cv_func_expl_use = x"yes"; then
9239     for ac_func in expl
9240 do
9241 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9242 echo "configure:9243: checking for $ac_func" >&5
9243 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9244   echo $ac_n "(cached) $ac_c" 1>&6
9245 else
9246   cat > conftest.$ac_ext <<EOF
9247 #line 9248 "configure"
9248 #include "confdefs.h"
9249 /* System header to define __stub macros and hopefully few prototypes,
9250     which can conflict with char $ac_func(); below.  */
9251 #include <assert.h>
9252 /* Override any gcc2 internal prototype to avoid an error.  */
9253 /* We use char because int might match the return type of a gcc2
9254     builtin and then its argument prototype would still apply.  */
9255 char $ac_func();
9256
9257 int main() {
9258
9259 /* The GNU C library defines this for functions which it implements
9260     to always fail with ENOSYS.  Some functions are actually named
9261     something starting with __ and the normal name is an alias.  */
9262 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9263 choke me
9264 #else
9265 $ac_func();
9266 #endif
9267
9268 ; return 0; }
9269 EOF
9270 if { (eval echo configure:9271: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9271   rm -rf conftest*
9272   eval "ac_cv_func_$ac_func=yes"
9273 else
9274   echo "configure: failed program was:" >&5
9275   cat conftest.$ac_ext >&5
9276   rm -rf conftest*
9277   eval "ac_cv_func_$ac_func=no"
9278 fi
9279 rm -f conftest*
9280 fi
9281
9282 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9283   echo "$ac_t""yes" 1>&6
9284     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9285   cat >> confdefs.h <<EOF
9286 #define $ac_tr_func 1
9287 EOF
9288
9289 else
9290   echo "$ac_t""no" 1>&6
9291 fi
9292 done
9293
9294   fi
9295
9296
9297   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9298 echo "configure:9299: checking for fabsl declaration" >&5
9299   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
9300   echo $ac_n "(cached) $ac_c" 1>&6
9301 else
9302
9303
9304     ac_ext=C
9305 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9306 ac_cpp='$CXXCPP $CPPFLAGS'
9307 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9308 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9309 cross_compiling=$ac_cv_prog_cxx_cross
9310
9311     cat > conftest.$ac_ext <<EOF
9312 #line 9313 "configure"
9313 #include "confdefs.h"
9314 #include <math.h>
9315 int main() {
9316  fabsl(0);
9317 ; return 0; }
9318 EOF
9319 if { (eval echo configure:9320: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9320   rm -rf conftest*
9321   glibcpp_cv_func_fabsl_use=yes
9322 else
9323   echo "configure: failed program was:" >&5
9324   cat conftest.$ac_ext >&5
9325   rm -rf conftest*
9326   glibcpp_cv_func_fabsl_use=no
9327 fi
9328 rm -f conftest*
9329     ac_ext=c
9330 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9331 ac_cpp='$CPP $CPPFLAGS'
9332 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9333 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9334 cross_compiling=$ac_cv_prog_cc_cross
9335
9336
9337 fi
9338
9339   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
9340   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
9341     for ac_func in fabsl
9342 do
9343 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9344 echo "configure:9345: checking for $ac_func" >&5
9345 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9346   echo $ac_n "(cached) $ac_c" 1>&6
9347 else
9348   cat > conftest.$ac_ext <<EOF
9349 #line 9350 "configure"
9350 #include "confdefs.h"
9351 /* System header to define __stub macros and hopefully few prototypes,
9352     which can conflict with char $ac_func(); below.  */
9353 #include <assert.h>
9354 /* Override any gcc2 internal prototype to avoid an error.  */
9355 /* We use char because int might match the return type of a gcc2
9356     builtin and then its argument prototype would still apply.  */
9357 char $ac_func();
9358
9359 int main() {
9360
9361 /* The GNU C library defines this for functions which it implements
9362     to always fail with ENOSYS.  Some functions are actually named
9363     something starting with __ and the normal name is an alias.  */
9364 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9365 choke me
9366 #else
9367 $ac_func();
9368 #endif
9369
9370 ; return 0; }
9371 EOF
9372 if { (eval echo configure:9373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9373   rm -rf conftest*
9374   eval "ac_cv_func_$ac_func=yes"
9375 else
9376   echo "configure: failed program was:" >&5
9377   cat conftest.$ac_ext >&5
9378   rm -rf conftest*
9379   eval "ac_cv_func_$ac_func=no"
9380 fi
9381 rm -f conftest*
9382 fi
9383
9384 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9385   echo "$ac_t""yes" 1>&6
9386     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9387   cat >> confdefs.h <<EOF
9388 #define $ac_tr_func 1
9389 EOF
9390
9391 else
9392   echo "$ac_t""no" 1>&6
9393 fi
9394 done
9395
9396   fi
9397
9398
9399   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9400 echo "configure:9401: checking for floorl declaration" >&5
9401   if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
9402   echo $ac_n "(cached) $ac_c" 1>&6
9403 else
9404
9405
9406     ac_ext=C
9407 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9408 ac_cpp='$CXXCPP $CPPFLAGS'
9409 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9410 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9411 cross_compiling=$ac_cv_prog_cxx_cross
9412
9413     cat > conftest.$ac_ext <<EOF
9414 #line 9415 "configure"
9415 #include "confdefs.h"
9416 #include <math.h>
9417 int main() {
9418  floorl(0);
9419 ; return 0; }
9420 EOF
9421 if { (eval echo configure:9422: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9422   rm -rf conftest*
9423   glibcpp_cv_func_floorl_use=yes
9424 else
9425   echo "configure: failed program was:" >&5
9426   cat conftest.$ac_ext >&5
9427   rm -rf conftest*
9428   glibcpp_cv_func_floorl_use=no
9429 fi
9430 rm -f conftest*
9431     ac_ext=c
9432 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9433 ac_cpp='$CPP $CPPFLAGS'
9434 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9435 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9436 cross_compiling=$ac_cv_prog_cc_cross
9437
9438
9439 fi
9440
9441   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
9442   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
9443     for ac_func in floorl
9444 do
9445 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9446 echo "configure:9447: checking for $ac_func" >&5
9447 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9448   echo $ac_n "(cached) $ac_c" 1>&6
9449 else
9450   cat > conftest.$ac_ext <<EOF
9451 #line 9452 "configure"
9452 #include "confdefs.h"
9453 /* System header to define __stub macros and hopefully few prototypes,
9454     which can conflict with char $ac_func(); below.  */
9455 #include <assert.h>
9456 /* Override any gcc2 internal prototype to avoid an error.  */
9457 /* We use char because int might match the return type of a gcc2
9458     builtin and then its argument prototype would still apply.  */
9459 char $ac_func();
9460
9461 int main() {
9462
9463 /* The GNU C library defines this for functions which it implements
9464     to always fail with ENOSYS.  Some functions are actually named
9465     something starting with __ and the normal name is an alias.  */
9466 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9467 choke me
9468 #else
9469 $ac_func();
9470 #endif
9471
9472 ; return 0; }
9473 EOF
9474 if { (eval echo configure:9475: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9475   rm -rf conftest*
9476   eval "ac_cv_func_$ac_func=yes"
9477 else
9478   echo "configure: failed program was:" >&5
9479   cat conftest.$ac_ext >&5
9480   rm -rf conftest*
9481   eval "ac_cv_func_$ac_func=no"
9482 fi
9483 rm -f conftest*
9484 fi
9485
9486 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9487   echo "$ac_t""yes" 1>&6
9488     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9489   cat >> confdefs.h <<EOF
9490 #define $ac_tr_func 1
9491 EOF
9492
9493 else
9494   echo "$ac_t""no" 1>&6
9495 fi
9496 done
9497
9498   fi
9499
9500
9501   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9502 echo "configure:9503: checking for fmodl declaration" >&5
9503   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
9504   echo $ac_n "(cached) $ac_c" 1>&6
9505 else
9506
9507
9508     ac_ext=C
9509 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9510 ac_cpp='$CXXCPP $CPPFLAGS'
9511 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9512 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9513 cross_compiling=$ac_cv_prog_cxx_cross
9514
9515     cat > conftest.$ac_ext <<EOF
9516 #line 9517 "configure"
9517 #include "confdefs.h"
9518 #include <math.h>
9519 int main() {
9520  fmodl(0, 0);
9521 ; return 0; }
9522 EOF
9523 if { (eval echo configure:9524: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9524   rm -rf conftest*
9525   glibcpp_cv_func_fmodl_use=yes
9526 else
9527   echo "configure: failed program was:" >&5
9528   cat conftest.$ac_ext >&5
9529   rm -rf conftest*
9530   glibcpp_cv_func_fmodl_use=no
9531 fi
9532 rm -f conftest*
9533     ac_ext=c
9534 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9535 ac_cpp='$CPP $CPPFLAGS'
9536 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9537 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9538 cross_compiling=$ac_cv_prog_cc_cross
9539
9540
9541 fi
9542
9543   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
9544   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
9545     for ac_func in fmodl
9546 do
9547 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9548 echo "configure:9549: checking for $ac_func" >&5
9549 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9550   echo $ac_n "(cached) $ac_c" 1>&6
9551 else
9552   cat > conftest.$ac_ext <<EOF
9553 #line 9554 "configure"
9554 #include "confdefs.h"
9555 /* System header to define __stub macros and hopefully few prototypes,
9556     which can conflict with char $ac_func(); below.  */
9557 #include <assert.h>
9558 /* Override any gcc2 internal prototype to avoid an error.  */
9559 /* We use char because int might match the return type of a gcc2
9560     builtin and then its argument prototype would still apply.  */
9561 char $ac_func();
9562
9563 int main() {
9564
9565 /* The GNU C library defines this for functions which it implements
9566     to always fail with ENOSYS.  Some functions are actually named
9567     something starting with __ and the normal name is an alias.  */
9568 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9569 choke me
9570 #else
9571 $ac_func();
9572 #endif
9573
9574 ; return 0; }
9575 EOF
9576 if { (eval echo configure:9577: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9577   rm -rf conftest*
9578   eval "ac_cv_func_$ac_func=yes"
9579 else
9580   echo "configure: failed program was:" >&5
9581   cat conftest.$ac_ext >&5
9582   rm -rf conftest*
9583   eval "ac_cv_func_$ac_func=no"
9584 fi
9585 rm -f conftest*
9586 fi
9587
9588 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9589   echo "$ac_t""yes" 1>&6
9590     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9591   cat >> confdefs.h <<EOF
9592 #define $ac_tr_func 1
9593 EOF
9594
9595 else
9596   echo "$ac_t""no" 1>&6
9597 fi
9598 done
9599
9600   fi
9601
9602
9603   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9604 echo "configure:9605: checking for frexpl declaration" >&5
9605   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
9606   echo $ac_n "(cached) $ac_c" 1>&6
9607 else
9608
9609
9610     ac_ext=C
9611 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9612 ac_cpp='$CXXCPP $CPPFLAGS'
9613 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9614 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9615 cross_compiling=$ac_cv_prog_cxx_cross
9616
9617     cat > conftest.$ac_ext <<EOF
9618 #line 9619 "configure"
9619 #include "confdefs.h"
9620 #include <math.h>
9621 int main() {
9622  frexpl(0, 0);
9623 ; return 0; }
9624 EOF
9625 if { (eval echo configure:9626: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9626   rm -rf conftest*
9627   glibcpp_cv_func_frexpl_use=yes
9628 else
9629   echo "configure: failed program was:" >&5
9630   cat conftest.$ac_ext >&5
9631   rm -rf conftest*
9632   glibcpp_cv_func_frexpl_use=no
9633 fi
9634 rm -f conftest*
9635     ac_ext=c
9636 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9637 ac_cpp='$CPP $CPPFLAGS'
9638 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9639 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9640 cross_compiling=$ac_cv_prog_cc_cross
9641
9642
9643 fi
9644
9645   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
9646   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
9647     for ac_func in frexpl
9648 do
9649 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9650 echo "configure:9651: checking for $ac_func" >&5
9651 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9652   echo $ac_n "(cached) $ac_c" 1>&6
9653 else
9654   cat > conftest.$ac_ext <<EOF
9655 #line 9656 "configure"
9656 #include "confdefs.h"
9657 /* System header to define __stub macros and hopefully few prototypes,
9658     which can conflict with char $ac_func(); below.  */
9659 #include <assert.h>
9660 /* Override any gcc2 internal prototype to avoid an error.  */
9661 /* We use char because int might match the return type of a gcc2
9662     builtin and then its argument prototype would still apply.  */
9663 char $ac_func();
9664
9665 int main() {
9666
9667 /* The GNU C library defines this for functions which it implements
9668     to always fail with ENOSYS.  Some functions are actually named
9669     something starting with __ and the normal name is an alias.  */
9670 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9671 choke me
9672 #else
9673 $ac_func();
9674 #endif
9675
9676 ; return 0; }
9677 EOF
9678 if { (eval echo configure:9679: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9679   rm -rf conftest*
9680   eval "ac_cv_func_$ac_func=yes"
9681 else
9682   echo "configure: failed program was:" >&5
9683   cat conftest.$ac_ext >&5
9684   rm -rf conftest*
9685   eval "ac_cv_func_$ac_func=no"
9686 fi
9687 rm -f conftest*
9688 fi
9689
9690 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9691   echo "$ac_t""yes" 1>&6
9692     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9693   cat >> confdefs.h <<EOF
9694 #define $ac_tr_func 1
9695 EOF
9696
9697 else
9698   echo "$ac_t""no" 1>&6
9699 fi
9700 done
9701
9702   fi
9703
9704
9705   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9706 echo "configure:9707: checking for ldexpl declaration" >&5
9707   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
9708   echo $ac_n "(cached) $ac_c" 1>&6
9709 else
9710
9711
9712     ac_ext=C
9713 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9714 ac_cpp='$CXXCPP $CPPFLAGS'
9715 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9716 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9717 cross_compiling=$ac_cv_prog_cxx_cross
9718
9719     cat > conftest.$ac_ext <<EOF
9720 #line 9721 "configure"
9721 #include "confdefs.h"
9722 #include <math.h>
9723 int main() {
9724  ldexpl(0, 0);
9725 ; return 0; }
9726 EOF
9727 if { (eval echo configure:9728: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9728   rm -rf conftest*
9729   glibcpp_cv_func_ldexpl_use=yes
9730 else
9731   echo "configure: failed program was:" >&5
9732   cat conftest.$ac_ext >&5
9733   rm -rf conftest*
9734   glibcpp_cv_func_ldexpl_use=no
9735 fi
9736 rm -f conftest*
9737     ac_ext=c
9738 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9739 ac_cpp='$CPP $CPPFLAGS'
9740 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9741 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9742 cross_compiling=$ac_cv_prog_cc_cross
9743
9744
9745 fi
9746
9747   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
9748   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
9749     for ac_func in ldexpl
9750 do
9751 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9752 echo "configure:9753: checking for $ac_func" >&5
9753 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9754   echo $ac_n "(cached) $ac_c" 1>&6
9755 else
9756   cat > conftest.$ac_ext <<EOF
9757 #line 9758 "configure"
9758 #include "confdefs.h"
9759 /* System header to define __stub macros and hopefully few prototypes,
9760     which can conflict with char $ac_func(); below.  */
9761 #include <assert.h>
9762 /* Override any gcc2 internal prototype to avoid an error.  */
9763 /* We use char because int might match the return type of a gcc2
9764     builtin and then its argument prototype would still apply.  */
9765 char $ac_func();
9766
9767 int main() {
9768
9769 /* The GNU C library defines this for functions which it implements
9770     to always fail with ENOSYS.  Some functions are actually named
9771     something starting with __ and the normal name is an alias.  */
9772 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9773 choke me
9774 #else
9775 $ac_func();
9776 #endif
9777
9778 ; return 0; }
9779 EOF
9780 if { (eval echo configure:9781: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9781   rm -rf conftest*
9782   eval "ac_cv_func_$ac_func=yes"
9783 else
9784   echo "configure: failed program was:" >&5
9785   cat conftest.$ac_ext >&5
9786   rm -rf conftest*
9787   eval "ac_cv_func_$ac_func=no"
9788 fi
9789 rm -f conftest*
9790 fi
9791
9792 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9793   echo "$ac_t""yes" 1>&6
9794     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9795   cat >> confdefs.h <<EOF
9796 #define $ac_tr_func 1
9797 EOF
9798
9799 else
9800   echo "$ac_t""no" 1>&6
9801 fi
9802 done
9803
9804   fi
9805
9806
9807   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9808 echo "configure:9809: checking for logl declaration" >&5
9809   if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
9810   echo $ac_n "(cached) $ac_c" 1>&6
9811 else
9812
9813
9814     ac_ext=C
9815 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9816 ac_cpp='$CXXCPP $CPPFLAGS'
9817 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9818 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9819 cross_compiling=$ac_cv_prog_cxx_cross
9820
9821     cat > conftest.$ac_ext <<EOF
9822 #line 9823 "configure"
9823 #include "confdefs.h"
9824 #include <math.h>
9825 int main() {
9826  logl(0);
9827 ; return 0; }
9828 EOF
9829 if { (eval echo configure:9830: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9830   rm -rf conftest*
9831   glibcpp_cv_func_logl_use=yes
9832 else
9833   echo "configure: failed program was:" >&5
9834   cat conftest.$ac_ext >&5
9835   rm -rf conftest*
9836   glibcpp_cv_func_logl_use=no
9837 fi
9838 rm -f conftest*
9839     ac_ext=c
9840 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9841 ac_cpp='$CPP $CPPFLAGS'
9842 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9843 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9844 cross_compiling=$ac_cv_prog_cc_cross
9845
9846
9847 fi
9848
9849   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
9850   if test x$glibcpp_cv_func_logl_use = x"yes"; then
9851     for ac_func in logl
9852 do
9853 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9854 echo "configure:9855: checking for $ac_func" >&5
9855 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9856   echo $ac_n "(cached) $ac_c" 1>&6
9857 else
9858   cat > conftest.$ac_ext <<EOF
9859 #line 9860 "configure"
9860 #include "confdefs.h"
9861 /* System header to define __stub macros and hopefully few prototypes,
9862     which can conflict with char $ac_func(); below.  */
9863 #include <assert.h>
9864 /* Override any gcc2 internal prototype to avoid an error.  */
9865 /* We use char because int might match the return type of a gcc2
9866     builtin and then its argument prototype would still apply.  */
9867 char $ac_func();
9868
9869 int main() {
9870
9871 /* The GNU C library defines this for functions which it implements
9872     to always fail with ENOSYS.  Some functions are actually named
9873     something starting with __ and the normal name is an alias.  */
9874 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9875 choke me
9876 #else
9877 $ac_func();
9878 #endif
9879
9880 ; return 0; }
9881 EOF
9882 if { (eval echo configure:9883: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9883   rm -rf conftest*
9884   eval "ac_cv_func_$ac_func=yes"
9885 else
9886   echo "configure: failed program was:" >&5
9887   cat conftest.$ac_ext >&5
9888   rm -rf conftest*
9889   eval "ac_cv_func_$ac_func=no"
9890 fi
9891 rm -f conftest*
9892 fi
9893
9894 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9895   echo "$ac_t""yes" 1>&6
9896     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9897   cat >> confdefs.h <<EOF
9898 #define $ac_tr_func 1
9899 EOF
9900
9901 else
9902   echo "$ac_t""no" 1>&6
9903 fi
9904 done
9905
9906   fi
9907
9908
9909   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9910 echo "configure:9911: checking for log10l declaration" >&5
9911   if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
9912   echo $ac_n "(cached) $ac_c" 1>&6
9913 else
9914
9915
9916     ac_ext=C
9917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9918 ac_cpp='$CXXCPP $CPPFLAGS'
9919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9921 cross_compiling=$ac_cv_prog_cxx_cross
9922
9923     cat > conftest.$ac_ext <<EOF
9924 #line 9925 "configure"
9925 #include "confdefs.h"
9926 #include <math.h>
9927 int main() {
9928  log10l(0);
9929 ; return 0; }
9930 EOF
9931 if { (eval echo configure:9932: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9932   rm -rf conftest*
9933   glibcpp_cv_func_log10l_use=yes
9934 else
9935   echo "configure: failed program was:" >&5
9936   cat conftest.$ac_ext >&5
9937   rm -rf conftest*
9938   glibcpp_cv_func_log10l_use=no
9939 fi
9940 rm -f conftest*
9941     ac_ext=c
9942 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9943 ac_cpp='$CPP $CPPFLAGS'
9944 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9945 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9946 cross_compiling=$ac_cv_prog_cc_cross
9947
9948
9949 fi
9950
9951   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
9952   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
9953     for ac_func in log10l
9954 do
9955 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9956 echo "configure:9957: checking for $ac_func" >&5
9957 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9958   echo $ac_n "(cached) $ac_c" 1>&6
9959 else
9960   cat > conftest.$ac_ext <<EOF
9961 #line 9962 "configure"
9962 #include "confdefs.h"
9963 /* System header to define __stub macros and hopefully few prototypes,
9964     which can conflict with char $ac_func(); below.  */
9965 #include <assert.h>
9966 /* Override any gcc2 internal prototype to avoid an error.  */
9967 /* We use char because int might match the return type of a gcc2
9968     builtin and then its argument prototype would still apply.  */
9969 char $ac_func();
9970
9971 int main() {
9972
9973 /* The GNU C library defines this for functions which it implements
9974     to always fail with ENOSYS.  Some functions are actually named
9975     something starting with __ and the normal name is an alias.  */
9976 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9977 choke me
9978 #else
9979 $ac_func();
9980 #endif
9981
9982 ; return 0; }
9983 EOF
9984 if { (eval echo configure:9985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9985   rm -rf conftest*
9986   eval "ac_cv_func_$ac_func=yes"
9987 else
9988   echo "configure: failed program was:" >&5
9989   cat conftest.$ac_ext >&5
9990   rm -rf conftest*
9991   eval "ac_cv_func_$ac_func=no"
9992 fi
9993 rm -f conftest*
9994 fi
9995
9996 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9997   echo "$ac_t""yes" 1>&6
9998     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9999   cat >> confdefs.h <<EOF
10000 #define $ac_tr_func 1
10001 EOF
10002
10003 else
10004   echo "$ac_t""no" 1>&6
10005 fi
10006 done
10007
10008   fi
10009
10010
10011   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
10012 echo "configure:10013: checking for modfl declaration" >&5
10013   if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
10014   echo $ac_n "(cached) $ac_c" 1>&6
10015 else
10016
10017
10018     ac_ext=C
10019 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10020 ac_cpp='$CXXCPP $CPPFLAGS'
10021 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10022 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10023 cross_compiling=$ac_cv_prog_cxx_cross
10024
10025     cat > conftest.$ac_ext <<EOF
10026 #line 10027 "configure"
10027 #include "confdefs.h"
10028 #include <math.h>
10029 int main() {
10030  modfl(0, 0);
10031 ; return 0; }
10032 EOF
10033 if { (eval echo configure:10034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10034   rm -rf conftest*
10035   glibcpp_cv_func_modfl_use=yes
10036 else
10037   echo "configure: failed program was:" >&5
10038   cat conftest.$ac_ext >&5
10039   rm -rf conftest*
10040   glibcpp_cv_func_modfl_use=no
10041 fi
10042 rm -f conftest*
10043     ac_ext=c
10044 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10045 ac_cpp='$CPP $CPPFLAGS'
10046 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10047 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10048 cross_compiling=$ac_cv_prog_cc_cross
10049
10050
10051 fi
10052
10053   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
10054   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
10055     for ac_func in modfl
10056 do
10057 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10058 echo "configure:10059: checking for $ac_func" >&5
10059 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10060   echo $ac_n "(cached) $ac_c" 1>&6
10061 else
10062   cat > conftest.$ac_ext <<EOF
10063 #line 10064 "configure"
10064 #include "confdefs.h"
10065 /* System header to define __stub macros and hopefully few prototypes,
10066     which can conflict with char $ac_func(); below.  */
10067 #include <assert.h>
10068 /* Override any gcc2 internal prototype to avoid an error.  */
10069 /* We use char because int might match the return type of a gcc2
10070     builtin and then its argument prototype would still apply.  */
10071 char $ac_func();
10072
10073 int main() {
10074
10075 /* The GNU C library defines this for functions which it implements
10076     to always fail with ENOSYS.  Some functions are actually named
10077     something starting with __ and the normal name is an alias.  */
10078 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10079 choke me
10080 #else
10081 $ac_func();
10082 #endif
10083
10084 ; return 0; }
10085 EOF
10086 if { (eval echo configure:10087: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10087   rm -rf conftest*
10088   eval "ac_cv_func_$ac_func=yes"
10089 else
10090   echo "configure: failed program was:" >&5
10091   cat conftest.$ac_ext >&5
10092   rm -rf conftest*
10093   eval "ac_cv_func_$ac_func=no"
10094 fi
10095 rm -f conftest*
10096 fi
10097
10098 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10099   echo "$ac_t""yes" 1>&6
10100     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10101   cat >> confdefs.h <<EOF
10102 #define $ac_tr_func 1
10103 EOF
10104
10105 else
10106   echo "$ac_t""no" 1>&6
10107 fi
10108 done
10109
10110   fi
10111
10112
10113   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
10114 echo "configure:10115: checking for powl declaration" >&5
10115   if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
10116   echo $ac_n "(cached) $ac_c" 1>&6
10117 else
10118
10119
10120     ac_ext=C
10121 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10122 ac_cpp='$CXXCPP $CPPFLAGS'
10123 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10124 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10125 cross_compiling=$ac_cv_prog_cxx_cross
10126
10127     cat > conftest.$ac_ext <<EOF
10128 #line 10129 "configure"
10129 #include "confdefs.h"
10130 #include <math.h>
10131 int main() {
10132  powl(0, 0);
10133 ; return 0; }
10134 EOF
10135 if { (eval echo configure:10136: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10136   rm -rf conftest*
10137   glibcpp_cv_func_powl_use=yes
10138 else
10139   echo "configure: failed program was:" >&5
10140   cat conftest.$ac_ext >&5
10141   rm -rf conftest*
10142   glibcpp_cv_func_powl_use=no
10143 fi
10144 rm -f conftest*
10145     ac_ext=c
10146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10147 ac_cpp='$CPP $CPPFLAGS'
10148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10150 cross_compiling=$ac_cv_prog_cc_cross
10151
10152
10153 fi
10154
10155   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
10156   if test x$glibcpp_cv_func_powl_use = x"yes"; then
10157     for ac_func in powl
10158 do
10159 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10160 echo "configure:10161: checking for $ac_func" >&5
10161 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10162   echo $ac_n "(cached) $ac_c" 1>&6
10163 else
10164   cat > conftest.$ac_ext <<EOF
10165 #line 10166 "configure"
10166 #include "confdefs.h"
10167 /* System header to define __stub macros and hopefully few prototypes,
10168     which can conflict with char $ac_func(); below.  */
10169 #include <assert.h>
10170 /* Override any gcc2 internal prototype to avoid an error.  */
10171 /* We use char because int might match the return type of a gcc2
10172     builtin and then its argument prototype would still apply.  */
10173 char $ac_func();
10174
10175 int main() {
10176
10177 /* The GNU C library defines this for functions which it implements
10178     to always fail with ENOSYS.  Some functions are actually named
10179     something starting with __ and the normal name is an alias.  */
10180 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10181 choke me
10182 #else
10183 $ac_func();
10184 #endif
10185
10186 ; return 0; }
10187 EOF
10188 if { (eval echo configure:10189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10189   rm -rf conftest*
10190   eval "ac_cv_func_$ac_func=yes"
10191 else
10192   echo "configure: failed program was:" >&5
10193   cat conftest.$ac_ext >&5
10194   rm -rf conftest*
10195   eval "ac_cv_func_$ac_func=no"
10196 fi
10197 rm -f conftest*
10198 fi
10199
10200 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10201   echo "$ac_t""yes" 1>&6
10202     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10203   cat >> confdefs.h <<EOF
10204 #define $ac_tr_func 1
10205 EOF
10206
10207 else
10208   echo "$ac_t""no" 1>&6
10209 fi
10210 done
10211
10212   fi
10213
10214
10215   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
10216 echo "configure:10217: checking for sinl declaration" >&5
10217   if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
10218   echo $ac_n "(cached) $ac_c" 1>&6
10219 else
10220
10221
10222     ac_ext=C
10223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10224 ac_cpp='$CXXCPP $CPPFLAGS'
10225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10227 cross_compiling=$ac_cv_prog_cxx_cross
10228
10229     cat > conftest.$ac_ext <<EOF
10230 #line 10231 "configure"
10231 #include "confdefs.h"
10232 #include <math.h>
10233 int main() {
10234  sinl(0);
10235 ; return 0; }
10236 EOF
10237 if { (eval echo configure:10238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10238   rm -rf conftest*
10239   glibcpp_cv_func_sinl_use=yes
10240 else
10241   echo "configure: failed program was:" >&5
10242   cat conftest.$ac_ext >&5
10243   rm -rf conftest*
10244   glibcpp_cv_func_sinl_use=no
10245 fi
10246 rm -f conftest*
10247     ac_ext=c
10248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10249 ac_cpp='$CPP $CPPFLAGS'
10250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10252 cross_compiling=$ac_cv_prog_cc_cross
10253
10254
10255 fi
10256
10257   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
10258   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
10259     for ac_func in sinl
10260 do
10261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10262 echo "configure:10263: checking for $ac_func" >&5
10263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10264   echo $ac_n "(cached) $ac_c" 1>&6
10265 else
10266   cat > conftest.$ac_ext <<EOF
10267 #line 10268 "configure"
10268 #include "confdefs.h"
10269 /* System header to define __stub macros and hopefully few prototypes,
10270     which can conflict with char $ac_func(); below.  */
10271 #include <assert.h>
10272 /* Override any gcc2 internal prototype to avoid an error.  */
10273 /* We use char because int might match the return type of a gcc2
10274     builtin and then its argument prototype would still apply.  */
10275 char $ac_func();
10276
10277 int main() {
10278
10279 /* The GNU C library defines this for functions which it implements
10280     to always fail with ENOSYS.  Some functions are actually named
10281     something starting with __ and the normal name is an alias.  */
10282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10283 choke me
10284 #else
10285 $ac_func();
10286 #endif
10287
10288 ; return 0; }
10289 EOF
10290 if { (eval echo configure:10291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10291   rm -rf conftest*
10292   eval "ac_cv_func_$ac_func=yes"
10293 else
10294   echo "configure: failed program was:" >&5
10295   cat conftest.$ac_ext >&5
10296   rm -rf conftest*
10297   eval "ac_cv_func_$ac_func=no"
10298 fi
10299 rm -f conftest*
10300 fi
10301
10302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10303   echo "$ac_t""yes" 1>&6
10304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10305   cat >> confdefs.h <<EOF
10306 #define $ac_tr_func 1
10307 EOF
10308
10309 else
10310   echo "$ac_t""no" 1>&6
10311 fi
10312 done
10313
10314   fi
10315
10316
10317   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
10318 echo "configure:10319: checking for sinhl declaration" >&5
10319   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
10320   echo $ac_n "(cached) $ac_c" 1>&6
10321 else
10322
10323
10324     ac_ext=C
10325 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10326 ac_cpp='$CXXCPP $CPPFLAGS'
10327 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10328 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10329 cross_compiling=$ac_cv_prog_cxx_cross
10330
10331     cat > conftest.$ac_ext <<EOF
10332 #line 10333 "configure"
10333 #include "confdefs.h"
10334 #include <math.h>
10335 int main() {
10336  sinhl(0);
10337 ; return 0; }
10338 EOF
10339 if { (eval echo configure:10340: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10340   rm -rf conftest*
10341   glibcpp_cv_func_sinhl_use=yes
10342 else
10343   echo "configure: failed program was:" >&5
10344   cat conftest.$ac_ext >&5
10345   rm -rf conftest*
10346   glibcpp_cv_func_sinhl_use=no
10347 fi
10348 rm -f conftest*
10349     ac_ext=c
10350 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10351 ac_cpp='$CPP $CPPFLAGS'
10352 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10353 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10354 cross_compiling=$ac_cv_prog_cc_cross
10355
10356
10357 fi
10358
10359   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
10360   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
10361     for ac_func in sinhl
10362 do
10363 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10364 echo "configure:10365: checking for $ac_func" >&5
10365 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10366   echo $ac_n "(cached) $ac_c" 1>&6
10367 else
10368   cat > conftest.$ac_ext <<EOF
10369 #line 10370 "configure"
10370 #include "confdefs.h"
10371 /* System header to define __stub macros and hopefully few prototypes,
10372     which can conflict with char $ac_func(); below.  */
10373 #include <assert.h>
10374 /* Override any gcc2 internal prototype to avoid an error.  */
10375 /* We use char because int might match the return type of a gcc2
10376     builtin and then its argument prototype would still apply.  */
10377 char $ac_func();
10378
10379 int main() {
10380
10381 /* The GNU C library defines this for functions which it implements
10382     to always fail with ENOSYS.  Some functions are actually named
10383     something starting with __ and the normal name is an alias.  */
10384 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10385 choke me
10386 #else
10387 $ac_func();
10388 #endif
10389
10390 ; return 0; }
10391 EOF
10392 if { (eval echo configure:10393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10393   rm -rf conftest*
10394   eval "ac_cv_func_$ac_func=yes"
10395 else
10396   echo "configure: failed program was:" >&5
10397   cat conftest.$ac_ext >&5
10398   rm -rf conftest*
10399   eval "ac_cv_func_$ac_func=no"
10400 fi
10401 rm -f conftest*
10402 fi
10403
10404 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10405   echo "$ac_t""yes" 1>&6
10406     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10407   cat >> confdefs.h <<EOF
10408 #define $ac_tr_func 1
10409 EOF
10410
10411 else
10412   echo "$ac_t""no" 1>&6
10413 fi
10414 done
10415
10416   fi
10417
10418
10419   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
10420 echo "configure:10421: checking for sqrtl declaration" >&5
10421   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
10422   echo $ac_n "(cached) $ac_c" 1>&6
10423 else
10424
10425
10426     ac_ext=C
10427 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10428 ac_cpp='$CXXCPP $CPPFLAGS'
10429 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10430 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10431 cross_compiling=$ac_cv_prog_cxx_cross
10432
10433     cat > conftest.$ac_ext <<EOF
10434 #line 10435 "configure"
10435 #include "confdefs.h"
10436 #include <math.h>
10437 int main() {
10438  sqrtl(0);
10439 ; return 0; }
10440 EOF
10441 if { (eval echo configure:10442: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10442   rm -rf conftest*
10443   glibcpp_cv_func_sqrtl_use=yes
10444 else
10445   echo "configure: failed program was:" >&5
10446   cat conftest.$ac_ext >&5
10447   rm -rf conftest*
10448   glibcpp_cv_func_sqrtl_use=no
10449 fi
10450 rm -f conftest*
10451     ac_ext=c
10452 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10453 ac_cpp='$CPP $CPPFLAGS'
10454 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10455 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10456 cross_compiling=$ac_cv_prog_cc_cross
10457
10458
10459 fi
10460
10461   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
10462   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
10463     for ac_func in sqrtl
10464 do
10465 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10466 echo "configure:10467: checking for $ac_func" >&5
10467 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10468   echo $ac_n "(cached) $ac_c" 1>&6
10469 else
10470   cat > conftest.$ac_ext <<EOF
10471 #line 10472 "configure"
10472 #include "confdefs.h"
10473 /* System header to define __stub macros and hopefully few prototypes,
10474     which can conflict with char $ac_func(); below.  */
10475 #include <assert.h>
10476 /* Override any gcc2 internal prototype to avoid an error.  */
10477 /* We use char because int might match the return type of a gcc2
10478     builtin and then its argument prototype would still apply.  */
10479 char $ac_func();
10480
10481 int main() {
10482
10483 /* The GNU C library defines this for functions which it implements
10484     to always fail with ENOSYS.  Some functions are actually named
10485     something starting with __ and the normal name is an alias.  */
10486 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10487 choke me
10488 #else
10489 $ac_func();
10490 #endif
10491
10492 ; return 0; }
10493 EOF
10494 if { (eval echo configure:10495: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10495   rm -rf conftest*
10496   eval "ac_cv_func_$ac_func=yes"
10497 else
10498   echo "configure: failed program was:" >&5
10499   cat conftest.$ac_ext >&5
10500   rm -rf conftest*
10501   eval "ac_cv_func_$ac_func=no"
10502 fi
10503 rm -f conftest*
10504 fi
10505
10506 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10507   echo "$ac_t""yes" 1>&6
10508     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10509   cat >> confdefs.h <<EOF
10510 #define $ac_tr_func 1
10511 EOF
10512
10513 else
10514   echo "$ac_t""no" 1>&6
10515 fi
10516 done
10517
10518   fi
10519
10520
10521   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
10522 echo "configure:10523: checking for tanl declaration" >&5
10523   if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
10524   echo $ac_n "(cached) $ac_c" 1>&6
10525 else
10526
10527
10528     ac_ext=C
10529 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10530 ac_cpp='$CXXCPP $CPPFLAGS'
10531 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10532 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10533 cross_compiling=$ac_cv_prog_cxx_cross
10534
10535     cat > conftest.$ac_ext <<EOF
10536 #line 10537 "configure"
10537 #include "confdefs.h"
10538 #include <math.h>
10539 int main() {
10540  tanl(0);
10541 ; return 0; }
10542 EOF
10543 if { (eval echo configure:10544: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10544   rm -rf conftest*
10545   glibcpp_cv_func_tanl_use=yes
10546 else
10547   echo "configure: failed program was:" >&5
10548   cat conftest.$ac_ext >&5
10549   rm -rf conftest*
10550   glibcpp_cv_func_tanl_use=no
10551 fi
10552 rm -f conftest*
10553     ac_ext=c
10554 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10555 ac_cpp='$CPP $CPPFLAGS'
10556 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10557 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10558 cross_compiling=$ac_cv_prog_cc_cross
10559
10560
10561 fi
10562
10563   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
10564   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
10565     for ac_func in tanl
10566 do
10567 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10568 echo "configure:10569: checking for $ac_func" >&5
10569 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10570   echo $ac_n "(cached) $ac_c" 1>&6
10571 else
10572   cat > conftest.$ac_ext <<EOF
10573 #line 10574 "configure"
10574 #include "confdefs.h"
10575 /* System header to define __stub macros and hopefully few prototypes,
10576     which can conflict with char $ac_func(); below.  */
10577 #include <assert.h>
10578 /* Override any gcc2 internal prototype to avoid an error.  */
10579 /* We use char because int might match the return type of a gcc2
10580     builtin and then its argument prototype would still apply.  */
10581 char $ac_func();
10582
10583 int main() {
10584
10585 /* The GNU C library defines this for functions which it implements
10586     to always fail with ENOSYS.  Some functions are actually named
10587     something starting with __ and the normal name is an alias.  */
10588 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10589 choke me
10590 #else
10591 $ac_func();
10592 #endif
10593
10594 ; return 0; }
10595 EOF
10596 if { (eval echo configure:10597: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10597   rm -rf conftest*
10598   eval "ac_cv_func_$ac_func=yes"
10599 else
10600   echo "configure: failed program was:" >&5
10601   cat conftest.$ac_ext >&5
10602   rm -rf conftest*
10603   eval "ac_cv_func_$ac_func=no"
10604 fi
10605 rm -f conftest*
10606 fi
10607
10608 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10609   echo "$ac_t""yes" 1>&6
10610     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10611   cat >> confdefs.h <<EOF
10612 #define $ac_tr_func 1
10613 EOF
10614
10615 else
10616   echo "$ac_t""no" 1>&6
10617 fi
10618 done
10619
10620   fi
10621
10622
10623   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
10624 echo "configure:10625: checking for tanhl declaration" >&5
10625   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
10626   echo $ac_n "(cached) $ac_c" 1>&6
10627 else
10628
10629
10630     ac_ext=C
10631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10632 ac_cpp='$CXXCPP $CPPFLAGS'
10633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10635 cross_compiling=$ac_cv_prog_cxx_cross
10636
10637     cat > conftest.$ac_ext <<EOF
10638 #line 10639 "configure"
10639 #include "confdefs.h"
10640 #include <math.h>
10641 int main() {
10642  tanhl(0);
10643 ; return 0; }
10644 EOF
10645 if { (eval echo configure:10646: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10646   rm -rf conftest*
10647   glibcpp_cv_func_tanhl_use=yes
10648 else
10649   echo "configure: failed program was:" >&5
10650   cat conftest.$ac_ext >&5
10651   rm -rf conftest*
10652   glibcpp_cv_func_tanhl_use=no
10653 fi
10654 rm -f conftest*
10655     ac_ext=c
10656 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10657 ac_cpp='$CPP $CPPFLAGS'
10658 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10659 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10660 cross_compiling=$ac_cv_prog_cc_cross
10661
10662
10663 fi
10664
10665   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
10666   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
10667     for ac_func in tanhl
10668 do
10669 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10670 echo "configure:10671: checking for $ac_func" >&5
10671 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10672   echo $ac_n "(cached) $ac_c" 1>&6
10673 else
10674   cat > conftest.$ac_ext <<EOF
10675 #line 10676 "configure"
10676 #include "confdefs.h"
10677 /* System header to define __stub macros and hopefully few prototypes,
10678     which can conflict with char $ac_func(); below.  */
10679 #include <assert.h>
10680 /* Override any gcc2 internal prototype to avoid an error.  */
10681 /* We use char because int might match the return type of a gcc2
10682     builtin and then its argument prototype would still apply.  */
10683 char $ac_func();
10684
10685 int main() {
10686
10687 /* The GNU C library defines this for functions which it implements
10688     to always fail with ENOSYS.  Some functions are actually named
10689     something starting with __ and the normal name is an alias.  */
10690 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10691 choke me
10692 #else
10693 $ac_func();
10694 #endif
10695
10696 ; return 0; }
10697 EOF
10698 if { (eval echo configure:10699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10699   rm -rf conftest*
10700   eval "ac_cv_func_$ac_func=yes"
10701 else
10702   echo "configure: failed program was:" >&5
10703   cat conftest.$ac_ext >&5
10704   rm -rf conftest*
10705   eval "ac_cv_func_$ac_func=no"
10706 fi
10707 rm -f conftest*
10708 fi
10709
10710 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10711   echo "$ac_t""yes" 1>&6
10712     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10713   cat >> confdefs.h <<EOF
10714 #define $ac_tr_func 1
10715 EOF
10716
10717 else
10718   echo "$ac_t""no" 1>&6
10719 fi
10720 done
10721
10722   fi
10723
10724
10725   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
10726 echo "configure:10727: checking for sincosl declaration" >&5
10727   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
10728   echo $ac_n "(cached) $ac_c" 1>&6
10729 else
10730
10731
10732     ac_ext=C
10733 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10734 ac_cpp='$CXXCPP $CPPFLAGS'
10735 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10736 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10737 cross_compiling=$ac_cv_prog_cxx_cross
10738
10739     cat > conftest.$ac_ext <<EOF
10740 #line 10741 "configure"
10741 #include "confdefs.h"
10742 #include <math.h>
10743 int main() {
10744  sincosl(0, 0, 0);
10745 ; return 0; }
10746 EOF
10747 if { (eval echo configure:10748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10748   rm -rf conftest*
10749   glibcpp_cv_func_sincosl_use=yes
10750 else
10751   echo "configure: failed program was:" >&5
10752   cat conftest.$ac_ext >&5
10753   rm -rf conftest*
10754   glibcpp_cv_func_sincosl_use=no
10755 fi
10756 rm -f conftest*
10757     ac_ext=c
10758 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10759 ac_cpp='$CPP $CPPFLAGS'
10760 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10761 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10762 cross_compiling=$ac_cv_prog_cc_cross
10763
10764
10765 fi
10766
10767   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
10768   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
10769     for ac_func in sincosl
10770 do
10771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10772 echo "configure:10773: checking for $ac_func" >&5
10773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10774   echo $ac_n "(cached) $ac_c" 1>&6
10775 else
10776   cat > conftest.$ac_ext <<EOF
10777 #line 10778 "configure"
10778 #include "confdefs.h"
10779 /* System header to define __stub macros and hopefully few prototypes,
10780     which can conflict with char $ac_func(); below.  */
10781 #include <assert.h>
10782 /* Override any gcc2 internal prototype to avoid an error.  */
10783 /* We use char because int might match the return type of a gcc2
10784     builtin and then its argument prototype would still apply.  */
10785 char $ac_func();
10786
10787 int main() {
10788
10789 /* The GNU C library defines this for functions which it implements
10790     to always fail with ENOSYS.  Some functions are actually named
10791     something starting with __ and the normal name is an alias.  */
10792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10793 choke me
10794 #else
10795 $ac_func();
10796 #endif
10797
10798 ; return 0; }
10799 EOF
10800 if { (eval echo configure:10801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10801   rm -rf conftest*
10802   eval "ac_cv_func_$ac_func=yes"
10803 else
10804   echo "configure: failed program was:" >&5
10805   cat conftest.$ac_ext >&5
10806   rm -rf conftest*
10807   eval "ac_cv_func_$ac_func=no"
10808 fi
10809 rm -f conftest*
10810 fi
10811
10812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10813   echo "$ac_t""yes" 1>&6
10814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10815   cat >> confdefs.h <<EOF
10816 #define $ac_tr_func 1
10817 EOF
10818
10819 else
10820   echo "$ac_t""no" 1>&6
10821 fi
10822 done
10823
10824   fi
10825
10826
10827   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10828 echo "configure:10829: checking for finitel declaration" >&5
10829   if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
10830   echo $ac_n "(cached) $ac_c" 1>&6
10831 else
10832
10833
10834     ac_ext=C
10835 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10836 ac_cpp='$CXXCPP $CPPFLAGS'
10837 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10838 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10839 cross_compiling=$ac_cv_prog_cxx_cross
10840
10841     cat > conftest.$ac_ext <<EOF
10842 #line 10843 "configure"
10843 #include "confdefs.h"
10844 #include <math.h>
10845 int main() {
10846  finitel(0);
10847 ; return 0; }
10848 EOF
10849 if { (eval echo configure:10850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10850   rm -rf conftest*
10851   glibcpp_cv_func_finitel_use=yes
10852 else
10853   echo "configure: failed program was:" >&5
10854   cat conftest.$ac_ext >&5
10855   rm -rf conftest*
10856   glibcpp_cv_func_finitel_use=no
10857 fi
10858 rm -f conftest*
10859     ac_ext=c
10860 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10861 ac_cpp='$CPP $CPPFLAGS'
10862 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10863 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10864 cross_compiling=$ac_cv_prog_cc_cross
10865
10866
10867 fi
10868
10869   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
10870   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
10871     for ac_func in finitel
10872 do
10873 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10874 echo "configure:10875: checking for $ac_func" >&5
10875 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10876   echo $ac_n "(cached) $ac_c" 1>&6
10877 else
10878   cat > conftest.$ac_ext <<EOF
10879 #line 10880 "configure"
10880 #include "confdefs.h"
10881 /* System header to define __stub macros and hopefully few prototypes,
10882     which can conflict with char $ac_func(); below.  */
10883 #include <assert.h>
10884 /* Override any gcc2 internal prototype to avoid an error.  */
10885 /* We use char because int might match the return type of a gcc2
10886     builtin and then its argument prototype would still apply.  */
10887 char $ac_func();
10888
10889 int main() {
10890
10891 /* The GNU C library defines this for functions which it implements
10892     to always fail with ENOSYS.  Some functions are actually named
10893     something starting with __ and the normal name is an alias.  */
10894 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10895 choke me
10896 #else
10897 $ac_func();
10898 #endif
10899
10900 ; return 0; }
10901 EOF
10902 if { (eval echo configure:10903: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10903   rm -rf conftest*
10904   eval "ac_cv_func_$ac_func=yes"
10905 else
10906   echo "configure: failed program was:" >&5
10907   cat conftest.$ac_ext >&5
10908   rm -rf conftest*
10909   eval "ac_cv_func_$ac_func=no"
10910 fi
10911 rm -f conftest*
10912 fi
10913
10914 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10915   echo "$ac_t""yes" 1>&6
10916     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10917   cat >> confdefs.h <<EOF
10918 #define $ac_tr_func 1
10919 EOF
10920
10921 else
10922   echo "$ac_t""no" 1>&6
10923 fi
10924 done
10925
10926   fi
10927
10928
10929
10930   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
10931 echo "configure:10932: checking for _isinf declaration" >&5
10932   if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
10933   echo $ac_n "(cached) $ac_c" 1>&6
10934 else
10935
10936
10937     ac_ext=C
10938 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10939 ac_cpp='$CXXCPP $CPPFLAGS'
10940 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10941 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10942 cross_compiling=$ac_cv_prog_cxx_cross
10943
10944     cat > conftest.$ac_ext <<EOF
10945 #line 10946 "configure"
10946 #include "confdefs.h"
10947 #include <math.h>
10948 int main() {
10949  _isinf(0);
10950 ; return 0; }
10951 EOF
10952 if { (eval echo configure:10953: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10953   rm -rf conftest*
10954   glibcpp_cv_func__isinf_use=yes
10955 else
10956   echo "configure: failed program was:" >&5
10957   cat conftest.$ac_ext >&5
10958   rm -rf conftest*
10959   glibcpp_cv_func__isinf_use=no
10960 fi
10961 rm -f conftest*
10962     ac_ext=c
10963 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10964 ac_cpp='$CPP $CPPFLAGS'
10965 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10966 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10967 cross_compiling=$ac_cv_prog_cc_cross
10968
10969
10970 fi
10971
10972   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
10973   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
10974     for ac_func in _isinf
10975 do
10976 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10977 echo "configure:10978: checking for $ac_func" >&5
10978 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10979   echo $ac_n "(cached) $ac_c" 1>&6
10980 else
10981   cat > conftest.$ac_ext <<EOF
10982 #line 10983 "configure"
10983 #include "confdefs.h"
10984 /* System header to define __stub macros and hopefully few prototypes,
10985     which can conflict with char $ac_func(); below.  */
10986 #include <assert.h>
10987 /* Override any gcc2 internal prototype to avoid an error.  */
10988 /* We use char because int might match the return type of a gcc2
10989     builtin and then its argument prototype would still apply.  */
10990 char $ac_func();
10991
10992 int main() {
10993
10994 /* The GNU C library defines this for functions which it implements
10995     to always fail with ENOSYS.  Some functions are actually named
10996     something starting with __ and the normal name is an alias.  */
10997 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10998 choke me
10999 #else
11000 $ac_func();
11001 #endif
11002
11003 ; return 0; }
11004 EOF
11005 if { (eval echo configure:11006: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11006   rm -rf conftest*
11007   eval "ac_cv_func_$ac_func=yes"
11008 else
11009   echo "configure: failed program was:" >&5
11010   cat conftest.$ac_ext >&5
11011   rm -rf conftest*
11012   eval "ac_cv_func_$ac_func=no"
11013 fi
11014 rm -f conftest*
11015 fi
11016
11017 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11018   echo "$ac_t""yes" 1>&6
11019     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11020   cat >> confdefs.h <<EOF
11021 #define $ac_tr_func 1
11022 EOF
11023
11024 else
11025   echo "$ac_t""no" 1>&6
11026 fi
11027 done
11028
11029   fi
11030
11031
11032   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
11033 echo "configure:11034: checking for _isnan declaration" >&5
11034   if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
11035   echo $ac_n "(cached) $ac_c" 1>&6
11036 else
11037
11038
11039     ac_ext=C
11040 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11041 ac_cpp='$CXXCPP $CPPFLAGS'
11042 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11043 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11044 cross_compiling=$ac_cv_prog_cxx_cross
11045
11046     cat > conftest.$ac_ext <<EOF
11047 #line 11048 "configure"
11048 #include "confdefs.h"
11049 #include <math.h>
11050 int main() {
11051  _isnan(0);
11052 ; return 0; }
11053 EOF
11054 if { (eval echo configure:11055: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11055   rm -rf conftest*
11056   glibcpp_cv_func__isnan_use=yes
11057 else
11058   echo "configure: failed program was:" >&5
11059   cat conftest.$ac_ext >&5
11060   rm -rf conftest*
11061   glibcpp_cv_func__isnan_use=no
11062 fi
11063 rm -f conftest*
11064     ac_ext=c
11065 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11066 ac_cpp='$CPP $CPPFLAGS'
11067 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11068 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11069 cross_compiling=$ac_cv_prog_cc_cross
11070
11071
11072 fi
11073
11074   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
11075   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
11076     for ac_func in _isnan
11077 do
11078 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11079 echo "configure:11080: checking for $ac_func" >&5
11080 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11081   echo $ac_n "(cached) $ac_c" 1>&6
11082 else
11083   cat > conftest.$ac_ext <<EOF
11084 #line 11085 "configure"
11085 #include "confdefs.h"
11086 /* System header to define __stub macros and hopefully few prototypes,
11087     which can conflict with char $ac_func(); below.  */
11088 #include <assert.h>
11089 /* Override any gcc2 internal prototype to avoid an error.  */
11090 /* We use char because int might match the return type of a gcc2
11091     builtin and then its argument prototype would still apply.  */
11092 char $ac_func();
11093
11094 int main() {
11095
11096 /* The GNU C library defines this for functions which it implements
11097     to always fail with ENOSYS.  Some functions are actually named
11098     something starting with __ and the normal name is an alias.  */
11099 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11100 choke me
11101 #else
11102 $ac_func();
11103 #endif
11104
11105 ; return 0; }
11106 EOF
11107 if { (eval echo configure:11108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11108   rm -rf conftest*
11109   eval "ac_cv_func_$ac_func=yes"
11110 else
11111   echo "configure: failed program was:" >&5
11112   cat conftest.$ac_ext >&5
11113   rm -rf conftest*
11114   eval "ac_cv_func_$ac_func=no"
11115 fi
11116 rm -f conftest*
11117 fi
11118
11119 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11120   echo "$ac_t""yes" 1>&6
11121     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11122   cat >> confdefs.h <<EOF
11123 #define $ac_tr_func 1
11124 EOF
11125
11126 else
11127   echo "$ac_t""no" 1>&6
11128 fi
11129 done
11130
11131   fi
11132
11133
11134   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
11135 echo "configure:11136: checking for _finite declaration" >&5
11136   if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
11137   echo $ac_n "(cached) $ac_c" 1>&6
11138 else
11139
11140
11141     ac_ext=C
11142 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11143 ac_cpp='$CXXCPP $CPPFLAGS'
11144 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11145 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11146 cross_compiling=$ac_cv_prog_cxx_cross
11147
11148     cat > conftest.$ac_ext <<EOF
11149 #line 11150 "configure"
11150 #include "confdefs.h"
11151 #include <math.h>
11152 int main() {
11153  _finite(0);
11154 ; return 0; }
11155 EOF
11156 if { (eval echo configure:11157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11157   rm -rf conftest*
11158   glibcpp_cv_func__finite_use=yes
11159 else
11160   echo "configure: failed program was:" >&5
11161   cat conftest.$ac_ext >&5
11162   rm -rf conftest*
11163   glibcpp_cv_func__finite_use=no
11164 fi
11165 rm -f conftest*
11166     ac_ext=c
11167 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11168 ac_cpp='$CPP $CPPFLAGS'
11169 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11170 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11171 cross_compiling=$ac_cv_prog_cc_cross
11172
11173
11174 fi
11175
11176   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
11177   if test x$glibcpp_cv_func__finite_use = x"yes"; then
11178     for ac_func in _finite
11179 do
11180 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11181 echo "configure:11182: checking for $ac_func" >&5
11182 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11183   echo $ac_n "(cached) $ac_c" 1>&6
11184 else
11185   cat > conftest.$ac_ext <<EOF
11186 #line 11187 "configure"
11187 #include "confdefs.h"
11188 /* System header to define __stub macros and hopefully few prototypes,
11189     which can conflict with char $ac_func(); below.  */
11190 #include <assert.h>
11191 /* Override any gcc2 internal prototype to avoid an error.  */
11192 /* We use char because int might match the return type of a gcc2
11193     builtin and then its argument prototype would still apply.  */
11194 char $ac_func();
11195
11196 int main() {
11197
11198 /* The GNU C library defines this for functions which it implements
11199     to always fail with ENOSYS.  Some functions are actually named
11200     something starting with __ and the normal name is an alias.  */
11201 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11202 choke me
11203 #else
11204 $ac_func();
11205 #endif
11206
11207 ; return 0; }
11208 EOF
11209 if { (eval echo configure:11210: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11210   rm -rf conftest*
11211   eval "ac_cv_func_$ac_func=yes"
11212 else
11213   echo "configure: failed program was:" >&5
11214   cat conftest.$ac_ext >&5
11215   rm -rf conftest*
11216   eval "ac_cv_func_$ac_func=no"
11217 fi
11218 rm -f conftest*
11219 fi
11220
11221 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11222   echo "$ac_t""yes" 1>&6
11223     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11224   cat >> confdefs.h <<EOF
11225 #define $ac_tr_func 1
11226 EOF
11227
11228 else
11229   echo "$ac_t""no" 1>&6
11230 fi
11231 done
11232
11233   fi
11234
11235
11236   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
11237 echo "configure:11238: checking for _copysign declaration" >&5
11238   if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
11239   echo $ac_n "(cached) $ac_c" 1>&6
11240 else
11241
11242
11243     ac_ext=C
11244 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11245 ac_cpp='$CXXCPP $CPPFLAGS'
11246 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11247 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11248 cross_compiling=$ac_cv_prog_cxx_cross
11249
11250     cat > conftest.$ac_ext <<EOF
11251 #line 11252 "configure"
11252 #include "confdefs.h"
11253 #include <math.h>
11254 int main() {
11255  _copysign(0, 0);
11256 ; return 0; }
11257 EOF
11258 if { (eval echo configure:11259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11259   rm -rf conftest*
11260   glibcpp_cv_func__copysign_use=yes
11261 else
11262   echo "configure: failed program was:" >&5
11263   cat conftest.$ac_ext >&5
11264   rm -rf conftest*
11265   glibcpp_cv_func__copysign_use=no
11266 fi
11267 rm -f conftest*
11268     ac_ext=c
11269 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11270 ac_cpp='$CPP $CPPFLAGS'
11271 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11272 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11273 cross_compiling=$ac_cv_prog_cc_cross
11274
11275
11276 fi
11277
11278   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
11279   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
11280     for ac_func in _copysign
11281 do
11282 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11283 echo "configure:11284: checking for $ac_func" >&5
11284 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11285   echo $ac_n "(cached) $ac_c" 1>&6
11286 else
11287   cat > conftest.$ac_ext <<EOF
11288 #line 11289 "configure"
11289 #include "confdefs.h"
11290 /* System header to define __stub macros and hopefully few prototypes,
11291     which can conflict with char $ac_func(); below.  */
11292 #include <assert.h>
11293 /* Override any gcc2 internal prototype to avoid an error.  */
11294 /* We use char because int might match the return type of a gcc2
11295     builtin and then its argument prototype would still apply.  */
11296 char $ac_func();
11297
11298 int main() {
11299
11300 /* The GNU C library defines this for functions which it implements
11301     to always fail with ENOSYS.  Some functions are actually named
11302     something starting with __ and the normal name is an alias.  */
11303 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11304 choke me
11305 #else
11306 $ac_func();
11307 #endif
11308
11309 ; return 0; }
11310 EOF
11311 if { (eval echo configure:11312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11312   rm -rf conftest*
11313   eval "ac_cv_func_$ac_func=yes"
11314 else
11315   echo "configure: failed program was:" >&5
11316   cat conftest.$ac_ext >&5
11317   rm -rf conftest*
11318   eval "ac_cv_func_$ac_func=no"
11319 fi
11320 rm -f conftest*
11321 fi
11322
11323 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11324   echo "$ac_t""yes" 1>&6
11325     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11326   cat >> confdefs.h <<EOF
11327 #define $ac_tr_func 1
11328 EOF
11329
11330 else
11331   echo "$ac_t""no" 1>&6
11332 fi
11333 done
11334
11335   fi
11336
11337
11338   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
11339 echo "configure:11340: checking for _sincos declaration" >&5
11340   if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
11341   echo $ac_n "(cached) $ac_c" 1>&6
11342 else
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     cat > conftest.$ac_ext <<EOF
11353 #line 11354 "configure"
11354 #include "confdefs.h"
11355 #include <math.h>
11356 int main() {
11357  _sincos(0, 0, 0);
11358 ; return 0; }
11359 EOF
11360 if { (eval echo configure:11361: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11361   rm -rf conftest*
11362   glibcpp_cv_func__sincos_use=yes
11363 else
11364   echo "configure: failed program was:" >&5
11365   cat conftest.$ac_ext >&5
11366   rm -rf conftest*
11367   glibcpp_cv_func__sincos_use=no
11368 fi
11369 rm -f conftest*
11370     ac_ext=c
11371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11372 ac_cpp='$CPP $CPPFLAGS'
11373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11375 cross_compiling=$ac_cv_prog_cc_cross
11376
11377
11378 fi
11379
11380   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
11381   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
11382     for ac_func in _sincos
11383 do
11384 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11385 echo "configure:11386: checking for $ac_func" >&5
11386 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11387   echo $ac_n "(cached) $ac_c" 1>&6
11388 else
11389   cat > conftest.$ac_ext <<EOF
11390 #line 11391 "configure"
11391 #include "confdefs.h"
11392 /* System header to define __stub macros and hopefully few prototypes,
11393     which can conflict with char $ac_func(); below.  */
11394 #include <assert.h>
11395 /* Override any gcc2 internal prototype to avoid an error.  */
11396 /* We use char because int might match the return type of a gcc2
11397     builtin and then its argument prototype would still apply.  */
11398 char $ac_func();
11399
11400 int main() {
11401
11402 /* The GNU C library defines this for functions which it implements
11403     to always fail with ENOSYS.  Some functions are actually named
11404     something starting with __ and the normal name is an alias.  */
11405 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11406 choke me
11407 #else
11408 $ac_func();
11409 #endif
11410
11411 ; return 0; }
11412 EOF
11413 if { (eval echo configure:11414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11414   rm -rf conftest*
11415   eval "ac_cv_func_$ac_func=yes"
11416 else
11417   echo "configure: failed program was:" >&5
11418   cat conftest.$ac_ext >&5
11419   rm -rf conftest*
11420   eval "ac_cv_func_$ac_func=no"
11421 fi
11422 rm -f conftest*
11423 fi
11424
11425 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11426   echo "$ac_t""yes" 1>&6
11427     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11428   cat >> confdefs.h <<EOF
11429 #define $ac_tr_func 1
11430 EOF
11431
11432 else
11433   echo "$ac_t""no" 1>&6
11434 fi
11435 done
11436
11437   fi
11438
11439
11440   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
11441 echo "configure:11442: checking for _fpclass declaration" >&5
11442   if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
11443   echo $ac_n "(cached) $ac_c" 1>&6
11444 else
11445
11446
11447     ac_ext=C
11448 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11449 ac_cpp='$CXXCPP $CPPFLAGS'
11450 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11451 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11452 cross_compiling=$ac_cv_prog_cxx_cross
11453
11454     cat > conftest.$ac_ext <<EOF
11455 #line 11456 "configure"
11456 #include "confdefs.h"
11457 #include <math.h>
11458 int main() {
11459  _fpclass(0);
11460 ; return 0; }
11461 EOF
11462 if { (eval echo configure:11463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11463   rm -rf conftest*
11464   glibcpp_cv_func__fpclass_use=yes
11465 else
11466   echo "configure: failed program was:" >&5
11467   cat conftest.$ac_ext >&5
11468   rm -rf conftest*
11469   glibcpp_cv_func__fpclass_use=no
11470 fi
11471 rm -f conftest*
11472     ac_ext=c
11473 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11474 ac_cpp='$CPP $CPPFLAGS'
11475 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11476 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11477 cross_compiling=$ac_cv_prog_cc_cross
11478
11479
11480 fi
11481
11482   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
11483   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
11484     for ac_func in _fpclass
11485 do
11486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11487 echo "configure:11488: checking for $ac_func" >&5
11488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11489   echo $ac_n "(cached) $ac_c" 1>&6
11490 else
11491   cat > conftest.$ac_ext <<EOF
11492 #line 11493 "configure"
11493 #include "confdefs.h"
11494 /* System header to define __stub macros and hopefully few prototypes,
11495     which can conflict with char $ac_func(); below.  */
11496 #include <assert.h>
11497 /* Override any gcc2 internal prototype to avoid an error.  */
11498 /* We use char because int might match the return type of a gcc2
11499     builtin and then its argument prototype would still apply.  */
11500 char $ac_func();
11501
11502 int main() {
11503
11504 /* The GNU C library defines this for functions which it implements
11505     to always fail with ENOSYS.  Some functions are actually named
11506     something starting with __ and the normal name is an alias.  */
11507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11508 choke me
11509 #else
11510 $ac_func();
11511 #endif
11512
11513 ; return 0; }
11514 EOF
11515 if { (eval echo configure:11516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11516   rm -rf conftest*
11517   eval "ac_cv_func_$ac_func=yes"
11518 else
11519   echo "configure: failed program was:" >&5
11520   cat conftest.$ac_ext >&5
11521   rm -rf conftest*
11522   eval "ac_cv_func_$ac_func=no"
11523 fi
11524 rm -f conftest*
11525 fi
11526
11527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11528   echo "$ac_t""yes" 1>&6
11529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11530   cat >> confdefs.h <<EOF
11531 #define $ac_tr_func 1
11532 EOF
11533
11534 else
11535   echo "$ac_t""no" 1>&6
11536 fi
11537 done
11538
11539   fi
11540
11541
11542   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
11543 echo "configure:11544: checking for _qfpclass declaration" >&5
11544   if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
11545   echo $ac_n "(cached) $ac_c" 1>&6
11546 else
11547
11548
11549     ac_ext=C
11550 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11551 ac_cpp='$CXXCPP $CPPFLAGS'
11552 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11553 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11554 cross_compiling=$ac_cv_prog_cxx_cross
11555
11556     cat > conftest.$ac_ext <<EOF
11557 #line 11558 "configure"
11558 #include "confdefs.h"
11559 #include <math.h>
11560 int main() {
11561  _qfpclass(0);
11562 ; return 0; }
11563 EOF
11564 if { (eval echo configure:11565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11565   rm -rf conftest*
11566   glibcpp_cv_func__qfpclass_use=yes
11567 else
11568   echo "configure: failed program was:" >&5
11569   cat conftest.$ac_ext >&5
11570   rm -rf conftest*
11571   glibcpp_cv_func__qfpclass_use=no
11572 fi
11573 rm -f conftest*
11574     ac_ext=c
11575 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11576 ac_cpp='$CPP $CPPFLAGS'
11577 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11578 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11579 cross_compiling=$ac_cv_prog_cc_cross
11580
11581
11582 fi
11583
11584   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
11585   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
11586     for ac_func in _qfpclass
11587 do
11588 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11589 echo "configure:11590: checking for $ac_func" >&5
11590 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11591   echo $ac_n "(cached) $ac_c" 1>&6
11592 else
11593   cat > conftest.$ac_ext <<EOF
11594 #line 11595 "configure"
11595 #include "confdefs.h"
11596 /* System header to define __stub macros and hopefully few prototypes,
11597     which can conflict with char $ac_func(); below.  */
11598 #include <assert.h>
11599 /* Override any gcc2 internal prototype to avoid an error.  */
11600 /* We use char because int might match the return type of a gcc2
11601     builtin and then its argument prototype would still apply.  */
11602 char $ac_func();
11603
11604 int main() {
11605
11606 /* The GNU C library defines this for functions which it implements
11607     to always fail with ENOSYS.  Some functions are actually named
11608     something starting with __ and the normal name is an alias.  */
11609 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11610 choke me
11611 #else
11612 $ac_func();
11613 #endif
11614
11615 ; return 0; }
11616 EOF
11617 if { (eval echo configure:11618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11618   rm -rf conftest*
11619   eval "ac_cv_func_$ac_func=yes"
11620 else
11621   echo "configure: failed program was:" >&5
11622   cat conftest.$ac_ext >&5
11623   rm -rf conftest*
11624   eval "ac_cv_func_$ac_func=no"
11625 fi
11626 rm -f conftest*
11627 fi
11628
11629 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11630   echo "$ac_t""yes" 1>&6
11631     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11632   cat >> confdefs.h <<EOF
11633 #define $ac_tr_func 1
11634 EOF
11635
11636 else
11637   echo "$ac_t""no" 1>&6
11638 fi
11639 done
11640
11641   fi
11642
11643
11644
11645   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11646 echo "configure:11647: checking for _isnanf declaration" >&5
11647   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
11648   echo $ac_n "(cached) $ac_c" 1>&6
11649 else
11650
11651
11652     ac_ext=C
11653 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11654 ac_cpp='$CXXCPP $CPPFLAGS'
11655 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11656 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11657 cross_compiling=$ac_cv_prog_cxx_cross
11658
11659     cat > conftest.$ac_ext <<EOF
11660 #line 11661 "configure"
11661 #include "confdefs.h"
11662 #include <math.h>
11663 int main() {
11664  _isnanf(0);
11665 ; return 0; }
11666 EOF
11667 if { (eval echo configure:11668: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11668   rm -rf conftest*
11669   glibcpp_cv_func__isnanf_use=yes
11670 else
11671   echo "configure: failed program was:" >&5
11672   cat conftest.$ac_ext >&5
11673   rm -rf conftest*
11674   glibcpp_cv_func__isnanf_use=no
11675 fi
11676 rm -f conftest*
11677     ac_ext=c
11678 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11679 ac_cpp='$CPP $CPPFLAGS'
11680 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11681 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11682 cross_compiling=$ac_cv_prog_cc_cross
11683
11684
11685 fi
11686
11687   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
11688   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
11689     for ac_func in _isnanf
11690 do
11691 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11692 echo "configure:11693: checking for $ac_func" >&5
11693 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11694   echo $ac_n "(cached) $ac_c" 1>&6
11695 else
11696   cat > conftest.$ac_ext <<EOF
11697 #line 11698 "configure"
11698 #include "confdefs.h"
11699 /* System header to define __stub macros and hopefully few prototypes,
11700     which can conflict with char $ac_func(); below.  */
11701 #include <assert.h>
11702 /* Override any gcc2 internal prototype to avoid an error.  */
11703 /* We use char because int might match the return type of a gcc2
11704     builtin and then its argument prototype would still apply.  */
11705 char $ac_func();
11706
11707 int main() {
11708
11709 /* The GNU C library defines this for functions which it implements
11710     to always fail with ENOSYS.  Some functions are actually named
11711     something starting with __ and the normal name is an alias.  */
11712 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11713 choke me
11714 #else
11715 $ac_func();
11716 #endif
11717
11718 ; return 0; }
11719 EOF
11720 if { (eval echo configure:11721: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11721   rm -rf conftest*
11722   eval "ac_cv_func_$ac_func=yes"
11723 else
11724   echo "configure: failed program was:" >&5
11725   cat conftest.$ac_ext >&5
11726   rm -rf conftest*
11727   eval "ac_cv_func_$ac_func=no"
11728 fi
11729 rm -f conftest*
11730 fi
11731
11732 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11733   echo "$ac_t""yes" 1>&6
11734     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11735   cat >> confdefs.h <<EOF
11736 #define $ac_tr_func 1
11737 EOF
11738
11739 else
11740   echo "$ac_t""no" 1>&6
11741 fi
11742 done
11743
11744   fi
11745
11746
11747   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11748 echo "configure:11749: checking for _isinff declaration" >&5
11749   if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
11750   echo $ac_n "(cached) $ac_c" 1>&6
11751 else
11752
11753
11754     ac_ext=C
11755 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11756 ac_cpp='$CXXCPP $CPPFLAGS'
11757 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11758 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11759 cross_compiling=$ac_cv_prog_cxx_cross
11760
11761     cat > conftest.$ac_ext <<EOF
11762 #line 11763 "configure"
11763 #include "confdefs.h"
11764 #include <math.h>
11765 int main() {
11766  _isinff(0);
11767 ; return 0; }
11768 EOF
11769 if { (eval echo configure:11770: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11770   rm -rf conftest*
11771   glibcpp_cv_func__isinff_use=yes
11772 else
11773   echo "configure: failed program was:" >&5
11774   cat conftest.$ac_ext >&5
11775   rm -rf conftest*
11776   glibcpp_cv_func__isinff_use=no
11777 fi
11778 rm -f conftest*
11779     ac_ext=c
11780 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11781 ac_cpp='$CPP $CPPFLAGS'
11782 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11783 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11784 cross_compiling=$ac_cv_prog_cc_cross
11785
11786
11787 fi
11788
11789   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
11790   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
11791     for ac_func in _isinff
11792 do
11793 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11794 echo "configure:11795: checking for $ac_func" >&5
11795 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11796   echo $ac_n "(cached) $ac_c" 1>&6
11797 else
11798   cat > conftest.$ac_ext <<EOF
11799 #line 11800 "configure"
11800 #include "confdefs.h"
11801 /* System header to define __stub macros and hopefully few prototypes,
11802     which can conflict with char $ac_func(); below.  */
11803 #include <assert.h>
11804 /* Override any gcc2 internal prototype to avoid an error.  */
11805 /* We use char because int might match the return type of a gcc2
11806     builtin and then its argument prototype would still apply.  */
11807 char $ac_func();
11808
11809 int main() {
11810
11811 /* The GNU C library defines this for functions which it implements
11812     to always fail with ENOSYS.  Some functions are actually named
11813     something starting with __ and the normal name is an alias.  */
11814 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11815 choke me
11816 #else
11817 $ac_func();
11818 #endif
11819
11820 ; return 0; }
11821 EOF
11822 if { (eval echo configure:11823: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11823   rm -rf conftest*
11824   eval "ac_cv_func_$ac_func=yes"
11825 else
11826   echo "configure: failed program was:" >&5
11827   cat conftest.$ac_ext >&5
11828   rm -rf conftest*
11829   eval "ac_cv_func_$ac_func=no"
11830 fi
11831 rm -f conftest*
11832 fi
11833
11834 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11835   echo "$ac_t""yes" 1>&6
11836     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11837   cat >> confdefs.h <<EOF
11838 #define $ac_tr_func 1
11839 EOF
11840
11841 else
11842   echo "$ac_t""no" 1>&6
11843 fi
11844 done
11845
11846   fi
11847
11848
11849   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11850 echo "configure:11851: checking for _acosf declaration" >&5
11851   if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
11852   echo $ac_n "(cached) $ac_c" 1>&6
11853 else
11854
11855
11856     ac_ext=C
11857 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11858 ac_cpp='$CXXCPP $CPPFLAGS'
11859 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11860 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11861 cross_compiling=$ac_cv_prog_cxx_cross
11862
11863     cat > conftest.$ac_ext <<EOF
11864 #line 11865 "configure"
11865 #include "confdefs.h"
11866 #include <math.h>
11867 int main() {
11868  _acosf(0);
11869 ; return 0; }
11870 EOF
11871 if { (eval echo configure:11872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11872   rm -rf conftest*
11873   glibcpp_cv_func__acosf_use=yes
11874 else
11875   echo "configure: failed program was:" >&5
11876   cat conftest.$ac_ext >&5
11877   rm -rf conftest*
11878   glibcpp_cv_func__acosf_use=no
11879 fi
11880 rm -f conftest*
11881     ac_ext=c
11882 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11883 ac_cpp='$CPP $CPPFLAGS'
11884 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11885 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11886 cross_compiling=$ac_cv_prog_cc_cross
11887
11888
11889 fi
11890
11891   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
11892   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
11893     for ac_func in _acosf
11894 do
11895 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11896 echo "configure:11897: checking for $ac_func" >&5
11897 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11898   echo $ac_n "(cached) $ac_c" 1>&6
11899 else
11900   cat > conftest.$ac_ext <<EOF
11901 #line 11902 "configure"
11902 #include "confdefs.h"
11903 /* System header to define __stub macros and hopefully few prototypes,
11904     which can conflict with char $ac_func(); below.  */
11905 #include <assert.h>
11906 /* Override any gcc2 internal prototype to avoid an error.  */
11907 /* We use char because int might match the return type of a gcc2
11908     builtin and then its argument prototype would still apply.  */
11909 char $ac_func();
11910
11911 int main() {
11912
11913 /* The GNU C library defines this for functions which it implements
11914     to always fail with ENOSYS.  Some functions are actually named
11915     something starting with __ and the normal name is an alias.  */
11916 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11917 choke me
11918 #else
11919 $ac_func();
11920 #endif
11921
11922 ; return 0; }
11923 EOF
11924 if { (eval echo configure:11925: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11925   rm -rf conftest*
11926   eval "ac_cv_func_$ac_func=yes"
11927 else
11928   echo "configure: failed program was:" >&5
11929   cat conftest.$ac_ext >&5
11930   rm -rf conftest*
11931   eval "ac_cv_func_$ac_func=no"
11932 fi
11933 rm -f conftest*
11934 fi
11935
11936 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11937   echo "$ac_t""yes" 1>&6
11938     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11939   cat >> confdefs.h <<EOF
11940 #define $ac_tr_func 1
11941 EOF
11942
11943 else
11944   echo "$ac_t""no" 1>&6
11945 fi
11946 done
11947
11948   fi
11949
11950
11951   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11952 echo "configure:11953: checking for _asinf declaration" >&5
11953   if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
11954   echo $ac_n "(cached) $ac_c" 1>&6
11955 else
11956
11957
11958     ac_ext=C
11959 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11960 ac_cpp='$CXXCPP $CPPFLAGS'
11961 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11962 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11963 cross_compiling=$ac_cv_prog_cxx_cross
11964
11965     cat > conftest.$ac_ext <<EOF
11966 #line 11967 "configure"
11967 #include "confdefs.h"
11968 #include <math.h>
11969 int main() {
11970  _asinf(0);
11971 ; return 0; }
11972 EOF
11973 if { (eval echo configure:11974: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11974   rm -rf conftest*
11975   glibcpp_cv_func__asinf_use=yes
11976 else
11977   echo "configure: failed program was:" >&5
11978   cat conftest.$ac_ext >&5
11979   rm -rf conftest*
11980   glibcpp_cv_func__asinf_use=no
11981 fi
11982 rm -f conftest*
11983     ac_ext=c
11984 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11985 ac_cpp='$CPP $CPPFLAGS'
11986 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11987 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11988 cross_compiling=$ac_cv_prog_cc_cross
11989
11990
11991 fi
11992
11993   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
11994   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
11995     for ac_func in _asinf
11996 do
11997 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11998 echo "configure:11999: checking for $ac_func" >&5
11999 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12000   echo $ac_n "(cached) $ac_c" 1>&6
12001 else
12002   cat > conftest.$ac_ext <<EOF
12003 #line 12004 "configure"
12004 #include "confdefs.h"
12005 /* System header to define __stub macros and hopefully few prototypes,
12006     which can conflict with char $ac_func(); below.  */
12007 #include <assert.h>
12008 /* Override any gcc2 internal prototype to avoid an error.  */
12009 /* We use char because int might match the return type of a gcc2
12010     builtin and then its argument prototype would still apply.  */
12011 char $ac_func();
12012
12013 int main() {
12014
12015 /* The GNU C library defines this for functions which it implements
12016     to always fail with ENOSYS.  Some functions are actually named
12017     something starting with __ and the normal name is an alias.  */
12018 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12019 choke me
12020 #else
12021 $ac_func();
12022 #endif
12023
12024 ; return 0; }
12025 EOF
12026 if { (eval echo configure:12027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12027   rm -rf conftest*
12028   eval "ac_cv_func_$ac_func=yes"
12029 else
12030   echo "configure: failed program was:" >&5
12031   cat conftest.$ac_ext >&5
12032   rm -rf conftest*
12033   eval "ac_cv_func_$ac_func=no"
12034 fi
12035 rm -f conftest*
12036 fi
12037
12038 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12039   echo "$ac_t""yes" 1>&6
12040     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12041   cat >> confdefs.h <<EOF
12042 #define $ac_tr_func 1
12043 EOF
12044
12045 else
12046   echo "$ac_t""no" 1>&6
12047 fi
12048 done
12049
12050   fi
12051
12052
12053   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
12054 echo "configure:12055: checking for _atanf declaration" >&5
12055   if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
12056   echo $ac_n "(cached) $ac_c" 1>&6
12057 else
12058
12059
12060     ac_ext=C
12061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12062 ac_cpp='$CXXCPP $CPPFLAGS'
12063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12065 cross_compiling=$ac_cv_prog_cxx_cross
12066
12067     cat > conftest.$ac_ext <<EOF
12068 #line 12069 "configure"
12069 #include "confdefs.h"
12070 #include <math.h>
12071 int main() {
12072  _atanf(0);
12073 ; return 0; }
12074 EOF
12075 if { (eval echo configure:12076: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12076   rm -rf conftest*
12077   glibcpp_cv_func__atanf_use=yes
12078 else
12079   echo "configure: failed program was:" >&5
12080   cat conftest.$ac_ext >&5
12081   rm -rf conftest*
12082   glibcpp_cv_func__atanf_use=no
12083 fi
12084 rm -f conftest*
12085     ac_ext=c
12086 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12087 ac_cpp='$CPP $CPPFLAGS'
12088 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12089 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12090 cross_compiling=$ac_cv_prog_cc_cross
12091
12092
12093 fi
12094
12095   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
12096   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
12097     for ac_func in _atanf
12098 do
12099 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12100 echo "configure:12101: checking for $ac_func" >&5
12101 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12102   echo $ac_n "(cached) $ac_c" 1>&6
12103 else
12104   cat > conftest.$ac_ext <<EOF
12105 #line 12106 "configure"
12106 #include "confdefs.h"
12107 /* System header to define __stub macros and hopefully few prototypes,
12108     which can conflict with char $ac_func(); below.  */
12109 #include <assert.h>
12110 /* Override any gcc2 internal prototype to avoid an error.  */
12111 /* We use char because int might match the return type of a gcc2
12112     builtin and then its argument prototype would still apply.  */
12113 char $ac_func();
12114
12115 int main() {
12116
12117 /* The GNU C library defines this for functions which it implements
12118     to always fail with ENOSYS.  Some functions are actually named
12119     something starting with __ and the normal name is an alias.  */
12120 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12121 choke me
12122 #else
12123 $ac_func();
12124 #endif
12125
12126 ; return 0; }
12127 EOF
12128 if { (eval echo configure:12129: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12129   rm -rf conftest*
12130   eval "ac_cv_func_$ac_func=yes"
12131 else
12132   echo "configure: failed program was:" >&5
12133   cat conftest.$ac_ext >&5
12134   rm -rf conftest*
12135   eval "ac_cv_func_$ac_func=no"
12136 fi
12137 rm -f conftest*
12138 fi
12139
12140 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12141   echo "$ac_t""yes" 1>&6
12142     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12143   cat >> confdefs.h <<EOF
12144 #define $ac_tr_func 1
12145 EOF
12146
12147 else
12148   echo "$ac_t""no" 1>&6
12149 fi
12150 done
12151
12152   fi
12153
12154
12155   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
12156 echo "configure:12157: checking for _atan2f declaration" >&5
12157   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
12158   echo $ac_n "(cached) $ac_c" 1>&6
12159 else
12160
12161
12162     ac_ext=C
12163 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12164 ac_cpp='$CXXCPP $CPPFLAGS'
12165 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12166 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12167 cross_compiling=$ac_cv_prog_cxx_cross
12168
12169     cat > conftest.$ac_ext <<EOF
12170 #line 12171 "configure"
12171 #include "confdefs.h"
12172 #include <math.h>
12173 int main() {
12174  _atan2f(0, 0);
12175 ; return 0; }
12176 EOF
12177 if { (eval echo configure:12178: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12178   rm -rf conftest*
12179   glibcpp_cv_func__atan2f_use=yes
12180 else
12181   echo "configure: failed program was:" >&5
12182   cat conftest.$ac_ext >&5
12183   rm -rf conftest*
12184   glibcpp_cv_func__atan2f_use=no
12185 fi
12186 rm -f conftest*
12187     ac_ext=c
12188 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12189 ac_cpp='$CPP $CPPFLAGS'
12190 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12191 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12192 cross_compiling=$ac_cv_prog_cc_cross
12193
12194
12195 fi
12196
12197   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
12198   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
12199     for ac_func in _atan2f
12200 do
12201 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12202 echo "configure:12203: checking for $ac_func" >&5
12203 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12204   echo $ac_n "(cached) $ac_c" 1>&6
12205 else
12206   cat > conftest.$ac_ext <<EOF
12207 #line 12208 "configure"
12208 #include "confdefs.h"
12209 /* System header to define __stub macros and hopefully few prototypes,
12210     which can conflict with char $ac_func(); below.  */
12211 #include <assert.h>
12212 /* Override any gcc2 internal prototype to avoid an error.  */
12213 /* We use char because int might match the return type of a gcc2
12214     builtin and then its argument prototype would still apply.  */
12215 char $ac_func();
12216
12217 int main() {
12218
12219 /* The GNU C library defines this for functions which it implements
12220     to always fail with ENOSYS.  Some functions are actually named
12221     something starting with __ and the normal name is an alias.  */
12222 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12223 choke me
12224 #else
12225 $ac_func();
12226 #endif
12227
12228 ; return 0; }
12229 EOF
12230 if { (eval echo configure:12231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12231   rm -rf conftest*
12232   eval "ac_cv_func_$ac_func=yes"
12233 else
12234   echo "configure: failed program was:" >&5
12235   cat conftest.$ac_ext >&5
12236   rm -rf conftest*
12237   eval "ac_cv_func_$ac_func=no"
12238 fi
12239 rm -f conftest*
12240 fi
12241
12242 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12243   echo "$ac_t""yes" 1>&6
12244     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12245   cat >> confdefs.h <<EOF
12246 #define $ac_tr_func 1
12247 EOF
12248
12249 else
12250   echo "$ac_t""no" 1>&6
12251 fi
12252 done
12253
12254   fi
12255
12256
12257   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
12258 echo "configure:12259: checking for _ceilf declaration" >&5
12259   if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
12260   echo $ac_n "(cached) $ac_c" 1>&6
12261 else
12262
12263
12264     ac_ext=C
12265 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12266 ac_cpp='$CXXCPP $CPPFLAGS'
12267 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12268 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12269 cross_compiling=$ac_cv_prog_cxx_cross
12270
12271     cat > conftest.$ac_ext <<EOF
12272 #line 12273 "configure"
12273 #include "confdefs.h"
12274 #include <math.h>
12275 int main() {
12276  _ceilf(0);
12277 ; return 0; }
12278 EOF
12279 if { (eval echo configure:12280: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12280   rm -rf conftest*
12281   glibcpp_cv_func__ceilf_use=yes
12282 else
12283   echo "configure: failed program was:" >&5
12284   cat conftest.$ac_ext >&5
12285   rm -rf conftest*
12286   glibcpp_cv_func__ceilf_use=no
12287 fi
12288 rm -f conftest*
12289     ac_ext=c
12290 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12291 ac_cpp='$CPP $CPPFLAGS'
12292 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12293 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12294 cross_compiling=$ac_cv_prog_cc_cross
12295
12296
12297 fi
12298
12299   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
12300   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
12301     for ac_func in _ceilf
12302 do
12303 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12304 echo "configure:12305: checking for $ac_func" >&5
12305 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12306   echo $ac_n "(cached) $ac_c" 1>&6
12307 else
12308   cat > conftest.$ac_ext <<EOF
12309 #line 12310 "configure"
12310 #include "confdefs.h"
12311 /* System header to define __stub macros and hopefully few prototypes,
12312     which can conflict with char $ac_func(); below.  */
12313 #include <assert.h>
12314 /* Override any gcc2 internal prototype to avoid an error.  */
12315 /* We use char because int might match the return type of a gcc2
12316     builtin and then its argument prototype would still apply.  */
12317 char $ac_func();
12318
12319 int main() {
12320
12321 /* The GNU C library defines this for functions which it implements
12322     to always fail with ENOSYS.  Some functions are actually named
12323     something starting with __ and the normal name is an alias.  */
12324 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12325 choke me
12326 #else
12327 $ac_func();
12328 #endif
12329
12330 ; return 0; }
12331 EOF
12332 if { (eval echo configure:12333: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12333   rm -rf conftest*
12334   eval "ac_cv_func_$ac_func=yes"
12335 else
12336   echo "configure: failed program was:" >&5
12337   cat conftest.$ac_ext >&5
12338   rm -rf conftest*
12339   eval "ac_cv_func_$ac_func=no"
12340 fi
12341 rm -f conftest*
12342 fi
12343
12344 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12345   echo "$ac_t""yes" 1>&6
12346     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12347   cat >> confdefs.h <<EOF
12348 #define $ac_tr_func 1
12349 EOF
12350
12351 else
12352   echo "$ac_t""no" 1>&6
12353 fi
12354 done
12355
12356   fi
12357
12358
12359   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
12360 echo "configure:12361: checking for _cosf declaration" >&5
12361   if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
12362   echo $ac_n "(cached) $ac_c" 1>&6
12363 else
12364
12365
12366     ac_ext=C
12367 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12368 ac_cpp='$CXXCPP $CPPFLAGS'
12369 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12370 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12371 cross_compiling=$ac_cv_prog_cxx_cross
12372
12373     cat > conftest.$ac_ext <<EOF
12374 #line 12375 "configure"
12375 #include "confdefs.h"
12376 #include <math.h>
12377 int main() {
12378  _cosf(0);
12379 ; return 0; }
12380 EOF
12381 if { (eval echo configure:12382: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12382   rm -rf conftest*
12383   glibcpp_cv_func__cosf_use=yes
12384 else
12385   echo "configure: failed program was:" >&5
12386   cat conftest.$ac_ext >&5
12387   rm -rf conftest*
12388   glibcpp_cv_func__cosf_use=no
12389 fi
12390 rm -f conftest*
12391     ac_ext=c
12392 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12393 ac_cpp='$CPP $CPPFLAGS'
12394 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12395 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12396 cross_compiling=$ac_cv_prog_cc_cross
12397
12398
12399 fi
12400
12401   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
12402   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
12403     for ac_func in _cosf
12404 do
12405 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12406 echo "configure:12407: checking for $ac_func" >&5
12407 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12408   echo $ac_n "(cached) $ac_c" 1>&6
12409 else
12410   cat > conftest.$ac_ext <<EOF
12411 #line 12412 "configure"
12412 #include "confdefs.h"
12413 /* System header to define __stub macros and hopefully few prototypes,
12414     which can conflict with char $ac_func(); below.  */
12415 #include <assert.h>
12416 /* Override any gcc2 internal prototype to avoid an error.  */
12417 /* We use char because int might match the return type of a gcc2
12418     builtin and then its argument prototype would still apply.  */
12419 char $ac_func();
12420
12421 int main() {
12422
12423 /* The GNU C library defines this for functions which it implements
12424     to always fail with ENOSYS.  Some functions are actually named
12425     something starting with __ and the normal name is an alias.  */
12426 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12427 choke me
12428 #else
12429 $ac_func();
12430 #endif
12431
12432 ; return 0; }
12433 EOF
12434 if { (eval echo configure:12435: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12435   rm -rf conftest*
12436   eval "ac_cv_func_$ac_func=yes"
12437 else
12438   echo "configure: failed program was:" >&5
12439   cat conftest.$ac_ext >&5
12440   rm -rf conftest*
12441   eval "ac_cv_func_$ac_func=no"
12442 fi
12443 rm -f conftest*
12444 fi
12445
12446 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12447   echo "$ac_t""yes" 1>&6
12448     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12449   cat >> confdefs.h <<EOF
12450 #define $ac_tr_func 1
12451 EOF
12452
12453 else
12454   echo "$ac_t""no" 1>&6
12455 fi
12456 done
12457
12458   fi
12459
12460
12461   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12462 echo "configure:12463: checking for _coshf declaration" >&5
12463   if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
12464   echo $ac_n "(cached) $ac_c" 1>&6
12465 else
12466
12467
12468     ac_ext=C
12469 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12470 ac_cpp='$CXXCPP $CPPFLAGS'
12471 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12472 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12473 cross_compiling=$ac_cv_prog_cxx_cross
12474
12475     cat > conftest.$ac_ext <<EOF
12476 #line 12477 "configure"
12477 #include "confdefs.h"
12478 #include <math.h>
12479 int main() {
12480  _coshf(0);
12481 ; return 0; }
12482 EOF
12483 if { (eval echo configure:12484: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12484   rm -rf conftest*
12485   glibcpp_cv_func__coshf_use=yes
12486 else
12487   echo "configure: failed program was:" >&5
12488   cat conftest.$ac_ext >&5
12489   rm -rf conftest*
12490   glibcpp_cv_func__coshf_use=no
12491 fi
12492 rm -f conftest*
12493     ac_ext=c
12494 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12495 ac_cpp='$CPP $CPPFLAGS'
12496 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12497 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12498 cross_compiling=$ac_cv_prog_cc_cross
12499
12500
12501 fi
12502
12503   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
12504   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
12505     for ac_func in _coshf
12506 do
12507 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12508 echo "configure:12509: checking for $ac_func" >&5
12509 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12510   echo $ac_n "(cached) $ac_c" 1>&6
12511 else
12512   cat > conftest.$ac_ext <<EOF
12513 #line 12514 "configure"
12514 #include "confdefs.h"
12515 /* System header to define __stub macros and hopefully few prototypes,
12516     which can conflict with char $ac_func(); below.  */
12517 #include <assert.h>
12518 /* Override any gcc2 internal prototype to avoid an error.  */
12519 /* We use char because int might match the return type of a gcc2
12520     builtin and then its argument prototype would still apply.  */
12521 char $ac_func();
12522
12523 int main() {
12524
12525 /* The GNU C library defines this for functions which it implements
12526     to always fail with ENOSYS.  Some functions are actually named
12527     something starting with __ and the normal name is an alias.  */
12528 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12529 choke me
12530 #else
12531 $ac_func();
12532 #endif
12533
12534 ; return 0; }
12535 EOF
12536 if { (eval echo configure:12537: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12537   rm -rf conftest*
12538   eval "ac_cv_func_$ac_func=yes"
12539 else
12540   echo "configure: failed program was:" >&5
12541   cat conftest.$ac_ext >&5
12542   rm -rf conftest*
12543   eval "ac_cv_func_$ac_func=no"
12544 fi
12545 rm -f conftest*
12546 fi
12547
12548 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12549   echo "$ac_t""yes" 1>&6
12550     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12551   cat >> confdefs.h <<EOF
12552 #define $ac_tr_func 1
12553 EOF
12554
12555 else
12556   echo "$ac_t""no" 1>&6
12557 fi
12558 done
12559
12560   fi
12561
12562
12563   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12564 echo "configure:12565: checking for _expf declaration" >&5
12565   if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
12566   echo $ac_n "(cached) $ac_c" 1>&6
12567 else
12568
12569
12570     ac_ext=C
12571 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12572 ac_cpp='$CXXCPP $CPPFLAGS'
12573 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12574 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12575 cross_compiling=$ac_cv_prog_cxx_cross
12576
12577     cat > conftest.$ac_ext <<EOF
12578 #line 12579 "configure"
12579 #include "confdefs.h"
12580 #include <math.h>
12581 int main() {
12582  _expf(0);
12583 ; return 0; }
12584 EOF
12585 if { (eval echo configure:12586: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12586   rm -rf conftest*
12587   glibcpp_cv_func__expf_use=yes
12588 else
12589   echo "configure: failed program was:" >&5
12590   cat conftest.$ac_ext >&5
12591   rm -rf conftest*
12592   glibcpp_cv_func__expf_use=no
12593 fi
12594 rm -f conftest*
12595     ac_ext=c
12596 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12597 ac_cpp='$CPP $CPPFLAGS'
12598 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12599 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12600 cross_compiling=$ac_cv_prog_cc_cross
12601
12602
12603 fi
12604
12605   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
12606   if test x$glibcpp_cv_func__expf_use = x"yes"; then
12607     for ac_func in _expf
12608 do
12609 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12610 echo "configure:12611: checking for $ac_func" >&5
12611 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12612   echo $ac_n "(cached) $ac_c" 1>&6
12613 else
12614   cat > conftest.$ac_ext <<EOF
12615 #line 12616 "configure"
12616 #include "confdefs.h"
12617 /* System header to define __stub macros and hopefully few prototypes,
12618     which can conflict with char $ac_func(); below.  */
12619 #include <assert.h>
12620 /* Override any gcc2 internal prototype to avoid an error.  */
12621 /* We use char because int might match the return type of a gcc2
12622     builtin and then its argument prototype would still apply.  */
12623 char $ac_func();
12624
12625 int main() {
12626
12627 /* The GNU C library defines this for functions which it implements
12628     to always fail with ENOSYS.  Some functions are actually named
12629     something starting with __ and the normal name is an alias.  */
12630 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12631 choke me
12632 #else
12633 $ac_func();
12634 #endif
12635
12636 ; return 0; }
12637 EOF
12638 if { (eval echo configure:12639: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12639   rm -rf conftest*
12640   eval "ac_cv_func_$ac_func=yes"
12641 else
12642   echo "configure: failed program was:" >&5
12643   cat conftest.$ac_ext >&5
12644   rm -rf conftest*
12645   eval "ac_cv_func_$ac_func=no"
12646 fi
12647 rm -f conftest*
12648 fi
12649
12650 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12651   echo "$ac_t""yes" 1>&6
12652     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12653   cat >> confdefs.h <<EOF
12654 #define $ac_tr_func 1
12655 EOF
12656
12657 else
12658   echo "$ac_t""no" 1>&6
12659 fi
12660 done
12661
12662   fi
12663
12664
12665   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12666 echo "configure:12667: checking for _fabsf declaration" >&5
12667   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
12668   echo $ac_n "(cached) $ac_c" 1>&6
12669 else
12670
12671
12672     ac_ext=C
12673 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12674 ac_cpp='$CXXCPP $CPPFLAGS'
12675 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12676 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12677 cross_compiling=$ac_cv_prog_cxx_cross
12678
12679     cat > conftest.$ac_ext <<EOF
12680 #line 12681 "configure"
12681 #include "confdefs.h"
12682 #include <math.h>
12683 int main() {
12684  _fabsf(0);
12685 ; return 0; }
12686 EOF
12687 if { (eval echo configure:12688: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12688   rm -rf conftest*
12689   glibcpp_cv_func__fabsf_use=yes
12690 else
12691   echo "configure: failed program was:" >&5
12692   cat conftest.$ac_ext >&5
12693   rm -rf conftest*
12694   glibcpp_cv_func__fabsf_use=no
12695 fi
12696 rm -f conftest*
12697     ac_ext=c
12698 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12699 ac_cpp='$CPP $CPPFLAGS'
12700 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12701 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12702 cross_compiling=$ac_cv_prog_cc_cross
12703
12704
12705 fi
12706
12707   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
12708   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
12709     for ac_func in _fabsf
12710 do
12711 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12712 echo "configure:12713: checking for $ac_func" >&5
12713 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12714   echo $ac_n "(cached) $ac_c" 1>&6
12715 else
12716   cat > conftest.$ac_ext <<EOF
12717 #line 12718 "configure"
12718 #include "confdefs.h"
12719 /* System header to define __stub macros and hopefully few prototypes,
12720     which can conflict with char $ac_func(); below.  */
12721 #include <assert.h>
12722 /* Override any gcc2 internal prototype to avoid an error.  */
12723 /* We use char because int might match the return type of a gcc2
12724     builtin and then its argument prototype would still apply.  */
12725 char $ac_func();
12726
12727 int main() {
12728
12729 /* The GNU C library defines this for functions which it implements
12730     to always fail with ENOSYS.  Some functions are actually named
12731     something starting with __ and the normal name is an alias.  */
12732 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12733 choke me
12734 #else
12735 $ac_func();
12736 #endif
12737
12738 ; return 0; }
12739 EOF
12740 if { (eval echo configure:12741: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12741   rm -rf conftest*
12742   eval "ac_cv_func_$ac_func=yes"
12743 else
12744   echo "configure: failed program was:" >&5
12745   cat conftest.$ac_ext >&5
12746   rm -rf conftest*
12747   eval "ac_cv_func_$ac_func=no"
12748 fi
12749 rm -f conftest*
12750 fi
12751
12752 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12753   echo "$ac_t""yes" 1>&6
12754     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12755   cat >> confdefs.h <<EOF
12756 #define $ac_tr_func 1
12757 EOF
12758
12759 else
12760   echo "$ac_t""no" 1>&6
12761 fi
12762 done
12763
12764   fi
12765
12766
12767   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12768 echo "configure:12769: checking for _floorf declaration" >&5
12769   if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
12770   echo $ac_n "(cached) $ac_c" 1>&6
12771 else
12772
12773
12774     ac_ext=C
12775 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12776 ac_cpp='$CXXCPP $CPPFLAGS'
12777 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12778 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12779 cross_compiling=$ac_cv_prog_cxx_cross
12780
12781     cat > conftest.$ac_ext <<EOF
12782 #line 12783 "configure"
12783 #include "confdefs.h"
12784 #include <math.h>
12785 int main() {
12786  _floorf(0);
12787 ; return 0; }
12788 EOF
12789 if { (eval echo configure:12790: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12790   rm -rf conftest*
12791   glibcpp_cv_func__floorf_use=yes
12792 else
12793   echo "configure: failed program was:" >&5
12794   cat conftest.$ac_ext >&5
12795   rm -rf conftest*
12796   glibcpp_cv_func__floorf_use=no
12797 fi
12798 rm -f conftest*
12799     ac_ext=c
12800 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12801 ac_cpp='$CPP $CPPFLAGS'
12802 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12803 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12804 cross_compiling=$ac_cv_prog_cc_cross
12805
12806
12807 fi
12808
12809   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
12810   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
12811     for ac_func in _floorf
12812 do
12813 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12814 echo "configure:12815: checking for $ac_func" >&5
12815 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12816   echo $ac_n "(cached) $ac_c" 1>&6
12817 else
12818   cat > conftest.$ac_ext <<EOF
12819 #line 12820 "configure"
12820 #include "confdefs.h"
12821 /* System header to define __stub macros and hopefully few prototypes,
12822     which can conflict with char $ac_func(); below.  */
12823 #include <assert.h>
12824 /* Override any gcc2 internal prototype to avoid an error.  */
12825 /* We use char because int might match the return type of a gcc2
12826     builtin and then its argument prototype would still apply.  */
12827 char $ac_func();
12828
12829 int main() {
12830
12831 /* The GNU C library defines this for functions which it implements
12832     to always fail with ENOSYS.  Some functions are actually named
12833     something starting with __ and the normal name is an alias.  */
12834 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12835 choke me
12836 #else
12837 $ac_func();
12838 #endif
12839
12840 ; return 0; }
12841 EOF
12842 if { (eval echo configure:12843: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12843   rm -rf conftest*
12844   eval "ac_cv_func_$ac_func=yes"
12845 else
12846   echo "configure: failed program was:" >&5
12847   cat conftest.$ac_ext >&5
12848   rm -rf conftest*
12849   eval "ac_cv_func_$ac_func=no"
12850 fi
12851 rm -f conftest*
12852 fi
12853
12854 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12855   echo "$ac_t""yes" 1>&6
12856     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12857   cat >> confdefs.h <<EOF
12858 #define $ac_tr_func 1
12859 EOF
12860
12861 else
12862   echo "$ac_t""no" 1>&6
12863 fi
12864 done
12865
12866   fi
12867
12868
12869   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12870 echo "configure:12871: checking for _fmodf declaration" >&5
12871   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
12872   echo $ac_n "(cached) $ac_c" 1>&6
12873 else
12874
12875
12876     ac_ext=C
12877 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12878 ac_cpp='$CXXCPP $CPPFLAGS'
12879 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12880 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12881 cross_compiling=$ac_cv_prog_cxx_cross
12882
12883     cat > conftest.$ac_ext <<EOF
12884 #line 12885 "configure"
12885 #include "confdefs.h"
12886 #include <math.h>
12887 int main() {
12888  _fmodf(0, 0);
12889 ; return 0; }
12890 EOF
12891 if { (eval echo configure:12892: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12892   rm -rf conftest*
12893   glibcpp_cv_func__fmodf_use=yes
12894 else
12895   echo "configure: failed program was:" >&5
12896   cat conftest.$ac_ext >&5
12897   rm -rf conftest*
12898   glibcpp_cv_func__fmodf_use=no
12899 fi
12900 rm -f conftest*
12901     ac_ext=c
12902 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12903 ac_cpp='$CPP $CPPFLAGS'
12904 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12905 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12906 cross_compiling=$ac_cv_prog_cc_cross
12907
12908
12909 fi
12910
12911   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
12912   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
12913     for ac_func in _fmodf
12914 do
12915 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12916 echo "configure:12917: checking for $ac_func" >&5
12917 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12918   echo $ac_n "(cached) $ac_c" 1>&6
12919 else
12920   cat > conftest.$ac_ext <<EOF
12921 #line 12922 "configure"
12922 #include "confdefs.h"
12923 /* System header to define __stub macros and hopefully few prototypes,
12924     which can conflict with char $ac_func(); below.  */
12925 #include <assert.h>
12926 /* Override any gcc2 internal prototype to avoid an error.  */
12927 /* We use char because int might match the return type of a gcc2
12928     builtin and then its argument prototype would still apply.  */
12929 char $ac_func();
12930
12931 int main() {
12932
12933 /* The GNU C library defines this for functions which it implements
12934     to always fail with ENOSYS.  Some functions are actually named
12935     something starting with __ and the normal name is an alias.  */
12936 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12937 choke me
12938 #else
12939 $ac_func();
12940 #endif
12941
12942 ; return 0; }
12943 EOF
12944 if { (eval echo configure:12945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12945   rm -rf conftest*
12946   eval "ac_cv_func_$ac_func=yes"
12947 else
12948   echo "configure: failed program was:" >&5
12949   cat conftest.$ac_ext >&5
12950   rm -rf conftest*
12951   eval "ac_cv_func_$ac_func=no"
12952 fi
12953 rm -f conftest*
12954 fi
12955
12956 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12957   echo "$ac_t""yes" 1>&6
12958     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12959   cat >> confdefs.h <<EOF
12960 #define $ac_tr_func 1
12961 EOF
12962
12963 else
12964   echo "$ac_t""no" 1>&6
12965 fi
12966 done
12967
12968   fi
12969
12970
12971   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12972 echo "configure:12973: checking for _frexpf declaration" >&5
12973   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
12974   echo $ac_n "(cached) $ac_c" 1>&6
12975 else
12976
12977
12978     ac_ext=C
12979 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12980 ac_cpp='$CXXCPP $CPPFLAGS'
12981 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12982 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12983 cross_compiling=$ac_cv_prog_cxx_cross
12984
12985     cat > conftest.$ac_ext <<EOF
12986 #line 12987 "configure"
12987 #include "confdefs.h"
12988 #include <math.h>
12989 int main() {
12990  _frexpf(0, 0);
12991 ; return 0; }
12992 EOF
12993 if { (eval echo configure:12994: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12994   rm -rf conftest*
12995   glibcpp_cv_func__frexpf_use=yes
12996 else
12997   echo "configure: failed program was:" >&5
12998   cat conftest.$ac_ext >&5
12999   rm -rf conftest*
13000   glibcpp_cv_func__frexpf_use=no
13001 fi
13002 rm -f conftest*
13003     ac_ext=c
13004 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13005 ac_cpp='$CPP $CPPFLAGS'
13006 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13007 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13008 cross_compiling=$ac_cv_prog_cc_cross
13009
13010
13011 fi
13012
13013   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
13014   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
13015     for ac_func in _frexpf
13016 do
13017 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13018 echo "configure:13019: checking for $ac_func" >&5
13019 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13020   echo $ac_n "(cached) $ac_c" 1>&6
13021 else
13022   cat > conftest.$ac_ext <<EOF
13023 #line 13024 "configure"
13024 #include "confdefs.h"
13025 /* System header to define __stub macros and hopefully few prototypes,
13026     which can conflict with char $ac_func(); below.  */
13027 #include <assert.h>
13028 /* Override any gcc2 internal prototype to avoid an error.  */
13029 /* We use char because int might match the return type of a gcc2
13030     builtin and then its argument prototype would still apply.  */
13031 char $ac_func();
13032
13033 int main() {
13034
13035 /* The GNU C library defines this for functions which it implements
13036     to always fail with ENOSYS.  Some functions are actually named
13037     something starting with __ and the normal name is an alias.  */
13038 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13039 choke me
13040 #else
13041 $ac_func();
13042 #endif
13043
13044 ; return 0; }
13045 EOF
13046 if { (eval echo configure:13047: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13047   rm -rf conftest*
13048   eval "ac_cv_func_$ac_func=yes"
13049 else
13050   echo "configure: failed program was:" >&5
13051   cat conftest.$ac_ext >&5
13052   rm -rf conftest*
13053   eval "ac_cv_func_$ac_func=no"
13054 fi
13055 rm -f conftest*
13056 fi
13057
13058 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13059   echo "$ac_t""yes" 1>&6
13060     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13061   cat >> confdefs.h <<EOF
13062 #define $ac_tr_func 1
13063 EOF
13064
13065 else
13066   echo "$ac_t""no" 1>&6
13067 fi
13068 done
13069
13070   fi
13071
13072
13073   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13074 echo "configure:13075: checking for _ldexpf declaration" >&5
13075   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13076   echo $ac_n "(cached) $ac_c" 1>&6
13077 else
13078
13079
13080     ac_ext=C
13081 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13082 ac_cpp='$CXXCPP $CPPFLAGS'
13083 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13084 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13085 cross_compiling=$ac_cv_prog_cxx_cross
13086
13087     cat > conftest.$ac_ext <<EOF
13088 #line 13089 "configure"
13089 #include "confdefs.h"
13090 #include <math.h>
13091 int main() {
13092  _ldexpf(0, 0);
13093 ; return 0; }
13094 EOF
13095 if { (eval echo configure:13096: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13096   rm -rf conftest*
13097   glibcpp_cv_func__ldexpf_use=yes
13098 else
13099   echo "configure: failed program was:" >&5
13100   cat conftest.$ac_ext >&5
13101   rm -rf conftest*
13102   glibcpp_cv_func__ldexpf_use=no
13103 fi
13104 rm -f conftest*
13105     ac_ext=c
13106 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13107 ac_cpp='$CPP $CPPFLAGS'
13108 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13109 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13110 cross_compiling=$ac_cv_prog_cc_cross
13111
13112
13113 fi
13114
13115   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13116   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13117     for ac_func in _ldexpf
13118 do
13119 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13120 echo "configure:13121: checking for $ac_func" >&5
13121 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13122   echo $ac_n "(cached) $ac_c" 1>&6
13123 else
13124   cat > conftest.$ac_ext <<EOF
13125 #line 13126 "configure"
13126 #include "confdefs.h"
13127 /* System header to define __stub macros and hopefully few prototypes,
13128     which can conflict with char $ac_func(); below.  */
13129 #include <assert.h>
13130 /* Override any gcc2 internal prototype to avoid an error.  */
13131 /* We use char because int might match the return type of a gcc2
13132     builtin and then its argument prototype would still apply.  */
13133 char $ac_func();
13134
13135 int main() {
13136
13137 /* The GNU C library defines this for functions which it implements
13138     to always fail with ENOSYS.  Some functions are actually named
13139     something starting with __ and the normal name is an alias.  */
13140 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13141 choke me
13142 #else
13143 $ac_func();
13144 #endif
13145
13146 ; return 0; }
13147 EOF
13148 if { (eval echo configure:13149: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13149   rm -rf conftest*
13150   eval "ac_cv_func_$ac_func=yes"
13151 else
13152   echo "configure: failed program was:" >&5
13153   cat conftest.$ac_ext >&5
13154   rm -rf conftest*
13155   eval "ac_cv_func_$ac_func=no"
13156 fi
13157 rm -f conftest*
13158 fi
13159
13160 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13161   echo "$ac_t""yes" 1>&6
13162     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13163   cat >> confdefs.h <<EOF
13164 #define $ac_tr_func 1
13165 EOF
13166
13167 else
13168   echo "$ac_t""no" 1>&6
13169 fi
13170 done
13171
13172   fi
13173
13174
13175   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
13176 echo "configure:13177: checking for _logf declaration" >&5
13177   if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
13178   echo $ac_n "(cached) $ac_c" 1>&6
13179 else
13180
13181
13182     ac_ext=C
13183 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13184 ac_cpp='$CXXCPP $CPPFLAGS'
13185 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13186 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13187 cross_compiling=$ac_cv_prog_cxx_cross
13188
13189     cat > conftest.$ac_ext <<EOF
13190 #line 13191 "configure"
13191 #include "confdefs.h"
13192 #include <math.h>
13193 int main() {
13194  _logf(0);
13195 ; return 0; }
13196 EOF
13197 if { (eval echo configure:13198: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13198   rm -rf conftest*
13199   glibcpp_cv_func__logf_use=yes
13200 else
13201   echo "configure: failed program was:" >&5
13202   cat conftest.$ac_ext >&5
13203   rm -rf conftest*
13204   glibcpp_cv_func__logf_use=no
13205 fi
13206 rm -f conftest*
13207     ac_ext=c
13208 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13209 ac_cpp='$CPP $CPPFLAGS'
13210 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13211 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13212 cross_compiling=$ac_cv_prog_cc_cross
13213
13214
13215 fi
13216
13217   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
13218   if test x$glibcpp_cv_func__logf_use = x"yes"; then
13219     for ac_func in _logf
13220 do
13221 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13222 echo "configure:13223: checking for $ac_func" >&5
13223 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13224   echo $ac_n "(cached) $ac_c" 1>&6
13225 else
13226   cat > conftest.$ac_ext <<EOF
13227 #line 13228 "configure"
13228 #include "confdefs.h"
13229 /* System header to define __stub macros and hopefully few prototypes,
13230     which can conflict with char $ac_func(); below.  */
13231 #include <assert.h>
13232 /* Override any gcc2 internal prototype to avoid an error.  */
13233 /* We use char because int might match the return type of a gcc2
13234     builtin and then its argument prototype would still apply.  */
13235 char $ac_func();
13236
13237 int main() {
13238
13239 /* The GNU C library defines this for functions which it implements
13240     to always fail with ENOSYS.  Some functions are actually named
13241     something starting with __ and the normal name is an alias.  */
13242 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13243 choke me
13244 #else
13245 $ac_func();
13246 #endif
13247
13248 ; return 0; }
13249 EOF
13250 if { (eval echo configure:13251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13251   rm -rf conftest*
13252   eval "ac_cv_func_$ac_func=yes"
13253 else
13254   echo "configure: failed program was:" >&5
13255   cat conftest.$ac_ext >&5
13256   rm -rf conftest*
13257   eval "ac_cv_func_$ac_func=no"
13258 fi
13259 rm -f conftest*
13260 fi
13261
13262 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13263   echo "$ac_t""yes" 1>&6
13264     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13265   cat >> confdefs.h <<EOF
13266 #define $ac_tr_func 1
13267 EOF
13268
13269 else
13270   echo "$ac_t""no" 1>&6
13271 fi
13272 done
13273
13274   fi
13275
13276
13277   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
13278 echo "configure:13279: checking for _log10f declaration" >&5
13279   if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
13280   echo $ac_n "(cached) $ac_c" 1>&6
13281 else
13282
13283
13284     ac_ext=C
13285 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13286 ac_cpp='$CXXCPP $CPPFLAGS'
13287 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13288 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13289 cross_compiling=$ac_cv_prog_cxx_cross
13290
13291     cat > conftest.$ac_ext <<EOF
13292 #line 13293 "configure"
13293 #include "confdefs.h"
13294 #include <math.h>
13295 int main() {
13296  _log10f(0);
13297 ; return 0; }
13298 EOF
13299 if { (eval echo configure:13300: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13300   rm -rf conftest*
13301   glibcpp_cv_func__log10f_use=yes
13302 else
13303   echo "configure: failed program was:" >&5
13304   cat conftest.$ac_ext >&5
13305   rm -rf conftest*
13306   glibcpp_cv_func__log10f_use=no
13307 fi
13308 rm -f conftest*
13309     ac_ext=c
13310 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13311 ac_cpp='$CPP $CPPFLAGS'
13312 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13313 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13314 cross_compiling=$ac_cv_prog_cc_cross
13315
13316
13317 fi
13318
13319   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
13320   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
13321     for ac_func in _log10f
13322 do
13323 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13324 echo "configure:13325: checking for $ac_func" >&5
13325 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13326   echo $ac_n "(cached) $ac_c" 1>&6
13327 else
13328   cat > conftest.$ac_ext <<EOF
13329 #line 13330 "configure"
13330 #include "confdefs.h"
13331 /* System header to define __stub macros and hopefully few prototypes,
13332     which can conflict with char $ac_func(); below.  */
13333 #include <assert.h>
13334 /* Override any gcc2 internal prototype to avoid an error.  */
13335 /* We use char because int might match the return type of a gcc2
13336     builtin and then its argument prototype would still apply.  */
13337 char $ac_func();
13338
13339 int main() {
13340
13341 /* The GNU C library defines this for functions which it implements
13342     to always fail with ENOSYS.  Some functions are actually named
13343     something starting with __ and the normal name is an alias.  */
13344 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13345 choke me
13346 #else
13347 $ac_func();
13348 #endif
13349
13350 ; return 0; }
13351 EOF
13352 if { (eval echo configure:13353: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13353   rm -rf conftest*
13354   eval "ac_cv_func_$ac_func=yes"
13355 else
13356   echo "configure: failed program was:" >&5
13357   cat conftest.$ac_ext >&5
13358   rm -rf conftest*
13359   eval "ac_cv_func_$ac_func=no"
13360 fi
13361 rm -f conftest*
13362 fi
13363
13364 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13365   echo "$ac_t""yes" 1>&6
13366     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13367   cat >> confdefs.h <<EOF
13368 #define $ac_tr_func 1
13369 EOF
13370
13371 else
13372   echo "$ac_t""no" 1>&6
13373 fi
13374 done
13375
13376   fi
13377
13378
13379   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
13380 echo "configure:13381: checking for _modff declaration" >&5
13381   if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
13382   echo $ac_n "(cached) $ac_c" 1>&6
13383 else
13384
13385
13386     ac_ext=C
13387 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13388 ac_cpp='$CXXCPP $CPPFLAGS'
13389 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13390 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13391 cross_compiling=$ac_cv_prog_cxx_cross
13392
13393     cat > conftest.$ac_ext <<EOF
13394 #line 13395 "configure"
13395 #include "confdefs.h"
13396 #include <math.h>
13397 int main() {
13398  _modff(0, 0);
13399 ; return 0; }
13400 EOF
13401 if { (eval echo configure:13402: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13402   rm -rf conftest*
13403   glibcpp_cv_func__modff_use=yes
13404 else
13405   echo "configure: failed program was:" >&5
13406   cat conftest.$ac_ext >&5
13407   rm -rf conftest*
13408   glibcpp_cv_func__modff_use=no
13409 fi
13410 rm -f conftest*
13411     ac_ext=c
13412 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13413 ac_cpp='$CPP $CPPFLAGS'
13414 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13415 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13416 cross_compiling=$ac_cv_prog_cc_cross
13417
13418
13419 fi
13420
13421   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
13422   if test x$glibcpp_cv_func__modff_use = x"yes"; then
13423     for ac_func in _modff
13424 do
13425 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13426 echo "configure:13427: checking for $ac_func" >&5
13427 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13428   echo $ac_n "(cached) $ac_c" 1>&6
13429 else
13430   cat > conftest.$ac_ext <<EOF
13431 #line 13432 "configure"
13432 #include "confdefs.h"
13433 /* System header to define __stub macros and hopefully few prototypes,
13434     which can conflict with char $ac_func(); below.  */
13435 #include <assert.h>
13436 /* Override any gcc2 internal prototype to avoid an error.  */
13437 /* We use char because int might match the return type of a gcc2
13438     builtin and then its argument prototype would still apply.  */
13439 char $ac_func();
13440
13441 int main() {
13442
13443 /* The GNU C library defines this for functions which it implements
13444     to always fail with ENOSYS.  Some functions are actually named
13445     something starting with __ and the normal name is an alias.  */
13446 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13447 choke me
13448 #else
13449 $ac_func();
13450 #endif
13451
13452 ; return 0; }
13453 EOF
13454 if { (eval echo configure:13455: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13455   rm -rf conftest*
13456   eval "ac_cv_func_$ac_func=yes"
13457 else
13458   echo "configure: failed program was:" >&5
13459   cat conftest.$ac_ext >&5
13460   rm -rf conftest*
13461   eval "ac_cv_func_$ac_func=no"
13462 fi
13463 rm -f conftest*
13464 fi
13465
13466 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13467   echo "$ac_t""yes" 1>&6
13468     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13469   cat >> confdefs.h <<EOF
13470 #define $ac_tr_func 1
13471 EOF
13472
13473 else
13474   echo "$ac_t""no" 1>&6
13475 fi
13476 done
13477
13478   fi
13479
13480
13481   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
13482 echo "configure:13483: checking for _powf declaration" >&5
13483   if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
13484   echo $ac_n "(cached) $ac_c" 1>&6
13485 else
13486
13487
13488     ac_ext=C
13489 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13490 ac_cpp='$CXXCPP $CPPFLAGS'
13491 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13492 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13493 cross_compiling=$ac_cv_prog_cxx_cross
13494
13495     cat > conftest.$ac_ext <<EOF
13496 #line 13497 "configure"
13497 #include "confdefs.h"
13498 #include <math.h>
13499 int main() {
13500  _powf(0, 0);
13501 ; return 0; }
13502 EOF
13503 if { (eval echo configure:13504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13504   rm -rf conftest*
13505   glibcpp_cv_func__powf_use=yes
13506 else
13507   echo "configure: failed program was:" >&5
13508   cat conftest.$ac_ext >&5
13509   rm -rf conftest*
13510   glibcpp_cv_func__powf_use=no
13511 fi
13512 rm -f conftest*
13513     ac_ext=c
13514 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13515 ac_cpp='$CPP $CPPFLAGS'
13516 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13517 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13518 cross_compiling=$ac_cv_prog_cc_cross
13519
13520
13521 fi
13522
13523   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
13524   if test x$glibcpp_cv_func__powf_use = x"yes"; then
13525     for ac_func in _powf
13526 do
13527 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13528 echo "configure:13529: checking for $ac_func" >&5
13529 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13530   echo $ac_n "(cached) $ac_c" 1>&6
13531 else
13532   cat > conftest.$ac_ext <<EOF
13533 #line 13534 "configure"
13534 #include "confdefs.h"
13535 /* System header to define __stub macros and hopefully few prototypes,
13536     which can conflict with char $ac_func(); below.  */
13537 #include <assert.h>
13538 /* Override any gcc2 internal prototype to avoid an error.  */
13539 /* We use char because int might match the return type of a gcc2
13540     builtin and then its argument prototype would still apply.  */
13541 char $ac_func();
13542
13543 int main() {
13544
13545 /* The GNU C library defines this for functions which it implements
13546     to always fail with ENOSYS.  Some functions are actually named
13547     something starting with __ and the normal name is an alias.  */
13548 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13549 choke me
13550 #else
13551 $ac_func();
13552 #endif
13553
13554 ; return 0; }
13555 EOF
13556 if { (eval echo configure:13557: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13557   rm -rf conftest*
13558   eval "ac_cv_func_$ac_func=yes"
13559 else
13560   echo "configure: failed program was:" >&5
13561   cat conftest.$ac_ext >&5
13562   rm -rf conftest*
13563   eval "ac_cv_func_$ac_func=no"
13564 fi
13565 rm -f conftest*
13566 fi
13567
13568 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13569   echo "$ac_t""yes" 1>&6
13570     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13571   cat >> confdefs.h <<EOF
13572 #define $ac_tr_func 1
13573 EOF
13574
13575 else
13576   echo "$ac_t""no" 1>&6
13577 fi
13578 done
13579
13580   fi
13581
13582
13583   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
13584 echo "configure:13585: checking for _sinf declaration" >&5
13585   if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
13586   echo $ac_n "(cached) $ac_c" 1>&6
13587 else
13588
13589
13590     ac_ext=C
13591 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13592 ac_cpp='$CXXCPP $CPPFLAGS'
13593 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13594 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13595 cross_compiling=$ac_cv_prog_cxx_cross
13596
13597     cat > conftest.$ac_ext <<EOF
13598 #line 13599 "configure"
13599 #include "confdefs.h"
13600 #include <math.h>
13601 int main() {
13602  _sinf(0);
13603 ; return 0; }
13604 EOF
13605 if { (eval echo configure:13606: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13606   rm -rf conftest*
13607   glibcpp_cv_func__sinf_use=yes
13608 else
13609   echo "configure: failed program was:" >&5
13610   cat conftest.$ac_ext >&5
13611   rm -rf conftest*
13612   glibcpp_cv_func__sinf_use=no
13613 fi
13614 rm -f conftest*
13615     ac_ext=c
13616 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13617 ac_cpp='$CPP $CPPFLAGS'
13618 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13619 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13620 cross_compiling=$ac_cv_prog_cc_cross
13621
13622
13623 fi
13624
13625   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
13626   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
13627     for ac_func in _sinf
13628 do
13629 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13630 echo "configure:13631: checking for $ac_func" >&5
13631 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13632   echo $ac_n "(cached) $ac_c" 1>&6
13633 else
13634   cat > conftest.$ac_ext <<EOF
13635 #line 13636 "configure"
13636 #include "confdefs.h"
13637 /* System header to define __stub macros and hopefully few prototypes,
13638     which can conflict with char $ac_func(); below.  */
13639 #include <assert.h>
13640 /* Override any gcc2 internal prototype to avoid an error.  */
13641 /* We use char because int might match the return type of a gcc2
13642     builtin and then its argument prototype would still apply.  */
13643 char $ac_func();
13644
13645 int main() {
13646
13647 /* The GNU C library defines this for functions which it implements
13648     to always fail with ENOSYS.  Some functions are actually named
13649     something starting with __ and the normal name is an alias.  */
13650 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13651 choke me
13652 #else
13653 $ac_func();
13654 #endif
13655
13656 ; return 0; }
13657 EOF
13658 if { (eval echo configure:13659: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13659   rm -rf conftest*
13660   eval "ac_cv_func_$ac_func=yes"
13661 else
13662   echo "configure: failed program was:" >&5
13663   cat conftest.$ac_ext >&5
13664   rm -rf conftest*
13665   eval "ac_cv_func_$ac_func=no"
13666 fi
13667 rm -f conftest*
13668 fi
13669
13670 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13671   echo "$ac_t""yes" 1>&6
13672     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13673   cat >> confdefs.h <<EOF
13674 #define $ac_tr_func 1
13675 EOF
13676
13677 else
13678   echo "$ac_t""no" 1>&6
13679 fi
13680 done
13681
13682   fi
13683
13684
13685   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
13686 echo "configure:13687: checking for _sinhf declaration" >&5
13687   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
13688   echo $ac_n "(cached) $ac_c" 1>&6
13689 else
13690
13691
13692     ac_ext=C
13693 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13694 ac_cpp='$CXXCPP $CPPFLAGS'
13695 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13696 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13697 cross_compiling=$ac_cv_prog_cxx_cross
13698
13699     cat > conftest.$ac_ext <<EOF
13700 #line 13701 "configure"
13701 #include "confdefs.h"
13702 #include <math.h>
13703 int main() {
13704  _sinhf(0);
13705 ; return 0; }
13706 EOF
13707 if { (eval echo configure:13708: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13708   rm -rf conftest*
13709   glibcpp_cv_func__sinhf_use=yes
13710 else
13711   echo "configure: failed program was:" >&5
13712   cat conftest.$ac_ext >&5
13713   rm -rf conftest*
13714   glibcpp_cv_func__sinhf_use=no
13715 fi
13716 rm -f conftest*
13717     ac_ext=c
13718 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13719 ac_cpp='$CPP $CPPFLAGS'
13720 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13721 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13722 cross_compiling=$ac_cv_prog_cc_cross
13723
13724
13725 fi
13726
13727   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
13728   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
13729     for ac_func in _sinhf
13730 do
13731 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13732 echo "configure:13733: checking for $ac_func" >&5
13733 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13734   echo $ac_n "(cached) $ac_c" 1>&6
13735 else
13736   cat > conftest.$ac_ext <<EOF
13737 #line 13738 "configure"
13738 #include "confdefs.h"
13739 /* System header to define __stub macros and hopefully few prototypes,
13740     which can conflict with char $ac_func(); below.  */
13741 #include <assert.h>
13742 /* Override any gcc2 internal prototype to avoid an error.  */
13743 /* We use char because int might match the return type of a gcc2
13744     builtin and then its argument prototype would still apply.  */
13745 char $ac_func();
13746
13747 int main() {
13748
13749 /* The GNU C library defines this for functions which it implements
13750     to always fail with ENOSYS.  Some functions are actually named
13751     something starting with __ and the normal name is an alias.  */
13752 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13753 choke me
13754 #else
13755 $ac_func();
13756 #endif
13757
13758 ; return 0; }
13759 EOF
13760 if { (eval echo configure:13761: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13761   rm -rf conftest*
13762   eval "ac_cv_func_$ac_func=yes"
13763 else
13764   echo "configure: failed program was:" >&5
13765   cat conftest.$ac_ext >&5
13766   rm -rf conftest*
13767   eval "ac_cv_func_$ac_func=no"
13768 fi
13769 rm -f conftest*
13770 fi
13771
13772 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13773   echo "$ac_t""yes" 1>&6
13774     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13775   cat >> confdefs.h <<EOF
13776 #define $ac_tr_func 1
13777 EOF
13778
13779 else
13780   echo "$ac_t""no" 1>&6
13781 fi
13782 done
13783
13784   fi
13785
13786
13787   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
13788 echo "configure:13789: checking for _sqrtf declaration" >&5
13789   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
13790   echo $ac_n "(cached) $ac_c" 1>&6
13791 else
13792
13793
13794     ac_ext=C
13795 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13796 ac_cpp='$CXXCPP $CPPFLAGS'
13797 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13798 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13799 cross_compiling=$ac_cv_prog_cxx_cross
13800
13801     cat > conftest.$ac_ext <<EOF
13802 #line 13803 "configure"
13803 #include "confdefs.h"
13804 #include <math.h>
13805 int main() {
13806  _sqrtf(0);
13807 ; return 0; }
13808 EOF
13809 if { (eval echo configure:13810: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13810   rm -rf conftest*
13811   glibcpp_cv_func__sqrtf_use=yes
13812 else
13813   echo "configure: failed program was:" >&5
13814   cat conftest.$ac_ext >&5
13815   rm -rf conftest*
13816   glibcpp_cv_func__sqrtf_use=no
13817 fi
13818 rm -f conftest*
13819     ac_ext=c
13820 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13821 ac_cpp='$CPP $CPPFLAGS'
13822 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13823 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13824 cross_compiling=$ac_cv_prog_cc_cross
13825
13826
13827 fi
13828
13829   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
13830   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
13831     for ac_func in _sqrtf
13832 do
13833 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13834 echo "configure:13835: checking for $ac_func" >&5
13835 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13836   echo $ac_n "(cached) $ac_c" 1>&6
13837 else
13838   cat > conftest.$ac_ext <<EOF
13839 #line 13840 "configure"
13840 #include "confdefs.h"
13841 /* System header to define __stub macros and hopefully few prototypes,
13842     which can conflict with char $ac_func(); below.  */
13843 #include <assert.h>
13844 /* Override any gcc2 internal prototype to avoid an error.  */
13845 /* We use char because int might match the return type of a gcc2
13846     builtin and then its argument prototype would still apply.  */
13847 char $ac_func();
13848
13849 int main() {
13850
13851 /* The GNU C library defines this for functions which it implements
13852     to always fail with ENOSYS.  Some functions are actually named
13853     something starting with __ and the normal name is an alias.  */
13854 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13855 choke me
13856 #else
13857 $ac_func();
13858 #endif
13859
13860 ; return 0; }
13861 EOF
13862 if { (eval echo configure:13863: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13863   rm -rf conftest*
13864   eval "ac_cv_func_$ac_func=yes"
13865 else
13866   echo "configure: failed program was:" >&5
13867   cat conftest.$ac_ext >&5
13868   rm -rf conftest*
13869   eval "ac_cv_func_$ac_func=no"
13870 fi
13871 rm -f conftest*
13872 fi
13873
13874 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13875   echo "$ac_t""yes" 1>&6
13876     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13877   cat >> confdefs.h <<EOF
13878 #define $ac_tr_func 1
13879 EOF
13880
13881 else
13882   echo "$ac_t""no" 1>&6
13883 fi
13884 done
13885
13886   fi
13887
13888
13889   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
13890 echo "configure:13891: checking for _tanf declaration" >&5
13891   if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
13892   echo $ac_n "(cached) $ac_c" 1>&6
13893 else
13894
13895
13896     ac_ext=C
13897 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13898 ac_cpp='$CXXCPP $CPPFLAGS'
13899 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13900 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13901 cross_compiling=$ac_cv_prog_cxx_cross
13902
13903     cat > conftest.$ac_ext <<EOF
13904 #line 13905 "configure"
13905 #include "confdefs.h"
13906 #include <math.h>
13907 int main() {
13908  _tanf(0);
13909 ; return 0; }
13910 EOF
13911 if { (eval echo configure:13912: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13912   rm -rf conftest*
13913   glibcpp_cv_func__tanf_use=yes
13914 else
13915   echo "configure: failed program was:" >&5
13916   cat conftest.$ac_ext >&5
13917   rm -rf conftest*
13918   glibcpp_cv_func__tanf_use=no
13919 fi
13920 rm -f conftest*
13921     ac_ext=c
13922 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13923 ac_cpp='$CPP $CPPFLAGS'
13924 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13925 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13926 cross_compiling=$ac_cv_prog_cc_cross
13927
13928
13929 fi
13930
13931   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
13932   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
13933     for ac_func in _tanf
13934 do
13935 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13936 echo "configure:13937: checking for $ac_func" >&5
13937 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13938   echo $ac_n "(cached) $ac_c" 1>&6
13939 else
13940   cat > conftest.$ac_ext <<EOF
13941 #line 13942 "configure"
13942 #include "confdefs.h"
13943 /* System header to define __stub macros and hopefully few prototypes,
13944     which can conflict with char $ac_func(); below.  */
13945 #include <assert.h>
13946 /* Override any gcc2 internal prototype to avoid an error.  */
13947 /* We use char because int might match the return type of a gcc2
13948     builtin and then its argument prototype would still apply.  */
13949 char $ac_func();
13950
13951 int main() {
13952
13953 /* The GNU C library defines this for functions which it implements
13954     to always fail with ENOSYS.  Some functions are actually named
13955     something starting with __ and the normal name is an alias.  */
13956 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13957 choke me
13958 #else
13959 $ac_func();
13960 #endif
13961
13962 ; return 0; }
13963 EOF
13964 if { (eval echo configure:13965: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13965   rm -rf conftest*
13966   eval "ac_cv_func_$ac_func=yes"
13967 else
13968   echo "configure: failed program was:" >&5
13969   cat conftest.$ac_ext >&5
13970   rm -rf conftest*
13971   eval "ac_cv_func_$ac_func=no"
13972 fi
13973 rm -f conftest*
13974 fi
13975
13976 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13977   echo "$ac_t""yes" 1>&6
13978     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13979   cat >> confdefs.h <<EOF
13980 #define $ac_tr_func 1
13981 EOF
13982
13983 else
13984   echo "$ac_t""no" 1>&6
13985 fi
13986 done
13987
13988   fi
13989
13990
13991   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
13992 echo "configure:13993: checking for _tanhf declaration" >&5
13993   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
13994   echo $ac_n "(cached) $ac_c" 1>&6
13995 else
13996
13997
13998     ac_ext=C
13999 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14000 ac_cpp='$CXXCPP $CPPFLAGS'
14001 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14002 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14003 cross_compiling=$ac_cv_prog_cxx_cross
14004
14005     cat > conftest.$ac_ext <<EOF
14006 #line 14007 "configure"
14007 #include "confdefs.h"
14008 #include <math.h>
14009 int main() {
14010  _tanhf(0);
14011 ; return 0; }
14012 EOF
14013 if { (eval echo configure:14014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14014   rm -rf conftest*
14015   glibcpp_cv_func__tanhf_use=yes
14016 else
14017   echo "configure: failed program was:" >&5
14018   cat conftest.$ac_ext >&5
14019   rm -rf conftest*
14020   glibcpp_cv_func__tanhf_use=no
14021 fi
14022 rm -f conftest*
14023     ac_ext=c
14024 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14025 ac_cpp='$CPP $CPPFLAGS'
14026 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14027 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14028 cross_compiling=$ac_cv_prog_cc_cross
14029
14030
14031 fi
14032
14033   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
14034   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
14035     for ac_func in _tanhf
14036 do
14037 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14038 echo "configure:14039: checking for $ac_func" >&5
14039 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14040   echo $ac_n "(cached) $ac_c" 1>&6
14041 else
14042   cat > conftest.$ac_ext <<EOF
14043 #line 14044 "configure"
14044 #include "confdefs.h"
14045 /* System header to define __stub macros and hopefully few prototypes,
14046     which can conflict with char $ac_func(); below.  */
14047 #include <assert.h>
14048 /* Override any gcc2 internal prototype to avoid an error.  */
14049 /* We use char because int might match the return type of a gcc2
14050     builtin and then its argument prototype would still apply.  */
14051 char $ac_func();
14052
14053 int main() {
14054
14055 /* The GNU C library defines this for functions which it implements
14056     to always fail with ENOSYS.  Some functions are actually named
14057     something starting with __ and the normal name is an alias.  */
14058 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14059 choke me
14060 #else
14061 $ac_func();
14062 #endif
14063
14064 ; return 0; }
14065 EOF
14066 if { (eval echo configure:14067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14067   rm -rf conftest*
14068   eval "ac_cv_func_$ac_func=yes"
14069 else
14070   echo "configure: failed program was:" >&5
14071   cat conftest.$ac_ext >&5
14072   rm -rf conftest*
14073   eval "ac_cv_func_$ac_func=no"
14074 fi
14075 rm -f conftest*
14076 fi
14077
14078 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14079   echo "$ac_t""yes" 1>&6
14080     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14081   cat >> confdefs.h <<EOF
14082 #define $ac_tr_func 1
14083 EOF
14084
14085 else
14086   echo "$ac_t""no" 1>&6
14087 fi
14088 done
14089
14090   fi
14091
14092
14093   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14094 echo "configure:14095: checking for _sincosf declaration" >&5
14095   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14096   echo $ac_n "(cached) $ac_c" 1>&6
14097 else
14098
14099
14100     ac_ext=C
14101 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14102 ac_cpp='$CXXCPP $CPPFLAGS'
14103 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14104 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14105 cross_compiling=$ac_cv_prog_cxx_cross
14106
14107     cat > conftest.$ac_ext <<EOF
14108 #line 14109 "configure"
14109 #include "confdefs.h"
14110 #include <math.h>
14111 int main() {
14112  _sincosf(0, 0, 0);
14113 ; return 0; }
14114 EOF
14115 if { (eval echo configure:14116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14116   rm -rf conftest*
14117   glibcpp_cv_func__sincosf_use=yes
14118 else
14119   echo "configure: failed program was:" >&5
14120   cat conftest.$ac_ext >&5
14121   rm -rf conftest*
14122   glibcpp_cv_func__sincosf_use=no
14123 fi
14124 rm -f conftest*
14125     ac_ext=c
14126 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14127 ac_cpp='$CPP $CPPFLAGS'
14128 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14129 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14130 cross_compiling=$ac_cv_prog_cc_cross
14131
14132
14133 fi
14134
14135   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
14136   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
14137     for ac_func in _sincosf
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   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
14196 echo "configure:14197: checking for _finitef declaration" >&5
14197   if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
14198   echo $ac_n "(cached) $ac_c" 1>&6
14199 else
14200
14201
14202     ac_ext=C
14203 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14204 ac_cpp='$CXXCPP $CPPFLAGS'
14205 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14206 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14207 cross_compiling=$ac_cv_prog_cxx_cross
14208
14209     cat > conftest.$ac_ext <<EOF
14210 #line 14211 "configure"
14211 #include "confdefs.h"
14212 #include <math.h>
14213 int main() {
14214  _finitef(0);
14215 ; return 0; }
14216 EOF
14217 if { (eval echo configure:14218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14218   rm -rf conftest*
14219   glibcpp_cv_func__finitef_use=yes
14220 else
14221   echo "configure: failed program was:" >&5
14222   cat conftest.$ac_ext >&5
14223   rm -rf conftest*
14224   glibcpp_cv_func__finitef_use=no
14225 fi
14226 rm -f conftest*
14227     ac_ext=c
14228 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14229 ac_cpp='$CPP $CPPFLAGS'
14230 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14231 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14232 cross_compiling=$ac_cv_prog_cc_cross
14233
14234
14235 fi
14236
14237   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
14238   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
14239     for ac_func in _finitef
14240 do
14241 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14242 echo "configure:14243: checking for $ac_func" >&5
14243 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14244   echo $ac_n "(cached) $ac_c" 1>&6
14245 else
14246   cat > conftest.$ac_ext <<EOF
14247 #line 14248 "configure"
14248 #include "confdefs.h"
14249 /* System header to define __stub macros and hopefully few prototypes,
14250     which can conflict with char $ac_func(); below.  */
14251 #include <assert.h>
14252 /* Override any gcc2 internal prototype to avoid an error.  */
14253 /* We use char because int might match the return type of a gcc2
14254     builtin and then its argument prototype would still apply.  */
14255 char $ac_func();
14256
14257 int main() {
14258
14259 /* The GNU C library defines this for functions which it implements
14260     to always fail with ENOSYS.  Some functions are actually named
14261     something starting with __ and the normal name is an alias.  */
14262 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14263 choke me
14264 #else
14265 $ac_func();
14266 #endif
14267
14268 ; return 0; }
14269 EOF
14270 if { (eval echo configure:14271: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14271   rm -rf conftest*
14272   eval "ac_cv_func_$ac_func=yes"
14273 else
14274   echo "configure: failed program was:" >&5
14275   cat conftest.$ac_ext >&5
14276   rm -rf conftest*
14277   eval "ac_cv_func_$ac_func=no"
14278 fi
14279 rm -f conftest*
14280 fi
14281
14282 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14283   echo "$ac_t""yes" 1>&6
14284     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14285   cat >> confdefs.h <<EOF
14286 #define $ac_tr_func 1
14287 EOF
14288
14289 else
14290   echo "$ac_t""no" 1>&6
14291 fi
14292 done
14293
14294   fi
14295
14296
14297
14298   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
14299 echo "configure:14300: checking for _isnanl declaration" >&5
14300   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
14301   echo $ac_n "(cached) $ac_c" 1>&6
14302 else
14303
14304
14305     ac_ext=C
14306 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14307 ac_cpp='$CXXCPP $CPPFLAGS'
14308 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14309 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14310 cross_compiling=$ac_cv_prog_cxx_cross
14311
14312     cat > conftest.$ac_ext <<EOF
14313 #line 14314 "configure"
14314 #include "confdefs.h"
14315 #include <math.h>
14316 int main() {
14317  _isnanl(0);
14318 ; return 0; }
14319 EOF
14320 if { (eval echo configure:14321: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14321   rm -rf conftest*
14322   glibcpp_cv_func__isnanl_use=yes
14323 else
14324   echo "configure: failed program was:" >&5
14325   cat conftest.$ac_ext >&5
14326   rm -rf conftest*
14327   glibcpp_cv_func__isnanl_use=no
14328 fi
14329 rm -f conftest*
14330     ac_ext=c
14331 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14332 ac_cpp='$CPP $CPPFLAGS'
14333 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14334 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14335 cross_compiling=$ac_cv_prog_cc_cross
14336
14337
14338 fi
14339
14340   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
14341   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
14342     for ac_func in _isnanl
14343 do
14344 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14345 echo "configure:14346: checking for $ac_func" >&5
14346 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14347   echo $ac_n "(cached) $ac_c" 1>&6
14348 else
14349   cat > conftest.$ac_ext <<EOF
14350 #line 14351 "configure"
14351 #include "confdefs.h"
14352 /* System header to define __stub macros and hopefully few prototypes,
14353     which can conflict with char $ac_func(); below.  */
14354 #include <assert.h>
14355 /* Override any gcc2 internal prototype to avoid an error.  */
14356 /* We use char because int might match the return type of a gcc2
14357     builtin and then its argument prototype would still apply.  */
14358 char $ac_func();
14359
14360 int main() {
14361
14362 /* The GNU C library defines this for functions which it implements
14363     to always fail with ENOSYS.  Some functions are actually named
14364     something starting with __ and the normal name is an alias.  */
14365 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14366 choke me
14367 #else
14368 $ac_func();
14369 #endif
14370
14371 ; return 0; }
14372 EOF
14373 if { (eval echo configure:14374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14374   rm -rf conftest*
14375   eval "ac_cv_func_$ac_func=yes"
14376 else
14377   echo "configure: failed program was:" >&5
14378   cat conftest.$ac_ext >&5
14379   rm -rf conftest*
14380   eval "ac_cv_func_$ac_func=no"
14381 fi
14382 rm -f conftest*
14383 fi
14384
14385 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14386   echo "$ac_t""yes" 1>&6
14387     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14388   cat >> confdefs.h <<EOF
14389 #define $ac_tr_func 1
14390 EOF
14391
14392 else
14393   echo "$ac_t""no" 1>&6
14394 fi
14395 done
14396
14397   fi
14398
14399
14400   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
14401 echo "configure:14402: checking for _isinfl declaration" >&5
14402   if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
14403   echo $ac_n "(cached) $ac_c" 1>&6
14404 else
14405
14406
14407     ac_ext=C
14408 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14409 ac_cpp='$CXXCPP $CPPFLAGS'
14410 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14411 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14412 cross_compiling=$ac_cv_prog_cxx_cross
14413
14414     cat > conftest.$ac_ext <<EOF
14415 #line 14416 "configure"
14416 #include "confdefs.h"
14417 #include <math.h>
14418 int main() {
14419  _isinfl(0);
14420 ; return 0; }
14421 EOF
14422 if { (eval echo configure:14423: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14423   rm -rf conftest*
14424   glibcpp_cv_func__isinfl_use=yes
14425 else
14426   echo "configure: failed program was:" >&5
14427   cat conftest.$ac_ext >&5
14428   rm -rf conftest*
14429   glibcpp_cv_func__isinfl_use=no
14430 fi
14431 rm -f conftest*
14432     ac_ext=c
14433 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14434 ac_cpp='$CPP $CPPFLAGS'
14435 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14436 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14437 cross_compiling=$ac_cv_prog_cc_cross
14438
14439
14440 fi
14441
14442   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
14443   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
14444     for ac_func in _isinfl
14445 do
14446 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14447 echo "configure:14448: checking for $ac_func" >&5
14448 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14449   echo $ac_n "(cached) $ac_c" 1>&6
14450 else
14451   cat > conftest.$ac_ext <<EOF
14452 #line 14453 "configure"
14453 #include "confdefs.h"
14454 /* System header to define __stub macros and hopefully few prototypes,
14455     which can conflict with char $ac_func(); below.  */
14456 #include <assert.h>
14457 /* Override any gcc2 internal prototype to avoid an error.  */
14458 /* We use char because int might match the return type of a gcc2
14459     builtin and then its argument prototype would still apply.  */
14460 char $ac_func();
14461
14462 int main() {
14463
14464 /* The GNU C library defines this for functions which it implements
14465     to always fail with ENOSYS.  Some functions are actually named
14466     something starting with __ and the normal name is an alias.  */
14467 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14468 choke me
14469 #else
14470 $ac_func();
14471 #endif
14472
14473 ; return 0; }
14474 EOF
14475 if { (eval echo configure:14476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14476   rm -rf conftest*
14477   eval "ac_cv_func_$ac_func=yes"
14478 else
14479   echo "configure: failed program was:" >&5
14480   cat conftest.$ac_ext >&5
14481   rm -rf conftest*
14482   eval "ac_cv_func_$ac_func=no"
14483 fi
14484 rm -f conftest*
14485 fi
14486
14487 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14488   echo "$ac_t""yes" 1>&6
14489     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14490   cat >> confdefs.h <<EOF
14491 #define $ac_tr_func 1
14492 EOF
14493
14494 else
14495   echo "$ac_t""no" 1>&6
14496 fi
14497 done
14498
14499   fi
14500
14501
14502   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
14503 echo "configure:14504: checking for _copysignl declaration" >&5
14504   if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
14505   echo $ac_n "(cached) $ac_c" 1>&6
14506 else
14507
14508
14509     ac_ext=C
14510 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14511 ac_cpp='$CXXCPP $CPPFLAGS'
14512 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14513 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14514 cross_compiling=$ac_cv_prog_cxx_cross
14515
14516     cat > conftest.$ac_ext <<EOF
14517 #line 14518 "configure"
14518 #include "confdefs.h"
14519 #include <math.h>
14520 int main() {
14521  _copysignl(0, 0);
14522 ; return 0; }
14523 EOF
14524 if { (eval echo configure:14525: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14525   rm -rf conftest*
14526   glibcpp_cv_func__copysignl_use=yes
14527 else
14528   echo "configure: failed program was:" >&5
14529   cat conftest.$ac_ext >&5
14530   rm -rf conftest*
14531   glibcpp_cv_func__copysignl_use=no
14532 fi
14533 rm -f conftest*
14534     ac_ext=c
14535 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14536 ac_cpp='$CPP $CPPFLAGS'
14537 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14538 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14539 cross_compiling=$ac_cv_prog_cc_cross
14540
14541
14542 fi
14543
14544   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
14545   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
14546     for ac_func in _copysignl
14547 do
14548 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14549 echo "configure:14550: checking for $ac_func" >&5
14550 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14551   echo $ac_n "(cached) $ac_c" 1>&6
14552 else
14553   cat > conftest.$ac_ext <<EOF
14554 #line 14555 "configure"
14555 #include "confdefs.h"
14556 /* System header to define __stub macros and hopefully few prototypes,
14557     which can conflict with char $ac_func(); below.  */
14558 #include <assert.h>
14559 /* Override any gcc2 internal prototype to avoid an error.  */
14560 /* We use char because int might match the return type of a gcc2
14561     builtin and then its argument prototype would still apply.  */
14562 char $ac_func();
14563
14564 int main() {
14565
14566 /* The GNU C library defines this for functions which it implements
14567     to always fail with ENOSYS.  Some functions are actually named
14568     something starting with __ and the normal name is an alias.  */
14569 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14570 choke me
14571 #else
14572 $ac_func();
14573 #endif
14574
14575 ; return 0; }
14576 EOF
14577 if { (eval echo configure:14578: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14578   rm -rf conftest*
14579   eval "ac_cv_func_$ac_func=yes"
14580 else
14581   echo "configure: failed program was:" >&5
14582   cat conftest.$ac_ext >&5
14583   rm -rf conftest*
14584   eval "ac_cv_func_$ac_func=no"
14585 fi
14586 rm -f conftest*
14587 fi
14588
14589 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14590   echo "$ac_t""yes" 1>&6
14591     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14592   cat >> confdefs.h <<EOF
14593 #define $ac_tr_func 1
14594 EOF
14595
14596 else
14597   echo "$ac_t""no" 1>&6
14598 fi
14599 done
14600
14601   fi
14602
14603
14604   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14605 echo "configure:14606: checking for _acosl declaration" >&5
14606   if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
14607   echo $ac_n "(cached) $ac_c" 1>&6
14608 else
14609
14610
14611     ac_ext=C
14612 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14613 ac_cpp='$CXXCPP $CPPFLAGS'
14614 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14615 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14616 cross_compiling=$ac_cv_prog_cxx_cross
14617
14618     cat > conftest.$ac_ext <<EOF
14619 #line 14620 "configure"
14620 #include "confdefs.h"
14621 #include <math.h>
14622 int main() {
14623  _acosl(0);
14624 ; return 0; }
14625 EOF
14626 if { (eval echo configure:14627: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14627   rm -rf conftest*
14628   glibcpp_cv_func__acosl_use=yes
14629 else
14630   echo "configure: failed program was:" >&5
14631   cat conftest.$ac_ext >&5
14632   rm -rf conftest*
14633   glibcpp_cv_func__acosl_use=no
14634 fi
14635 rm -f conftest*
14636     ac_ext=c
14637 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14638 ac_cpp='$CPP $CPPFLAGS'
14639 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14640 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14641 cross_compiling=$ac_cv_prog_cc_cross
14642
14643
14644 fi
14645
14646   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
14647   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
14648     for ac_func in _acosl
14649 do
14650 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14651 echo "configure:14652: checking for $ac_func" >&5
14652 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14653   echo $ac_n "(cached) $ac_c" 1>&6
14654 else
14655   cat > conftest.$ac_ext <<EOF
14656 #line 14657 "configure"
14657 #include "confdefs.h"
14658 /* System header to define __stub macros and hopefully few prototypes,
14659     which can conflict with char $ac_func(); below.  */
14660 #include <assert.h>
14661 /* Override any gcc2 internal prototype to avoid an error.  */
14662 /* We use char because int might match the return type of a gcc2
14663     builtin and then its argument prototype would still apply.  */
14664 char $ac_func();
14665
14666 int main() {
14667
14668 /* The GNU C library defines this for functions which it implements
14669     to always fail with ENOSYS.  Some functions are actually named
14670     something starting with __ and the normal name is an alias.  */
14671 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14672 choke me
14673 #else
14674 $ac_func();
14675 #endif
14676
14677 ; return 0; }
14678 EOF
14679 if { (eval echo configure:14680: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14680   rm -rf conftest*
14681   eval "ac_cv_func_$ac_func=yes"
14682 else
14683   echo "configure: failed program was:" >&5
14684   cat conftest.$ac_ext >&5
14685   rm -rf conftest*
14686   eval "ac_cv_func_$ac_func=no"
14687 fi
14688 rm -f conftest*
14689 fi
14690
14691 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14692   echo "$ac_t""yes" 1>&6
14693     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14694   cat >> confdefs.h <<EOF
14695 #define $ac_tr_func 1
14696 EOF
14697
14698 else
14699   echo "$ac_t""no" 1>&6
14700 fi
14701 done
14702
14703   fi
14704
14705
14706   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14707 echo "configure:14708: checking for _asinl declaration" >&5
14708   if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
14709   echo $ac_n "(cached) $ac_c" 1>&6
14710 else
14711
14712
14713     ac_ext=C
14714 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14715 ac_cpp='$CXXCPP $CPPFLAGS'
14716 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14717 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14718 cross_compiling=$ac_cv_prog_cxx_cross
14719
14720     cat > conftest.$ac_ext <<EOF
14721 #line 14722 "configure"
14722 #include "confdefs.h"
14723 #include <math.h>
14724 int main() {
14725  _asinl(0);
14726 ; return 0; }
14727 EOF
14728 if { (eval echo configure:14729: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14729   rm -rf conftest*
14730   glibcpp_cv_func__asinl_use=yes
14731 else
14732   echo "configure: failed program was:" >&5
14733   cat conftest.$ac_ext >&5
14734   rm -rf conftest*
14735   glibcpp_cv_func__asinl_use=no
14736 fi
14737 rm -f conftest*
14738     ac_ext=c
14739 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14740 ac_cpp='$CPP $CPPFLAGS'
14741 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14742 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14743 cross_compiling=$ac_cv_prog_cc_cross
14744
14745
14746 fi
14747
14748   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
14749   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
14750     for ac_func in _asinl
14751 do
14752 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14753 echo "configure:14754: checking for $ac_func" >&5
14754 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14755   echo $ac_n "(cached) $ac_c" 1>&6
14756 else
14757   cat > conftest.$ac_ext <<EOF
14758 #line 14759 "configure"
14759 #include "confdefs.h"
14760 /* System header to define __stub macros and hopefully few prototypes,
14761     which can conflict with char $ac_func(); below.  */
14762 #include <assert.h>
14763 /* Override any gcc2 internal prototype to avoid an error.  */
14764 /* We use char because int might match the return type of a gcc2
14765     builtin and then its argument prototype would still apply.  */
14766 char $ac_func();
14767
14768 int main() {
14769
14770 /* The GNU C library defines this for functions which it implements
14771     to always fail with ENOSYS.  Some functions are actually named
14772     something starting with __ and the normal name is an alias.  */
14773 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14774 choke me
14775 #else
14776 $ac_func();
14777 #endif
14778
14779 ; return 0; }
14780 EOF
14781 if { (eval echo configure:14782: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14782   rm -rf conftest*
14783   eval "ac_cv_func_$ac_func=yes"
14784 else
14785   echo "configure: failed program was:" >&5
14786   cat conftest.$ac_ext >&5
14787   rm -rf conftest*
14788   eval "ac_cv_func_$ac_func=no"
14789 fi
14790 rm -f conftest*
14791 fi
14792
14793 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14794   echo "$ac_t""yes" 1>&6
14795     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14796   cat >> confdefs.h <<EOF
14797 #define $ac_tr_func 1
14798 EOF
14799
14800 else
14801   echo "$ac_t""no" 1>&6
14802 fi
14803 done
14804
14805   fi
14806
14807
14808   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14809 echo "configure:14810: checking for _atanl declaration" >&5
14810   if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
14811   echo $ac_n "(cached) $ac_c" 1>&6
14812 else
14813
14814
14815     ac_ext=C
14816 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14817 ac_cpp='$CXXCPP $CPPFLAGS'
14818 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14819 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14820 cross_compiling=$ac_cv_prog_cxx_cross
14821
14822     cat > conftest.$ac_ext <<EOF
14823 #line 14824 "configure"
14824 #include "confdefs.h"
14825 #include <math.h>
14826 int main() {
14827  _atanl(0);
14828 ; return 0; }
14829 EOF
14830 if { (eval echo configure:14831: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14831   rm -rf conftest*
14832   glibcpp_cv_func__atanl_use=yes
14833 else
14834   echo "configure: failed program was:" >&5
14835   cat conftest.$ac_ext >&5
14836   rm -rf conftest*
14837   glibcpp_cv_func__atanl_use=no
14838 fi
14839 rm -f conftest*
14840     ac_ext=c
14841 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14842 ac_cpp='$CPP $CPPFLAGS'
14843 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14844 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14845 cross_compiling=$ac_cv_prog_cc_cross
14846
14847
14848 fi
14849
14850   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
14851   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
14852     for ac_func in _atanl
14853 do
14854 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14855 echo "configure:14856: checking for $ac_func" >&5
14856 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14857   echo $ac_n "(cached) $ac_c" 1>&6
14858 else
14859   cat > conftest.$ac_ext <<EOF
14860 #line 14861 "configure"
14861 #include "confdefs.h"
14862 /* System header to define __stub macros and hopefully few prototypes,
14863     which can conflict with char $ac_func(); below.  */
14864 #include <assert.h>
14865 /* Override any gcc2 internal prototype to avoid an error.  */
14866 /* We use char because int might match the return type of a gcc2
14867     builtin and then its argument prototype would still apply.  */
14868 char $ac_func();
14869
14870 int main() {
14871
14872 /* The GNU C library defines this for functions which it implements
14873     to always fail with ENOSYS.  Some functions are actually named
14874     something starting with __ and the normal name is an alias.  */
14875 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14876 choke me
14877 #else
14878 $ac_func();
14879 #endif
14880
14881 ; return 0; }
14882 EOF
14883 if { (eval echo configure:14884: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14884   rm -rf conftest*
14885   eval "ac_cv_func_$ac_func=yes"
14886 else
14887   echo "configure: failed program was:" >&5
14888   cat conftest.$ac_ext >&5
14889   rm -rf conftest*
14890   eval "ac_cv_func_$ac_func=no"
14891 fi
14892 rm -f conftest*
14893 fi
14894
14895 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14896   echo "$ac_t""yes" 1>&6
14897     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14898   cat >> confdefs.h <<EOF
14899 #define $ac_tr_func 1
14900 EOF
14901
14902 else
14903   echo "$ac_t""no" 1>&6
14904 fi
14905 done
14906
14907   fi
14908
14909
14910   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14911 echo "configure:14912: checking for _atan2l declaration" >&5
14912   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
14913   echo $ac_n "(cached) $ac_c" 1>&6
14914 else
14915
14916
14917     ac_ext=C
14918 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14919 ac_cpp='$CXXCPP $CPPFLAGS'
14920 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14921 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14922 cross_compiling=$ac_cv_prog_cxx_cross
14923
14924     cat > conftest.$ac_ext <<EOF
14925 #line 14926 "configure"
14926 #include "confdefs.h"
14927 #include <math.h>
14928 int main() {
14929  _atan2l(0, 0);
14930 ; return 0; }
14931 EOF
14932 if { (eval echo configure:14933: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14933   rm -rf conftest*
14934   glibcpp_cv_func__atan2l_use=yes
14935 else
14936   echo "configure: failed program was:" >&5
14937   cat conftest.$ac_ext >&5
14938   rm -rf conftest*
14939   glibcpp_cv_func__atan2l_use=no
14940 fi
14941 rm -f conftest*
14942     ac_ext=c
14943 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14944 ac_cpp='$CPP $CPPFLAGS'
14945 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14946 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14947 cross_compiling=$ac_cv_prog_cc_cross
14948
14949
14950 fi
14951
14952   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
14953   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
14954     for ac_func in _atan2l
14955 do
14956 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14957 echo "configure:14958: checking for $ac_func" >&5
14958 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14959   echo $ac_n "(cached) $ac_c" 1>&6
14960 else
14961   cat > conftest.$ac_ext <<EOF
14962 #line 14963 "configure"
14963 #include "confdefs.h"
14964 /* System header to define __stub macros and hopefully few prototypes,
14965     which can conflict with char $ac_func(); below.  */
14966 #include <assert.h>
14967 /* Override any gcc2 internal prototype to avoid an error.  */
14968 /* We use char because int might match the return type of a gcc2
14969     builtin and then its argument prototype would still apply.  */
14970 char $ac_func();
14971
14972 int main() {
14973
14974 /* The GNU C library defines this for functions which it implements
14975     to always fail with ENOSYS.  Some functions are actually named
14976     something starting with __ and the normal name is an alias.  */
14977 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14978 choke me
14979 #else
14980 $ac_func();
14981 #endif
14982
14983 ; return 0; }
14984 EOF
14985 if { (eval echo configure:14986: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14986   rm -rf conftest*
14987   eval "ac_cv_func_$ac_func=yes"
14988 else
14989   echo "configure: failed program was:" >&5
14990   cat conftest.$ac_ext >&5
14991   rm -rf conftest*
14992   eval "ac_cv_func_$ac_func=no"
14993 fi
14994 rm -f conftest*
14995 fi
14996
14997 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14998   echo "$ac_t""yes" 1>&6
14999     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15000   cat >> confdefs.h <<EOF
15001 #define $ac_tr_func 1
15002 EOF
15003
15004 else
15005   echo "$ac_t""no" 1>&6
15006 fi
15007 done
15008
15009   fi
15010
15011
15012   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
15013 echo "configure:15014: checking for _ceill declaration" >&5
15014   if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
15015   echo $ac_n "(cached) $ac_c" 1>&6
15016 else
15017
15018
15019     ac_ext=C
15020 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15021 ac_cpp='$CXXCPP $CPPFLAGS'
15022 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15023 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15024 cross_compiling=$ac_cv_prog_cxx_cross
15025
15026     cat > conftest.$ac_ext <<EOF
15027 #line 15028 "configure"
15028 #include "confdefs.h"
15029 #include <math.h>
15030 int main() {
15031  _ceill(0);
15032 ; return 0; }
15033 EOF
15034 if { (eval echo configure:15035: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15035   rm -rf conftest*
15036   glibcpp_cv_func__ceill_use=yes
15037 else
15038   echo "configure: failed program was:" >&5
15039   cat conftest.$ac_ext >&5
15040   rm -rf conftest*
15041   glibcpp_cv_func__ceill_use=no
15042 fi
15043 rm -f conftest*
15044     ac_ext=c
15045 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15046 ac_cpp='$CPP $CPPFLAGS'
15047 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15048 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15049 cross_compiling=$ac_cv_prog_cc_cross
15050
15051
15052 fi
15053
15054   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
15055   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
15056     for ac_func in _ceill
15057 do
15058 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15059 echo "configure:15060: checking for $ac_func" >&5
15060 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15061   echo $ac_n "(cached) $ac_c" 1>&6
15062 else
15063   cat > conftest.$ac_ext <<EOF
15064 #line 15065 "configure"
15065 #include "confdefs.h"
15066 /* System header to define __stub macros and hopefully few prototypes,
15067     which can conflict with char $ac_func(); below.  */
15068 #include <assert.h>
15069 /* Override any gcc2 internal prototype to avoid an error.  */
15070 /* We use char because int might match the return type of a gcc2
15071     builtin and then its argument prototype would still apply.  */
15072 char $ac_func();
15073
15074 int main() {
15075
15076 /* The GNU C library defines this for functions which it implements
15077     to always fail with ENOSYS.  Some functions are actually named
15078     something starting with __ and the normal name is an alias.  */
15079 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15080 choke me
15081 #else
15082 $ac_func();
15083 #endif
15084
15085 ; return 0; }
15086 EOF
15087 if { (eval echo configure:15088: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15088   rm -rf conftest*
15089   eval "ac_cv_func_$ac_func=yes"
15090 else
15091   echo "configure: failed program was:" >&5
15092   cat conftest.$ac_ext >&5
15093   rm -rf conftest*
15094   eval "ac_cv_func_$ac_func=no"
15095 fi
15096 rm -f conftest*
15097 fi
15098
15099 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15100   echo "$ac_t""yes" 1>&6
15101     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15102   cat >> confdefs.h <<EOF
15103 #define $ac_tr_func 1
15104 EOF
15105
15106 else
15107   echo "$ac_t""no" 1>&6
15108 fi
15109 done
15110
15111   fi
15112
15113
15114   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
15115 echo "configure:15116: checking for _cosl declaration" >&5
15116   if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
15117   echo $ac_n "(cached) $ac_c" 1>&6
15118 else
15119
15120
15121     ac_ext=C
15122 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15123 ac_cpp='$CXXCPP $CPPFLAGS'
15124 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15125 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15126 cross_compiling=$ac_cv_prog_cxx_cross
15127
15128     cat > conftest.$ac_ext <<EOF
15129 #line 15130 "configure"
15130 #include "confdefs.h"
15131 #include <math.h>
15132 int main() {
15133  _cosl(0);
15134 ; return 0; }
15135 EOF
15136 if { (eval echo configure:15137: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15137   rm -rf conftest*
15138   glibcpp_cv_func__cosl_use=yes
15139 else
15140   echo "configure: failed program was:" >&5
15141   cat conftest.$ac_ext >&5
15142   rm -rf conftest*
15143   glibcpp_cv_func__cosl_use=no
15144 fi
15145 rm -f conftest*
15146     ac_ext=c
15147 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15148 ac_cpp='$CPP $CPPFLAGS'
15149 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15150 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15151 cross_compiling=$ac_cv_prog_cc_cross
15152
15153
15154 fi
15155
15156   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
15157   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
15158     for ac_func in _cosl
15159 do
15160 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15161 echo "configure:15162: checking for $ac_func" >&5
15162 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15163   echo $ac_n "(cached) $ac_c" 1>&6
15164 else
15165   cat > conftest.$ac_ext <<EOF
15166 #line 15167 "configure"
15167 #include "confdefs.h"
15168 /* System header to define __stub macros and hopefully few prototypes,
15169     which can conflict with char $ac_func(); below.  */
15170 #include <assert.h>
15171 /* Override any gcc2 internal prototype to avoid an error.  */
15172 /* We use char because int might match the return type of a gcc2
15173     builtin and then its argument prototype would still apply.  */
15174 char $ac_func();
15175
15176 int main() {
15177
15178 /* The GNU C library defines this for functions which it implements
15179     to always fail with ENOSYS.  Some functions are actually named
15180     something starting with __ and the normal name is an alias.  */
15181 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15182 choke me
15183 #else
15184 $ac_func();
15185 #endif
15186
15187 ; return 0; }
15188 EOF
15189 if { (eval echo configure:15190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15190   rm -rf conftest*
15191   eval "ac_cv_func_$ac_func=yes"
15192 else
15193   echo "configure: failed program was:" >&5
15194   cat conftest.$ac_ext >&5
15195   rm -rf conftest*
15196   eval "ac_cv_func_$ac_func=no"
15197 fi
15198 rm -f conftest*
15199 fi
15200
15201 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15202   echo "$ac_t""yes" 1>&6
15203     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15204   cat >> confdefs.h <<EOF
15205 #define $ac_tr_func 1
15206 EOF
15207
15208 else
15209   echo "$ac_t""no" 1>&6
15210 fi
15211 done
15212
15213   fi
15214
15215
15216   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
15217 echo "configure:15218: checking for _coshl declaration" >&5
15218   if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
15219   echo $ac_n "(cached) $ac_c" 1>&6
15220 else
15221
15222
15223     ac_ext=C
15224 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15225 ac_cpp='$CXXCPP $CPPFLAGS'
15226 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15227 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15228 cross_compiling=$ac_cv_prog_cxx_cross
15229
15230     cat > conftest.$ac_ext <<EOF
15231 #line 15232 "configure"
15232 #include "confdefs.h"
15233 #include <math.h>
15234 int main() {
15235  _coshl(0);
15236 ; return 0; }
15237 EOF
15238 if { (eval echo configure:15239: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15239   rm -rf conftest*
15240   glibcpp_cv_func__coshl_use=yes
15241 else
15242   echo "configure: failed program was:" >&5
15243   cat conftest.$ac_ext >&5
15244   rm -rf conftest*
15245   glibcpp_cv_func__coshl_use=no
15246 fi
15247 rm -f conftest*
15248     ac_ext=c
15249 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15250 ac_cpp='$CPP $CPPFLAGS'
15251 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15252 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15253 cross_compiling=$ac_cv_prog_cc_cross
15254
15255
15256 fi
15257
15258   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
15259   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
15260     for ac_func in _coshl
15261 do
15262 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15263 echo "configure:15264: checking for $ac_func" >&5
15264 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15265   echo $ac_n "(cached) $ac_c" 1>&6
15266 else
15267   cat > conftest.$ac_ext <<EOF
15268 #line 15269 "configure"
15269 #include "confdefs.h"
15270 /* System header to define __stub macros and hopefully few prototypes,
15271     which can conflict with char $ac_func(); below.  */
15272 #include <assert.h>
15273 /* Override any gcc2 internal prototype to avoid an error.  */
15274 /* We use char because int might match the return type of a gcc2
15275     builtin and then its argument prototype would still apply.  */
15276 char $ac_func();
15277
15278 int main() {
15279
15280 /* The GNU C library defines this for functions which it implements
15281     to always fail with ENOSYS.  Some functions are actually named
15282     something starting with __ and the normal name is an alias.  */
15283 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15284 choke me
15285 #else
15286 $ac_func();
15287 #endif
15288
15289 ; return 0; }
15290 EOF
15291 if { (eval echo configure:15292: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15292   rm -rf conftest*
15293   eval "ac_cv_func_$ac_func=yes"
15294 else
15295   echo "configure: failed program was:" >&5
15296   cat conftest.$ac_ext >&5
15297   rm -rf conftest*
15298   eval "ac_cv_func_$ac_func=no"
15299 fi
15300 rm -f conftest*
15301 fi
15302
15303 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15304   echo "$ac_t""yes" 1>&6
15305     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15306   cat >> confdefs.h <<EOF
15307 #define $ac_tr_func 1
15308 EOF
15309
15310 else
15311   echo "$ac_t""no" 1>&6
15312 fi
15313 done
15314
15315   fi
15316
15317
15318   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
15319 echo "configure:15320: checking for _expl declaration" >&5
15320   if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
15321   echo $ac_n "(cached) $ac_c" 1>&6
15322 else
15323
15324
15325     ac_ext=C
15326 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15327 ac_cpp='$CXXCPP $CPPFLAGS'
15328 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15329 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15330 cross_compiling=$ac_cv_prog_cxx_cross
15331
15332     cat > conftest.$ac_ext <<EOF
15333 #line 15334 "configure"
15334 #include "confdefs.h"
15335 #include <math.h>
15336 int main() {
15337  _expl(0);
15338 ; return 0; }
15339 EOF
15340 if { (eval echo configure:15341: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15341   rm -rf conftest*
15342   glibcpp_cv_func__expl_use=yes
15343 else
15344   echo "configure: failed program was:" >&5
15345   cat conftest.$ac_ext >&5
15346   rm -rf conftest*
15347   glibcpp_cv_func__expl_use=no
15348 fi
15349 rm -f conftest*
15350     ac_ext=c
15351 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15352 ac_cpp='$CPP $CPPFLAGS'
15353 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15354 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15355 cross_compiling=$ac_cv_prog_cc_cross
15356
15357
15358 fi
15359
15360   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
15361   if test x$glibcpp_cv_func__expl_use = x"yes"; then
15362     for ac_func in _expl
15363 do
15364 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15365 echo "configure:15366: checking for $ac_func" >&5
15366 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15367   echo $ac_n "(cached) $ac_c" 1>&6
15368 else
15369   cat > conftest.$ac_ext <<EOF
15370 #line 15371 "configure"
15371 #include "confdefs.h"
15372 /* System header to define __stub macros and hopefully few prototypes,
15373     which can conflict with char $ac_func(); below.  */
15374 #include <assert.h>
15375 /* Override any gcc2 internal prototype to avoid an error.  */
15376 /* We use char because int might match the return type of a gcc2
15377     builtin and then its argument prototype would still apply.  */
15378 char $ac_func();
15379
15380 int main() {
15381
15382 /* The GNU C library defines this for functions which it implements
15383     to always fail with ENOSYS.  Some functions are actually named
15384     something starting with __ and the normal name is an alias.  */
15385 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15386 choke me
15387 #else
15388 $ac_func();
15389 #endif
15390
15391 ; return 0; }
15392 EOF
15393 if { (eval echo configure:15394: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15394   rm -rf conftest*
15395   eval "ac_cv_func_$ac_func=yes"
15396 else
15397   echo "configure: failed program was:" >&5
15398   cat conftest.$ac_ext >&5
15399   rm -rf conftest*
15400   eval "ac_cv_func_$ac_func=no"
15401 fi
15402 rm -f conftest*
15403 fi
15404
15405 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15406   echo "$ac_t""yes" 1>&6
15407     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15408   cat >> confdefs.h <<EOF
15409 #define $ac_tr_func 1
15410 EOF
15411
15412 else
15413   echo "$ac_t""no" 1>&6
15414 fi
15415 done
15416
15417   fi
15418
15419
15420   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
15421 echo "configure:15422: checking for _fabsl declaration" >&5
15422   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
15423   echo $ac_n "(cached) $ac_c" 1>&6
15424 else
15425
15426
15427     ac_ext=C
15428 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15429 ac_cpp='$CXXCPP $CPPFLAGS'
15430 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15431 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15432 cross_compiling=$ac_cv_prog_cxx_cross
15433
15434     cat > conftest.$ac_ext <<EOF
15435 #line 15436 "configure"
15436 #include "confdefs.h"
15437 #include <math.h>
15438 int main() {
15439  _fabsl(0);
15440 ; return 0; }
15441 EOF
15442 if { (eval echo configure:15443: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15443   rm -rf conftest*
15444   glibcpp_cv_func__fabsl_use=yes
15445 else
15446   echo "configure: failed program was:" >&5
15447   cat conftest.$ac_ext >&5
15448   rm -rf conftest*
15449   glibcpp_cv_func__fabsl_use=no
15450 fi
15451 rm -f conftest*
15452     ac_ext=c
15453 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15454 ac_cpp='$CPP $CPPFLAGS'
15455 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15456 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15457 cross_compiling=$ac_cv_prog_cc_cross
15458
15459
15460 fi
15461
15462   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
15463   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
15464     for ac_func in _fabsl
15465 do
15466 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15467 echo "configure:15468: checking for $ac_func" >&5
15468 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15469   echo $ac_n "(cached) $ac_c" 1>&6
15470 else
15471   cat > conftest.$ac_ext <<EOF
15472 #line 15473 "configure"
15473 #include "confdefs.h"
15474 /* System header to define __stub macros and hopefully few prototypes,
15475     which can conflict with char $ac_func(); below.  */
15476 #include <assert.h>
15477 /* Override any gcc2 internal prototype to avoid an error.  */
15478 /* We use char because int might match the return type of a gcc2
15479     builtin and then its argument prototype would still apply.  */
15480 char $ac_func();
15481
15482 int main() {
15483
15484 /* The GNU C library defines this for functions which it implements
15485     to always fail with ENOSYS.  Some functions are actually named
15486     something starting with __ and the normal name is an alias.  */
15487 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15488 choke me
15489 #else
15490 $ac_func();
15491 #endif
15492
15493 ; return 0; }
15494 EOF
15495 if { (eval echo configure:15496: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15496   rm -rf conftest*
15497   eval "ac_cv_func_$ac_func=yes"
15498 else
15499   echo "configure: failed program was:" >&5
15500   cat conftest.$ac_ext >&5
15501   rm -rf conftest*
15502   eval "ac_cv_func_$ac_func=no"
15503 fi
15504 rm -f conftest*
15505 fi
15506
15507 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15508   echo "$ac_t""yes" 1>&6
15509     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15510   cat >> confdefs.h <<EOF
15511 #define $ac_tr_func 1
15512 EOF
15513
15514 else
15515   echo "$ac_t""no" 1>&6
15516 fi
15517 done
15518
15519   fi
15520
15521
15522   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
15523 echo "configure:15524: checking for _floorl declaration" >&5
15524   if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
15525   echo $ac_n "(cached) $ac_c" 1>&6
15526 else
15527
15528
15529     ac_ext=C
15530 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15531 ac_cpp='$CXXCPP $CPPFLAGS'
15532 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15533 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15534 cross_compiling=$ac_cv_prog_cxx_cross
15535
15536     cat > conftest.$ac_ext <<EOF
15537 #line 15538 "configure"
15538 #include "confdefs.h"
15539 #include <math.h>
15540 int main() {
15541  _floorl(0);
15542 ; return 0; }
15543 EOF
15544 if { (eval echo configure:15545: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15545   rm -rf conftest*
15546   glibcpp_cv_func__floorl_use=yes
15547 else
15548   echo "configure: failed program was:" >&5
15549   cat conftest.$ac_ext >&5
15550   rm -rf conftest*
15551   glibcpp_cv_func__floorl_use=no
15552 fi
15553 rm -f conftest*
15554     ac_ext=c
15555 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15556 ac_cpp='$CPP $CPPFLAGS'
15557 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15558 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15559 cross_compiling=$ac_cv_prog_cc_cross
15560
15561
15562 fi
15563
15564   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
15565   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
15566     for ac_func in _floorl
15567 do
15568 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15569 echo "configure:15570: checking for $ac_func" >&5
15570 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15571   echo $ac_n "(cached) $ac_c" 1>&6
15572 else
15573   cat > conftest.$ac_ext <<EOF
15574 #line 15575 "configure"
15575 #include "confdefs.h"
15576 /* System header to define __stub macros and hopefully few prototypes,
15577     which can conflict with char $ac_func(); below.  */
15578 #include <assert.h>
15579 /* Override any gcc2 internal prototype to avoid an error.  */
15580 /* We use char because int might match the return type of a gcc2
15581     builtin and then its argument prototype would still apply.  */
15582 char $ac_func();
15583
15584 int main() {
15585
15586 /* The GNU C library defines this for functions which it implements
15587     to always fail with ENOSYS.  Some functions are actually named
15588     something starting with __ and the normal name is an alias.  */
15589 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15590 choke me
15591 #else
15592 $ac_func();
15593 #endif
15594
15595 ; return 0; }
15596 EOF
15597 if { (eval echo configure:15598: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15598   rm -rf conftest*
15599   eval "ac_cv_func_$ac_func=yes"
15600 else
15601   echo "configure: failed program was:" >&5
15602   cat conftest.$ac_ext >&5
15603   rm -rf conftest*
15604   eval "ac_cv_func_$ac_func=no"
15605 fi
15606 rm -f conftest*
15607 fi
15608
15609 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15610   echo "$ac_t""yes" 1>&6
15611     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15612   cat >> confdefs.h <<EOF
15613 #define $ac_tr_func 1
15614 EOF
15615
15616 else
15617   echo "$ac_t""no" 1>&6
15618 fi
15619 done
15620
15621   fi
15622
15623
15624   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
15625 echo "configure:15626: checking for _fmodl declaration" >&5
15626   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
15627   echo $ac_n "(cached) $ac_c" 1>&6
15628 else
15629
15630
15631     ac_ext=C
15632 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15633 ac_cpp='$CXXCPP $CPPFLAGS'
15634 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15635 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15636 cross_compiling=$ac_cv_prog_cxx_cross
15637
15638     cat > conftest.$ac_ext <<EOF
15639 #line 15640 "configure"
15640 #include "confdefs.h"
15641 #include <math.h>
15642 int main() {
15643  _fmodl(0, 0);
15644 ; return 0; }
15645 EOF
15646 if { (eval echo configure:15647: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15647   rm -rf conftest*
15648   glibcpp_cv_func__fmodl_use=yes
15649 else
15650   echo "configure: failed program was:" >&5
15651   cat conftest.$ac_ext >&5
15652   rm -rf conftest*
15653   glibcpp_cv_func__fmodl_use=no
15654 fi
15655 rm -f conftest*
15656     ac_ext=c
15657 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15658 ac_cpp='$CPP $CPPFLAGS'
15659 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15660 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15661 cross_compiling=$ac_cv_prog_cc_cross
15662
15663
15664 fi
15665
15666   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
15667   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
15668     for ac_func in _fmodl
15669 do
15670 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15671 echo "configure:15672: checking for $ac_func" >&5
15672 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15673   echo $ac_n "(cached) $ac_c" 1>&6
15674 else
15675   cat > conftest.$ac_ext <<EOF
15676 #line 15677 "configure"
15677 #include "confdefs.h"
15678 /* System header to define __stub macros and hopefully few prototypes,
15679     which can conflict with char $ac_func(); below.  */
15680 #include <assert.h>
15681 /* Override any gcc2 internal prototype to avoid an error.  */
15682 /* We use char because int might match the return type of a gcc2
15683     builtin and then its argument prototype would still apply.  */
15684 char $ac_func();
15685
15686 int main() {
15687
15688 /* The GNU C library defines this for functions which it implements
15689     to always fail with ENOSYS.  Some functions are actually named
15690     something starting with __ and the normal name is an alias.  */
15691 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15692 choke me
15693 #else
15694 $ac_func();
15695 #endif
15696
15697 ; return 0; }
15698 EOF
15699 if { (eval echo configure:15700: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15700   rm -rf conftest*
15701   eval "ac_cv_func_$ac_func=yes"
15702 else
15703   echo "configure: failed program was:" >&5
15704   cat conftest.$ac_ext >&5
15705   rm -rf conftest*
15706   eval "ac_cv_func_$ac_func=no"
15707 fi
15708 rm -f conftest*
15709 fi
15710
15711 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15712   echo "$ac_t""yes" 1>&6
15713     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15714   cat >> confdefs.h <<EOF
15715 #define $ac_tr_func 1
15716 EOF
15717
15718 else
15719   echo "$ac_t""no" 1>&6
15720 fi
15721 done
15722
15723   fi
15724
15725
15726   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15727 echo "configure:15728: checking for _frexpl declaration" >&5
15728   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
15729   echo $ac_n "(cached) $ac_c" 1>&6
15730 else
15731
15732
15733     ac_ext=C
15734 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15735 ac_cpp='$CXXCPP $CPPFLAGS'
15736 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15737 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15738 cross_compiling=$ac_cv_prog_cxx_cross
15739
15740     cat > conftest.$ac_ext <<EOF
15741 #line 15742 "configure"
15742 #include "confdefs.h"
15743 #include <math.h>
15744 int main() {
15745  _frexpl(0, 0);
15746 ; return 0; }
15747 EOF
15748 if { (eval echo configure:15749: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15749   rm -rf conftest*
15750   glibcpp_cv_func__frexpl_use=yes
15751 else
15752   echo "configure: failed program was:" >&5
15753   cat conftest.$ac_ext >&5
15754   rm -rf conftest*
15755   glibcpp_cv_func__frexpl_use=no
15756 fi
15757 rm -f conftest*
15758     ac_ext=c
15759 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15760 ac_cpp='$CPP $CPPFLAGS'
15761 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15762 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15763 cross_compiling=$ac_cv_prog_cc_cross
15764
15765
15766 fi
15767
15768   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
15769   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
15770     for ac_func in _frexpl
15771 do
15772 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15773 echo "configure:15774: checking for $ac_func" >&5
15774 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15775   echo $ac_n "(cached) $ac_c" 1>&6
15776 else
15777   cat > conftest.$ac_ext <<EOF
15778 #line 15779 "configure"
15779 #include "confdefs.h"
15780 /* System header to define __stub macros and hopefully few prototypes,
15781     which can conflict with char $ac_func(); below.  */
15782 #include <assert.h>
15783 /* Override any gcc2 internal prototype to avoid an error.  */
15784 /* We use char because int might match the return type of a gcc2
15785     builtin and then its argument prototype would still apply.  */
15786 char $ac_func();
15787
15788 int main() {
15789
15790 /* The GNU C library defines this for functions which it implements
15791     to always fail with ENOSYS.  Some functions are actually named
15792     something starting with __ and the normal name is an alias.  */
15793 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15794 choke me
15795 #else
15796 $ac_func();
15797 #endif
15798
15799 ; return 0; }
15800 EOF
15801 if { (eval echo configure:15802: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15802   rm -rf conftest*
15803   eval "ac_cv_func_$ac_func=yes"
15804 else
15805   echo "configure: failed program was:" >&5
15806   cat conftest.$ac_ext >&5
15807   rm -rf conftest*
15808   eval "ac_cv_func_$ac_func=no"
15809 fi
15810 rm -f conftest*
15811 fi
15812
15813 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15814   echo "$ac_t""yes" 1>&6
15815     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15816   cat >> confdefs.h <<EOF
15817 #define $ac_tr_func 1
15818 EOF
15819
15820 else
15821   echo "$ac_t""no" 1>&6
15822 fi
15823 done
15824
15825   fi
15826
15827
15828   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15829 echo "configure:15830: checking for _ldexpl declaration" >&5
15830   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
15831   echo $ac_n "(cached) $ac_c" 1>&6
15832 else
15833
15834
15835     ac_ext=C
15836 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15837 ac_cpp='$CXXCPP $CPPFLAGS'
15838 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15839 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15840 cross_compiling=$ac_cv_prog_cxx_cross
15841
15842     cat > conftest.$ac_ext <<EOF
15843 #line 15844 "configure"
15844 #include "confdefs.h"
15845 #include <math.h>
15846 int main() {
15847  _ldexpl(0, 0);
15848 ; return 0; }
15849 EOF
15850 if { (eval echo configure:15851: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15851   rm -rf conftest*
15852   glibcpp_cv_func__ldexpl_use=yes
15853 else
15854   echo "configure: failed program was:" >&5
15855   cat conftest.$ac_ext >&5
15856   rm -rf conftest*
15857   glibcpp_cv_func__ldexpl_use=no
15858 fi
15859 rm -f conftest*
15860     ac_ext=c
15861 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15862 ac_cpp='$CPP $CPPFLAGS'
15863 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15864 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15865 cross_compiling=$ac_cv_prog_cc_cross
15866
15867
15868 fi
15869
15870   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
15871   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
15872     for ac_func in _ldexpl
15873 do
15874 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15875 echo "configure:15876: checking for $ac_func" >&5
15876 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15877   echo $ac_n "(cached) $ac_c" 1>&6
15878 else
15879   cat > conftest.$ac_ext <<EOF
15880 #line 15881 "configure"
15881 #include "confdefs.h"
15882 /* System header to define __stub macros and hopefully few prototypes,
15883     which can conflict with char $ac_func(); below.  */
15884 #include <assert.h>
15885 /* Override any gcc2 internal prototype to avoid an error.  */
15886 /* We use char because int might match the return type of a gcc2
15887     builtin and then its argument prototype would still apply.  */
15888 char $ac_func();
15889
15890 int main() {
15891
15892 /* The GNU C library defines this for functions which it implements
15893     to always fail with ENOSYS.  Some functions are actually named
15894     something starting with __ and the normal name is an alias.  */
15895 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15896 choke me
15897 #else
15898 $ac_func();
15899 #endif
15900
15901 ; return 0; }
15902 EOF
15903 if { (eval echo configure:15904: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15904   rm -rf conftest*
15905   eval "ac_cv_func_$ac_func=yes"
15906 else
15907   echo "configure: failed program was:" >&5
15908   cat conftest.$ac_ext >&5
15909   rm -rf conftest*
15910   eval "ac_cv_func_$ac_func=no"
15911 fi
15912 rm -f conftest*
15913 fi
15914
15915 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15916   echo "$ac_t""yes" 1>&6
15917     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15918   cat >> confdefs.h <<EOF
15919 #define $ac_tr_func 1
15920 EOF
15921
15922 else
15923   echo "$ac_t""no" 1>&6
15924 fi
15925 done
15926
15927   fi
15928
15929
15930   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15931 echo "configure:15932: checking for _logl declaration" >&5
15932   if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
15933   echo $ac_n "(cached) $ac_c" 1>&6
15934 else
15935
15936
15937     ac_ext=C
15938 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15939 ac_cpp='$CXXCPP $CPPFLAGS'
15940 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15941 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15942 cross_compiling=$ac_cv_prog_cxx_cross
15943
15944     cat > conftest.$ac_ext <<EOF
15945 #line 15946 "configure"
15946 #include "confdefs.h"
15947 #include <math.h>
15948 int main() {
15949  _logl(0);
15950 ; return 0; }
15951 EOF
15952 if { (eval echo configure:15953: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15953   rm -rf conftest*
15954   glibcpp_cv_func__logl_use=yes
15955 else
15956   echo "configure: failed program was:" >&5
15957   cat conftest.$ac_ext >&5
15958   rm -rf conftest*
15959   glibcpp_cv_func__logl_use=no
15960 fi
15961 rm -f conftest*
15962     ac_ext=c
15963 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15964 ac_cpp='$CPP $CPPFLAGS'
15965 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15966 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15967 cross_compiling=$ac_cv_prog_cc_cross
15968
15969
15970 fi
15971
15972   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
15973   if test x$glibcpp_cv_func__logl_use = x"yes"; then
15974     for ac_func in _logl
15975 do
15976 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15977 echo "configure:15978: checking for $ac_func" >&5
15978 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15979   echo $ac_n "(cached) $ac_c" 1>&6
15980 else
15981   cat > conftest.$ac_ext <<EOF
15982 #line 15983 "configure"
15983 #include "confdefs.h"
15984 /* System header to define __stub macros and hopefully few prototypes,
15985     which can conflict with char $ac_func(); below.  */
15986 #include <assert.h>
15987 /* Override any gcc2 internal prototype to avoid an error.  */
15988 /* We use char because int might match the return type of a gcc2
15989     builtin and then its argument prototype would still apply.  */
15990 char $ac_func();
15991
15992 int main() {
15993
15994 /* The GNU C library defines this for functions which it implements
15995     to always fail with ENOSYS.  Some functions are actually named
15996     something starting with __ and the normal name is an alias.  */
15997 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15998 choke me
15999 #else
16000 $ac_func();
16001 #endif
16002
16003 ; return 0; }
16004 EOF
16005 if { (eval echo configure:16006: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16006   rm -rf conftest*
16007   eval "ac_cv_func_$ac_func=yes"
16008 else
16009   echo "configure: failed program was:" >&5
16010   cat conftest.$ac_ext >&5
16011   rm -rf conftest*
16012   eval "ac_cv_func_$ac_func=no"
16013 fi
16014 rm -f conftest*
16015 fi
16016
16017 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16018   echo "$ac_t""yes" 1>&6
16019     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16020   cat >> confdefs.h <<EOF
16021 #define $ac_tr_func 1
16022 EOF
16023
16024 else
16025   echo "$ac_t""no" 1>&6
16026 fi
16027 done
16028
16029   fi
16030
16031
16032   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
16033 echo "configure:16034: checking for _log10l declaration" >&5
16034   if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
16035   echo $ac_n "(cached) $ac_c" 1>&6
16036 else
16037
16038
16039     ac_ext=C
16040 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16041 ac_cpp='$CXXCPP $CPPFLAGS'
16042 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16043 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16044 cross_compiling=$ac_cv_prog_cxx_cross
16045
16046     cat > conftest.$ac_ext <<EOF
16047 #line 16048 "configure"
16048 #include "confdefs.h"
16049 #include <math.h>
16050 int main() {
16051  _log10l(0);
16052 ; return 0; }
16053 EOF
16054 if { (eval echo configure:16055: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16055   rm -rf conftest*
16056   glibcpp_cv_func__log10l_use=yes
16057 else
16058   echo "configure: failed program was:" >&5
16059   cat conftest.$ac_ext >&5
16060   rm -rf conftest*
16061   glibcpp_cv_func__log10l_use=no
16062 fi
16063 rm -f conftest*
16064     ac_ext=c
16065 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16066 ac_cpp='$CPP $CPPFLAGS'
16067 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16068 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16069 cross_compiling=$ac_cv_prog_cc_cross
16070
16071
16072 fi
16073
16074   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16075   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16076     for ac_func in _log10l
16077 do
16078 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16079 echo "configure:16080: checking for $ac_func" >&5
16080 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16081   echo $ac_n "(cached) $ac_c" 1>&6
16082 else
16083   cat > conftest.$ac_ext <<EOF
16084 #line 16085 "configure"
16085 #include "confdefs.h"
16086 /* System header to define __stub macros and hopefully few prototypes,
16087     which can conflict with char $ac_func(); below.  */
16088 #include <assert.h>
16089 /* Override any gcc2 internal prototype to avoid an error.  */
16090 /* We use char because int might match the return type of a gcc2
16091     builtin and then its argument prototype would still apply.  */
16092 char $ac_func();
16093
16094 int main() {
16095
16096 /* The GNU C library defines this for functions which it implements
16097     to always fail with ENOSYS.  Some functions are actually named
16098     something starting with __ and the normal name is an alias.  */
16099 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16100 choke me
16101 #else
16102 $ac_func();
16103 #endif
16104
16105 ; return 0; }
16106 EOF
16107 if { (eval echo configure:16108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16108   rm -rf conftest*
16109   eval "ac_cv_func_$ac_func=yes"
16110 else
16111   echo "configure: failed program was:" >&5
16112   cat conftest.$ac_ext >&5
16113   rm -rf conftest*
16114   eval "ac_cv_func_$ac_func=no"
16115 fi
16116 rm -f conftest*
16117 fi
16118
16119 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16120   echo "$ac_t""yes" 1>&6
16121     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16122   cat >> confdefs.h <<EOF
16123 #define $ac_tr_func 1
16124 EOF
16125
16126 else
16127   echo "$ac_t""no" 1>&6
16128 fi
16129 done
16130
16131   fi
16132
16133
16134   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
16135 echo "configure:16136: checking for _modfl declaration" >&5
16136   if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
16137   echo $ac_n "(cached) $ac_c" 1>&6
16138 else
16139
16140
16141     ac_ext=C
16142 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16143 ac_cpp='$CXXCPP $CPPFLAGS'
16144 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16145 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16146 cross_compiling=$ac_cv_prog_cxx_cross
16147
16148     cat > conftest.$ac_ext <<EOF
16149 #line 16150 "configure"
16150 #include "confdefs.h"
16151 #include <math.h>
16152 int main() {
16153  _modfl(0, 0);
16154 ; return 0; }
16155 EOF
16156 if { (eval echo configure:16157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16157   rm -rf conftest*
16158   glibcpp_cv_func__modfl_use=yes
16159 else
16160   echo "configure: failed program was:" >&5
16161   cat conftest.$ac_ext >&5
16162   rm -rf conftest*
16163   glibcpp_cv_func__modfl_use=no
16164 fi
16165 rm -f conftest*
16166     ac_ext=c
16167 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16168 ac_cpp='$CPP $CPPFLAGS'
16169 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16170 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16171 cross_compiling=$ac_cv_prog_cc_cross
16172
16173
16174 fi
16175
16176   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
16177   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
16178     for ac_func in _modfl
16179 do
16180 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16181 echo "configure:16182: checking for $ac_func" >&5
16182 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16183   echo $ac_n "(cached) $ac_c" 1>&6
16184 else
16185   cat > conftest.$ac_ext <<EOF
16186 #line 16187 "configure"
16187 #include "confdefs.h"
16188 /* System header to define __stub macros and hopefully few prototypes,
16189     which can conflict with char $ac_func(); below.  */
16190 #include <assert.h>
16191 /* Override any gcc2 internal prototype to avoid an error.  */
16192 /* We use char because int might match the return type of a gcc2
16193     builtin and then its argument prototype would still apply.  */
16194 char $ac_func();
16195
16196 int main() {
16197
16198 /* The GNU C library defines this for functions which it implements
16199     to always fail with ENOSYS.  Some functions are actually named
16200     something starting with __ and the normal name is an alias.  */
16201 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16202 choke me
16203 #else
16204 $ac_func();
16205 #endif
16206
16207 ; return 0; }
16208 EOF
16209 if { (eval echo configure:16210: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16210   rm -rf conftest*
16211   eval "ac_cv_func_$ac_func=yes"
16212 else
16213   echo "configure: failed program was:" >&5
16214   cat conftest.$ac_ext >&5
16215   rm -rf conftest*
16216   eval "ac_cv_func_$ac_func=no"
16217 fi
16218 rm -f conftest*
16219 fi
16220
16221 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16222   echo "$ac_t""yes" 1>&6
16223     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16224   cat >> confdefs.h <<EOF
16225 #define $ac_tr_func 1
16226 EOF
16227
16228 else
16229   echo "$ac_t""no" 1>&6
16230 fi
16231 done
16232
16233   fi
16234
16235
16236   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
16237 echo "configure:16238: checking for _powl declaration" >&5
16238   if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
16239   echo $ac_n "(cached) $ac_c" 1>&6
16240 else
16241
16242
16243     ac_ext=C
16244 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16245 ac_cpp='$CXXCPP $CPPFLAGS'
16246 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16247 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16248 cross_compiling=$ac_cv_prog_cxx_cross
16249
16250     cat > conftest.$ac_ext <<EOF
16251 #line 16252 "configure"
16252 #include "confdefs.h"
16253 #include <math.h>
16254 int main() {
16255  _powl(0, 0);
16256 ; return 0; }
16257 EOF
16258 if { (eval echo configure:16259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16259   rm -rf conftest*
16260   glibcpp_cv_func__powl_use=yes
16261 else
16262   echo "configure: failed program was:" >&5
16263   cat conftest.$ac_ext >&5
16264   rm -rf conftest*
16265   glibcpp_cv_func__powl_use=no
16266 fi
16267 rm -f conftest*
16268     ac_ext=c
16269 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16270 ac_cpp='$CPP $CPPFLAGS'
16271 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16272 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16273 cross_compiling=$ac_cv_prog_cc_cross
16274
16275
16276 fi
16277
16278   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
16279   if test x$glibcpp_cv_func__powl_use = x"yes"; then
16280     for ac_func in _powl
16281 do
16282 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16283 echo "configure:16284: checking for $ac_func" >&5
16284 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16285   echo $ac_n "(cached) $ac_c" 1>&6
16286 else
16287   cat > conftest.$ac_ext <<EOF
16288 #line 16289 "configure"
16289 #include "confdefs.h"
16290 /* System header to define __stub macros and hopefully few prototypes,
16291     which can conflict with char $ac_func(); below.  */
16292 #include <assert.h>
16293 /* Override any gcc2 internal prototype to avoid an error.  */
16294 /* We use char because int might match the return type of a gcc2
16295     builtin and then its argument prototype would still apply.  */
16296 char $ac_func();
16297
16298 int main() {
16299
16300 /* The GNU C library defines this for functions which it implements
16301     to always fail with ENOSYS.  Some functions are actually named
16302     something starting with __ and the normal name is an alias.  */
16303 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16304 choke me
16305 #else
16306 $ac_func();
16307 #endif
16308
16309 ; return 0; }
16310 EOF
16311 if { (eval echo configure:16312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16312   rm -rf conftest*
16313   eval "ac_cv_func_$ac_func=yes"
16314 else
16315   echo "configure: failed program was:" >&5
16316   cat conftest.$ac_ext >&5
16317   rm -rf conftest*
16318   eval "ac_cv_func_$ac_func=no"
16319 fi
16320 rm -f conftest*
16321 fi
16322
16323 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16324   echo "$ac_t""yes" 1>&6
16325     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16326   cat >> confdefs.h <<EOF
16327 #define $ac_tr_func 1
16328 EOF
16329
16330 else
16331   echo "$ac_t""no" 1>&6
16332 fi
16333 done
16334
16335   fi
16336
16337
16338   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
16339 echo "configure:16340: checking for _sinl declaration" >&5
16340   if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
16341   echo $ac_n "(cached) $ac_c" 1>&6
16342 else
16343
16344
16345     ac_ext=C
16346 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16347 ac_cpp='$CXXCPP $CPPFLAGS'
16348 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16349 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16350 cross_compiling=$ac_cv_prog_cxx_cross
16351
16352     cat > conftest.$ac_ext <<EOF
16353 #line 16354 "configure"
16354 #include "confdefs.h"
16355 #include <math.h>
16356 int main() {
16357  _sinl(0);
16358 ; return 0; }
16359 EOF
16360 if { (eval echo configure:16361: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16361   rm -rf conftest*
16362   glibcpp_cv_func__sinl_use=yes
16363 else
16364   echo "configure: failed program was:" >&5
16365   cat conftest.$ac_ext >&5
16366   rm -rf conftest*
16367   glibcpp_cv_func__sinl_use=no
16368 fi
16369 rm -f conftest*
16370     ac_ext=c
16371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16372 ac_cpp='$CPP $CPPFLAGS'
16373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16375 cross_compiling=$ac_cv_prog_cc_cross
16376
16377
16378 fi
16379
16380   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
16381   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
16382     for ac_func in _sinl
16383 do
16384 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16385 echo "configure:16386: checking for $ac_func" >&5
16386 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16387   echo $ac_n "(cached) $ac_c" 1>&6
16388 else
16389   cat > conftest.$ac_ext <<EOF
16390 #line 16391 "configure"
16391 #include "confdefs.h"
16392 /* System header to define __stub macros and hopefully few prototypes,
16393     which can conflict with char $ac_func(); below.  */
16394 #include <assert.h>
16395 /* Override any gcc2 internal prototype to avoid an error.  */
16396 /* We use char because int might match the return type of a gcc2
16397     builtin and then its argument prototype would still apply.  */
16398 char $ac_func();
16399
16400 int main() {
16401
16402 /* The GNU C library defines this for functions which it implements
16403     to always fail with ENOSYS.  Some functions are actually named
16404     something starting with __ and the normal name is an alias.  */
16405 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16406 choke me
16407 #else
16408 $ac_func();
16409 #endif
16410
16411 ; return 0; }
16412 EOF
16413 if { (eval echo configure:16414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16414   rm -rf conftest*
16415   eval "ac_cv_func_$ac_func=yes"
16416 else
16417   echo "configure: failed program was:" >&5
16418   cat conftest.$ac_ext >&5
16419   rm -rf conftest*
16420   eval "ac_cv_func_$ac_func=no"
16421 fi
16422 rm -f conftest*
16423 fi
16424
16425 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16426   echo "$ac_t""yes" 1>&6
16427     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16428   cat >> confdefs.h <<EOF
16429 #define $ac_tr_func 1
16430 EOF
16431
16432 else
16433   echo "$ac_t""no" 1>&6
16434 fi
16435 done
16436
16437   fi
16438
16439
16440   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
16441 echo "configure:16442: checking for _sinhl declaration" >&5
16442   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
16443   echo $ac_n "(cached) $ac_c" 1>&6
16444 else
16445
16446
16447     ac_ext=C
16448 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16449 ac_cpp='$CXXCPP $CPPFLAGS'
16450 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16451 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16452 cross_compiling=$ac_cv_prog_cxx_cross
16453
16454     cat > conftest.$ac_ext <<EOF
16455 #line 16456 "configure"
16456 #include "confdefs.h"
16457 #include <math.h>
16458 int main() {
16459  _sinhl(0);
16460 ; return 0; }
16461 EOF
16462 if { (eval echo configure:16463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16463   rm -rf conftest*
16464   glibcpp_cv_func__sinhl_use=yes
16465 else
16466   echo "configure: failed program was:" >&5
16467   cat conftest.$ac_ext >&5
16468   rm -rf conftest*
16469   glibcpp_cv_func__sinhl_use=no
16470 fi
16471 rm -f conftest*
16472     ac_ext=c
16473 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16474 ac_cpp='$CPP $CPPFLAGS'
16475 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16476 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16477 cross_compiling=$ac_cv_prog_cc_cross
16478
16479
16480 fi
16481
16482   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
16483   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
16484     for ac_func in _sinhl
16485 do
16486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16487 echo "configure:16488: checking for $ac_func" >&5
16488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16489   echo $ac_n "(cached) $ac_c" 1>&6
16490 else
16491   cat > conftest.$ac_ext <<EOF
16492 #line 16493 "configure"
16493 #include "confdefs.h"
16494 /* System header to define __stub macros and hopefully few prototypes,
16495     which can conflict with char $ac_func(); below.  */
16496 #include <assert.h>
16497 /* Override any gcc2 internal prototype to avoid an error.  */
16498 /* We use char because int might match the return type of a gcc2
16499     builtin and then its argument prototype would still apply.  */
16500 char $ac_func();
16501
16502 int main() {
16503
16504 /* The GNU C library defines this for functions which it implements
16505     to always fail with ENOSYS.  Some functions are actually named
16506     something starting with __ and the normal name is an alias.  */
16507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16508 choke me
16509 #else
16510 $ac_func();
16511 #endif
16512
16513 ; return 0; }
16514 EOF
16515 if { (eval echo configure:16516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16516   rm -rf conftest*
16517   eval "ac_cv_func_$ac_func=yes"
16518 else
16519   echo "configure: failed program was:" >&5
16520   cat conftest.$ac_ext >&5
16521   rm -rf conftest*
16522   eval "ac_cv_func_$ac_func=no"
16523 fi
16524 rm -f conftest*
16525 fi
16526
16527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16528   echo "$ac_t""yes" 1>&6
16529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16530   cat >> confdefs.h <<EOF
16531 #define $ac_tr_func 1
16532 EOF
16533
16534 else
16535   echo "$ac_t""no" 1>&6
16536 fi
16537 done
16538
16539   fi
16540
16541
16542   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
16543 echo "configure:16544: checking for _sqrtl declaration" >&5
16544   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
16545   echo $ac_n "(cached) $ac_c" 1>&6
16546 else
16547
16548
16549     ac_ext=C
16550 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16551 ac_cpp='$CXXCPP $CPPFLAGS'
16552 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16553 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16554 cross_compiling=$ac_cv_prog_cxx_cross
16555
16556     cat > conftest.$ac_ext <<EOF
16557 #line 16558 "configure"
16558 #include "confdefs.h"
16559 #include <math.h>
16560 int main() {
16561  _sqrtl(0);
16562 ; return 0; }
16563 EOF
16564 if { (eval echo configure:16565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16565   rm -rf conftest*
16566   glibcpp_cv_func__sqrtl_use=yes
16567 else
16568   echo "configure: failed program was:" >&5
16569   cat conftest.$ac_ext >&5
16570   rm -rf conftest*
16571   glibcpp_cv_func__sqrtl_use=no
16572 fi
16573 rm -f conftest*
16574     ac_ext=c
16575 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16576 ac_cpp='$CPP $CPPFLAGS'
16577 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16578 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16579 cross_compiling=$ac_cv_prog_cc_cross
16580
16581
16582 fi
16583
16584   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
16585   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
16586     for ac_func in _sqrtl
16587 do
16588 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16589 echo "configure:16590: checking for $ac_func" >&5
16590 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16591   echo $ac_n "(cached) $ac_c" 1>&6
16592 else
16593   cat > conftest.$ac_ext <<EOF
16594 #line 16595 "configure"
16595 #include "confdefs.h"
16596 /* System header to define __stub macros and hopefully few prototypes,
16597     which can conflict with char $ac_func(); below.  */
16598 #include <assert.h>
16599 /* Override any gcc2 internal prototype to avoid an error.  */
16600 /* We use char because int might match the return type of a gcc2
16601     builtin and then its argument prototype would still apply.  */
16602 char $ac_func();
16603
16604 int main() {
16605
16606 /* The GNU C library defines this for functions which it implements
16607     to always fail with ENOSYS.  Some functions are actually named
16608     something starting with __ and the normal name is an alias.  */
16609 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16610 choke me
16611 #else
16612 $ac_func();
16613 #endif
16614
16615 ; return 0; }
16616 EOF
16617 if { (eval echo configure:16618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16618   rm -rf conftest*
16619   eval "ac_cv_func_$ac_func=yes"
16620 else
16621   echo "configure: failed program was:" >&5
16622   cat conftest.$ac_ext >&5
16623   rm -rf conftest*
16624   eval "ac_cv_func_$ac_func=no"
16625 fi
16626 rm -f conftest*
16627 fi
16628
16629 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16630   echo "$ac_t""yes" 1>&6
16631     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16632   cat >> confdefs.h <<EOF
16633 #define $ac_tr_func 1
16634 EOF
16635
16636 else
16637   echo "$ac_t""no" 1>&6
16638 fi
16639 done
16640
16641   fi
16642
16643
16644   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
16645 echo "configure:16646: checking for _tanl declaration" >&5
16646   if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
16647   echo $ac_n "(cached) $ac_c" 1>&6
16648 else
16649
16650
16651     ac_ext=C
16652 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16653 ac_cpp='$CXXCPP $CPPFLAGS'
16654 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16655 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16656 cross_compiling=$ac_cv_prog_cxx_cross
16657
16658     cat > conftest.$ac_ext <<EOF
16659 #line 16660 "configure"
16660 #include "confdefs.h"
16661 #include <math.h>
16662 int main() {
16663  _tanl(0);
16664 ; return 0; }
16665 EOF
16666 if { (eval echo configure:16667: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16667   rm -rf conftest*
16668   glibcpp_cv_func__tanl_use=yes
16669 else
16670   echo "configure: failed program was:" >&5
16671   cat conftest.$ac_ext >&5
16672   rm -rf conftest*
16673   glibcpp_cv_func__tanl_use=no
16674 fi
16675 rm -f conftest*
16676     ac_ext=c
16677 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16678 ac_cpp='$CPP $CPPFLAGS'
16679 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16680 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16681 cross_compiling=$ac_cv_prog_cc_cross
16682
16683
16684 fi
16685
16686   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
16687   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
16688     for ac_func in _tanl
16689 do
16690 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16691 echo "configure:16692: checking for $ac_func" >&5
16692 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16693   echo $ac_n "(cached) $ac_c" 1>&6
16694 else
16695   cat > conftest.$ac_ext <<EOF
16696 #line 16697 "configure"
16697 #include "confdefs.h"
16698 /* System header to define __stub macros and hopefully few prototypes,
16699     which can conflict with char $ac_func(); below.  */
16700 #include <assert.h>
16701 /* Override any gcc2 internal prototype to avoid an error.  */
16702 /* We use char because int might match the return type of a gcc2
16703     builtin and then its argument prototype would still apply.  */
16704 char $ac_func();
16705
16706 int main() {
16707
16708 /* The GNU C library defines this for functions which it implements
16709     to always fail with ENOSYS.  Some functions are actually named
16710     something starting with __ and the normal name is an alias.  */
16711 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16712 choke me
16713 #else
16714 $ac_func();
16715 #endif
16716
16717 ; return 0; }
16718 EOF
16719 if { (eval echo configure:16720: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16720   rm -rf conftest*
16721   eval "ac_cv_func_$ac_func=yes"
16722 else
16723   echo "configure: failed program was:" >&5
16724   cat conftest.$ac_ext >&5
16725   rm -rf conftest*
16726   eval "ac_cv_func_$ac_func=no"
16727 fi
16728 rm -f conftest*
16729 fi
16730
16731 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16732   echo "$ac_t""yes" 1>&6
16733     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16734   cat >> confdefs.h <<EOF
16735 #define $ac_tr_func 1
16736 EOF
16737
16738 else
16739   echo "$ac_t""no" 1>&6
16740 fi
16741 done
16742
16743   fi
16744
16745
16746   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16747 echo "configure:16748: checking for _tanhl declaration" >&5
16748   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
16749   echo $ac_n "(cached) $ac_c" 1>&6
16750 else
16751
16752
16753     ac_ext=C
16754 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16755 ac_cpp='$CXXCPP $CPPFLAGS'
16756 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16757 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16758 cross_compiling=$ac_cv_prog_cxx_cross
16759
16760     cat > conftest.$ac_ext <<EOF
16761 #line 16762 "configure"
16762 #include "confdefs.h"
16763 #include <math.h>
16764 int main() {
16765  _tanhl(0);
16766 ; return 0; }
16767 EOF
16768 if { (eval echo configure:16769: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16769   rm -rf conftest*
16770   glibcpp_cv_func__tanhl_use=yes
16771 else
16772   echo "configure: failed program was:" >&5
16773   cat conftest.$ac_ext >&5
16774   rm -rf conftest*
16775   glibcpp_cv_func__tanhl_use=no
16776 fi
16777 rm -f conftest*
16778     ac_ext=c
16779 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16780 ac_cpp='$CPP $CPPFLAGS'
16781 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16782 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16783 cross_compiling=$ac_cv_prog_cc_cross
16784
16785
16786 fi
16787
16788   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
16789   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
16790     for ac_func in _tanhl
16791 do
16792 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16793 echo "configure:16794: checking for $ac_func" >&5
16794 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16795   echo $ac_n "(cached) $ac_c" 1>&6
16796 else
16797   cat > conftest.$ac_ext <<EOF
16798 #line 16799 "configure"
16799 #include "confdefs.h"
16800 /* System header to define __stub macros and hopefully few prototypes,
16801     which can conflict with char $ac_func(); below.  */
16802 #include <assert.h>
16803 /* Override any gcc2 internal prototype to avoid an error.  */
16804 /* We use char because int might match the return type of a gcc2
16805     builtin and then its argument prototype would still apply.  */
16806 char $ac_func();
16807
16808 int main() {
16809
16810 /* The GNU C library defines this for functions which it implements
16811     to always fail with ENOSYS.  Some functions are actually named
16812     something starting with __ and the normal name is an alias.  */
16813 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16814 choke me
16815 #else
16816 $ac_func();
16817 #endif
16818
16819 ; return 0; }
16820 EOF
16821 if { (eval echo configure:16822: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16822   rm -rf conftest*
16823   eval "ac_cv_func_$ac_func=yes"
16824 else
16825   echo "configure: failed program was:" >&5
16826   cat conftest.$ac_ext >&5
16827   rm -rf conftest*
16828   eval "ac_cv_func_$ac_func=no"
16829 fi
16830 rm -f conftest*
16831 fi
16832
16833 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16834   echo "$ac_t""yes" 1>&6
16835     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16836   cat >> confdefs.h <<EOF
16837 #define $ac_tr_func 1
16838 EOF
16839
16840 else
16841   echo "$ac_t""no" 1>&6
16842 fi
16843 done
16844
16845   fi
16846
16847
16848   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16849 echo "configure:16850: checking for _sincosl declaration" >&5
16850   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
16851   echo $ac_n "(cached) $ac_c" 1>&6
16852 else
16853
16854
16855     ac_ext=C
16856 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16857 ac_cpp='$CXXCPP $CPPFLAGS'
16858 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16859 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16860 cross_compiling=$ac_cv_prog_cxx_cross
16861
16862     cat > conftest.$ac_ext <<EOF
16863 #line 16864 "configure"
16864 #include "confdefs.h"
16865 #include <math.h>
16866 int main() {
16867  _sincosl(0, 0, 0);
16868 ; return 0; }
16869 EOF
16870 if { (eval echo configure:16871: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16871   rm -rf conftest*
16872   glibcpp_cv_func__sincosl_use=yes
16873 else
16874   echo "configure: failed program was:" >&5
16875   cat conftest.$ac_ext >&5
16876   rm -rf conftest*
16877   glibcpp_cv_func__sincosl_use=no
16878 fi
16879 rm -f conftest*
16880     ac_ext=c
16881 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16882 ac_cpp='$CPP $CPPFLAGS'
16883 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16884 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16885 cross_compiling=$ac_cv_prog_cc_cross
16886
16887
16888 fi
16889
16890   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
16891   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
16892     for ac_func in _sincosl
16893 do
16894 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16895 echo "configure:16896: checking for $ac_func" >&5
16896 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16897   echo $ac_n "(cached) $ac_c" 1>&6
16898 else
16899   cat > conftest.$ac_ext <<EOF
16900 #line 16901 "configure"
16901 #include "confdefs.h"
16902 /* System header to define __stub macros and hopefully few prototypes,
16903     which can conflict with char $ac_func(); below.  */
16904 #include <assert.h>
16905 /* Override any gcc2 internal prototype to avoid an error.  */
16906 /* We use char because int might match the return type of a gcc2
16907     builtin and then its argument prototype would still apply.  */
16908 char $ac_func();
16909
16910 int main() {
16911
16912 /* The GNU C library defines this for functions which it implements
16913     to always fail with ENOSYS.  Some functions are actually named
16914     something starting with __ and the normal name is an alias.  */
16915 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16916 choke me
16917 #else
16918 $ac_func();
16919 #endif
16920
16921 ; return 0; }
16922 EOF
16923 if { (eval echo configure:16924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16924   rm -rf conftest*
16925   eval "ac_cv_func_$ac_func=yes"
16926 else
16927   echo "configure: failed program was:" >&5
16928   cat conftest.$ac_ext >&5
16929   rm -rf conftest*
16930   eval "ac_cv_func_$ac_func=no"
16931 fi
16932 rm -f conftest*
16933 fi
16934
16935 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16936   echo "$ac_t""yes" 1>&6
16937     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16938   cat >> confdefs.h <<EOF
16939 #define $ac_tr_func 1
16940 EOF
16941
16942 else
16943   echo "$ac_t""no" 1>&6
16944 fi
16945 done
16946
16947   fi
16948
16949
16950   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16951 echo "configure:16952: checking for _finitel declaration" >&5
16952   if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
16953   echo $ac_n "(cached) $ac_c" 1>&6
16954 else
16955
16956
16957     ac_ext=C
16958 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16959 ac_cpp='$CXXCPP $CPPFLAGS'
16960 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16961 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16962 cross_compiling=$ac_cv_prog_cxx_cross
16963
16964     cat > conftest.$ac_ext <<EOF
16965 #line 16966 "configure"
16966 #include "confdefs.h"
16967 #include <math.h>
16968 int main() {
16969  _finitel(0);
16970 ; return 0; }
16971 EOF
16972 if { (eval echo configure:16973: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16973   rm -rf conftest*
16974   glibcpp_cv_func__finitel_use=yes
16975 else
16976   echo "configure: failed program was:" >&5
16977   cat conftest.$ac_ext >&5
16978   rm -rf conftest*
16979   glibcpp_cv_func__finitel_use=no
16980 fi
16981 rm -f conftest*
16982     ac_ext=c
16983 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16984 ac_cpp='$CPP $CPPFLAGS'
16985 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16986 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16987 cross_compiling=$ac_cv_prog_cc_cross
16988
16989
16990 fi
16991
16992   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
16993   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
16994     for ac_func in _finitel
16995 do
16996 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16997 echo "configure:16998: checking for $ac_func" >&5
16998 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16999   echo $ac_n "(cached) $ac_c" 1>&6
17000 else
17001   cat > conftest.$ac_ext <<EOF
17002 #line 17003 "configure"
17003 #include "confdefs.h"
17004 /* System header to define __stub macros and hopefully few prototypes,
17005     which can conflict with char $ac_func(); below.  */
17006 #include <assert.h>
17007 /* Override any gcc2 internal prototype to avoid an error.  */
17008 /* We use char because int might match the return type of a gcc2
17009     builtin and then its argument prototype would still apply.  */
17010 char $ac_func();
17011
17012 int main() {
17013
17014 /* The GNU C library defines this for functions which it implements
17015     to always fail with ENOSYS.  Some functions are actually named
17016     something starting with __ and the normal name is an alias.  */
17017 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17018 choke me
17019 #else
17020 $ac_func();
17021 #endif
17022
17023 ; return 0; }
17024 EOF
17025 if { (eval echo configure:17026: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17026   rm -rf conftest*
17027   eval "ac_cv_func_$ac_func=yes"
17028 else
17029   echo "configure: failed program was:" >&5
17030   cat conftest.$ac_ext >&5
17031   rm -rf conftest*
17032   eval "ac_cv_func_$ac_func=no"
17033 fi
17034 rm -f conftest*
17035 fi
17036
17037 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17038   echo "$ac_t""yes" 1>&6
17039     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17040   cat >> confdefs.h <<EOF
17041 #define $ac_tr_func 1
17042 EOF
17043
17044 else
17045   echo "$ac_t""no" 1>&6
17046 fi
17047 done
17048
17049   fi
17050
17051
17052   LIBS="$ac_save_LIBS"
17053   CXXFLAGS="$ac_save_CXXFLAGS"
17054
17055
17056     for ac_hdr in complex.h
17057 do
17058 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
17059 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
17060 echo "configure:17061: checking for $ac_hdr" >&5
17061 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17062   echo $ac_n "(cached) $ac_c" 1>&6
17063 else
17064   cat > conftest.$ac_ext <<EOF
17065 #line 17066 "configure"
17066 #include "confdefs.h"
17067 #include <$ac_hdr>
17068 EOF
17069 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17070 { (eval echo configure:17071: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17071 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17072 if test -z "$ac_err"; then
17073   rm -rf conftest*
17074   eval "ac_cv_header_$ac_safe=yes"
17075 else
17076   echo "$ac_err" >&5
17077   echo "configure: failed program was:" >&5
17078   cat conftest.$ac_ext >&5
17079   rm -rf conftest*
17080   eval "ac_cv_header_$ac_safe=no"
17081 fi
17082 rm -f conftest*
17083 fi
17084 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17085   echo "$ac_t""yes" 1>&6
17086     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17087   cat >> confdefs.h <<EOF
17088 #define $ac_tr_hdr 1
17089 EOF
17090
17091 else
17092   echo "$ac_t""no" 1>&6
17093 fi
17094 done
17095
17096   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17097 echo "configure:17098: checking for main in -lm" >&5
17098 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17099 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17100   echo $ac_n "(cached) $ac_c" 1>&6
17101 else
17102   ac_save_LIBS="$LIBS"
17103 LIBS="-lm  $LIBS"
17104 cat > conftest.$ac_ext <<EOF
17105 #line 17106 "configure"
17106 #include "confdefs.h"
17107
17108 int main() {
17109 main()
17110 ; return 0; }
17111 EOF
17112 if { (eval echo configure:17113: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17113   rm -rf conftest*
17114   eval "ac_cv_lib_$ac_lib_var=yes"
17115 else
17116   echo "configure: failed program was:" >&5
17117   cat conftest.$ac_ext >&5
17118   rm -rf conftest*
17119   eval "ac_cv_lib_$ac_lib_var=no"
17120 fi
17121 rm -f conftest*
17122 LIBS="$ac_save_LIBS"
17123
17124 fi
17125 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17126   echo "$ac_t""yes" 1>&6
17127     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
17128     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
17129   cat >> confdefs.h <<EOF
17130 #define $ac_tr_lib 1
17131 EOF
17132
17133   LIBS="-lm $LIBS"
17134
17135 else
17136   echo "$ac_t""no" 1>&6
17137 fi
17138
17139   for ac_func in cabs cabsf ccos ccosf ccosh ccoshf cexp cexpf \
17140   c_log c_logf clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt \
17141   csqrtf ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf \
17142   copysignf
17143 do
17144 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17145 echo "configure:17146: checking for $ac_func" >&5
17146 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17147   echo $ac_n "(cached) $ac_c" 1>&6
17148 else
17149   cat > conftest.$ac_ext <<EOF
17150 #line 17151 "configure"
17151 #include "confdefs.h"
17152 /* System header to define __stub macros and hopefully few prototypes,
17153     which can conflict with char $ac_func(); below.  */
17154 #include <assert.h>
17155 /* Override any gcc2 internal prototype to avoid an error.  */
17156 /* We use char because int might match the return type of a gcc2
17157     builtin and then its argument prototype would still apply.  */
17158 char $ac_func();
17159
17160 int main() {
17161
17162 /* The GNU C library defines this for functions which it implements
17163     to always fail with ENOSYS.  Some functions are actually named
17164     something starting with __ and the normal name is an alias.  */
17165 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17166 choke me
17167 #else
17168 $ac_func();
17169 #endif
17170
17171 ; return 0; }
17172 EOF
17173 if { (eval echo configure:17174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17174   rm -rf conftest*
17175   eval "ac_cv_func_$ac_func=yes"
17176 else
17177   echo "configure: failed program was:" >&5
17178   cat conftest.$ac_ext >&5
17179   rm -rf conftest*
17180   eval "ac_cv_func_$ac_func=no"
17181 fi
17182 rm -f conftest*
17183 fi
17184
17185 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17186   echo "$ac_t""yes" 1>&6
17187     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17188   cat >> confdefs.h <<EOF
17189 #define $ac_tr_func 1
17190 EOF
17191
17192 else
17193   echo "$ac_t""no" 1>&6
17194 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17195 fi
17196 done
17197
17198
17199
17200           USE_COMPLEX_LONG_DOUBLE=no
17201   if test x$ac_cv_func_atan2l = x"yes" \
17202      && test x$ac_cv_func_copysignl = x"yes"; then
17203     USE_COMPLEX_LONG_DOUBLE=yes
17204     for ac_func in cabsl ccoshl ccosl cexpl cpowl csinhl csinl \
17205     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
17206 do
17207 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17208 echo "configure:17209: checking for $ac_func" >&5
17209 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17210   echo $ac_n "(cached) $ac_c" 1>&6
17211 else
17212   cat > conftest.$ac_ext <<EOF
17213 #line 17214 "configure"
17214 #include "confdefs.h"
17215 /* System header to define __stub macros and hopefully few prototypes,
17216     which can conflict with char $ac_func(); below.  */
17217 #include <assert.h>
17218 /* Override any gcc2 internal prototype to avoid an error.  */
17219 /* We use char because int might match the return type of a gcc2
17220     builtin and then its argument prototype would still apply.  */
17221 char $ac_func();
17222
17223 int main() {
17224
17225 /* The GNU C library defines this for functions which it implements
17226     to always fail with ENOSYS.  Some functions are actually named
17227     something starting with __ and the normal name is an alias.  */
17228 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17229 choke me
17230 #else
17231 $ac_func();
17232 #endif
17233
17234 ; return 0; }
17235 EOF
17236 if { (eval echo configure:17237: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17237   rm -rf conftest*
17238   eval "ac_cv_func_$ac_func=yes"
17239 else
17240   echo "configure: failed program was:" >&5
17241   cat conftest.$ac_ext >&5
17242   rm -rf conftest*
17243   eval "ac_cv_func_$ac_func=no"
17244 fi
17245 rm -f conftest*
17246 fi
17247
17248 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17249   echo "$ac_t""yes" 1>&6
17250     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17251   cat >> confdefs.h <<EOF
17252 #define $ac_tr_func 1
17253 EOF
17254
17255 else
17256   echo "$ac_t""no" 1>&6
17257 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17258 fi
17259 done
17260
17261
17262   fi
17263
17264
17265
17266
17267
17268
17269   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
17270 echo "configure:17271: checking for GNU C++ __complex__ support" >&5
17271   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
17272   echo $ac_n "(cached) $ac_c" 1>&6
17273 else
17274
17275
17276     ac_ext=C
17277 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17278 ac_cpp='$CXXCPP $CPPFLAGS'
17279 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17280 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17281 cross_compiling=$ac_cv_prog_cxx_cross
17282
17283     cat > conftest.$ac_ext <<EOF
17284 #line 17285 "configure"
17285 #include "confdefs.h"
17286 struct dcomplex { __complex__ double x; }; \
17287                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
17288 int main() {
17289 \
17290                      dcomplex x; f(x);
17291 ; return 0; }
17292 EOF
17293 if { (eval echo configure:17294: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17294   rm -rf conftest*
17295   glibcpp_cv_complex=ok
17296 else
17297   echo "configure: failed program was:" >&5
17298   cat conftest.$ac_ext >&5
17299   rm -rf conftest*
17300   glibcpp_cv_complex=buggy
17301
17302 fi
17303 rm -f conftest*
17304     ac_ext=c
17305 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17306 ac_cpp='$CPP $CPPFLAGS'
17307 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17308 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17309 cross_compiling=$ac_cv_prog_cc_cross
17310
17311
17312 fi
17313
17314   echo "$ac_t""$glibcpp_cv_complex" 1>&6
17315   if test $glibcpp_cv_complex = buggy; then
17316     cat >> confdefs.h <<\EOF
17317 #define _GLIBCPP_BUGGY_COMPLEX 1
17318 EOF
17319
17320   fi
17321
17322   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
17323 echo "configure:17324: checking for GNU C++ __complex__ float support" >&5
17324   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
17325   echo $ac_n "(cached) $ac_c" 1>&6
17326 else
17327
17328
17329     ac_ext=C
17330 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17331 ac_cpp='$CXXCPP $CPPFLAGS'
17332 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17333 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17334 cross_compiling=$ac_cv_prog_cxx_cross
17335
17336     rm -f conftest.h
17337     cat > conftest.h <<EOB
17338       //
17339       // Check for buggy __complex__ that causes ICE in most versions of egcs
17340       // and gcc-2.95.x on certain platforms (eg., x86-win32).
17341       //
17342       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
17343       // more info on the bug itself.
17344       //
17345       struct
17346       float_complex
17347       {
17348        __complex__ float m_value;
17349        float_complex (float = 0.0f, float = 0.0f);
17350        float_complex (__complex__ float val) : m_value (val) {}
17351        float_complex foo (const float_complex &val)
17352          { return float_complex (~val.m_value); }
17353       };
17354 EOB
17355     cat > conftest.$ac_ext <<EOF
17356 #line 17357 "configure"
17357 #include "confdefs.h"
17358 #include "conftest.h"
17359 int main() {
17360
17361 ; return 0; }
17362 EOF
17363 if { (eval echo configure:17364: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17364   rm -rf conftest*
17365   glibcpp_cv_float_complex=ok
17366 else
17367   echo "configure: failed program was:" >&5
17368   cat conftest.$ac_ext >&5
17369   rm -rf conftest*
17370   glibcpp_cv_float_complex=buggy
17371
17372 fi
17373 rm -f conftest*
17374     ac_ext=c
17375 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17376 ac_cpp='$CPP $CPPFLAGS'
17377 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17378 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17379 cross_compiling=$ac_cv_prog_cc_cross
17380
17381
17382 fi
17383
17384   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
17385   if test $glibcpp_cv_float_complex = buggy; then
17386     cat >> confdefs.h <<\EOF
17387 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
17388 EOF
17389
17390   fi
17391
17392
17393   if test x$enable_c_mbchar != xno; then
17394
17395         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
17396 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
17397 echo "configure:17398: checking for wchar.h" >&5
17398 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17399   echo $ac_n "(cached) $ac_c" 1>&6
17400 else
17401   cat > conftest.$ac_ext <<EOF
17402 #line 17403 "configure"
17403 #include "confdefs.h"
17404 #include <wchar.h>
17405 EOF
17406 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17407 { (eval echo configure:17408: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17408 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17409 if test -z "$ac_err"; then
17410   rm -rf conftest*
17411   eval "ac_cv_header_$ac_safe=yes"
17412 else
17413   echo "$ac_err" >&5
17414   echo "configure: failed program was:" >&5
17415   cat conftest.$ac_ext >&5
17416   rm -rf conftest*
17417   eval "ac_cv_header_$ac_safe=no"
17418 fi
17419 rm -f conftest*
17420 fi
17421 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17422   echo "$ac_t""yes" 1>&6
17423   ac_has_wchar_h=yes
17424 else
17425   echo "$ac_t""no" 1>&6
17426 ac_has_wchar_h=no
17427 fi
17428
17429     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
17430 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
17431 echo "configure:17432: checking for wctype.h" >&5
17432 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17433   echo $ac_n "(cached) $ac_c" 1>&6
17434 else
17435   cat > conftest.$ac_ext <<EOF
17436 #line 17437 "configure"
17437 #include "confdefs.h"
17438 #include <wctype.h>
17439 EOF
17440 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17441 { (eval echo configure:17442: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17442 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17443 if test -z "$ac_err"; then
17444   rm -rf conftest*
17445   eval "ac_cv_header_$ac_safe=yes"
17446 else
17447   echo "$ac_err" >&5
17448   echo "configure: failed program was:" >&5
17449   cat conftest.$ac_ext >&5
17450   rm -rf conftest*
17451   eval "ac_cv_header_$ac_safe=no"
17452 fi
17453 rm -f conftest*
17454 fi
17455 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17456   echo "$ac_t""yes" 1>&6
17457   ac_has_wctype_h=yes
17458 else
17459   echo "$ac_t""no" 1>&6
17460 ac_has_wctype_h=no
17461 fi
17462
17463
17464         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
17465
17466                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
17467 echo "configure:17468: checking for mbstate_t" >&5
17468       cat > conftest.$ac_ext <<EOF
17469 #line 17470 "configure"
17470 #include "confdefs.h"
17471 #include <wchar.h>
17472 int main() {
17473 mbstate_t teststate;
17474 ; return 0; }
17475 EOF
17476 if { (eval echo configure:17477: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17477   rm -rf conftest*
17478   use_native_mbstatet=yes
17479 else
17480   echo "configure: failed program was:" >&5
17481   cat conftest.$ac_ext >&5
17482   rm -rf conftest*
17483   use_native_mbstatet=no
17484 fi
17485 rm -f conftest*
17486       echo "$ac_t""$use_native_mbstatet" 1>&6
17487       if test x"$use_native_mbstatet" = xno; then
17488         cat >> confdefs.h <<\EOF
17489 #define _GLIBCPP_NEED_MBSTATE_T 1
17490 EOF
17491
17492       fi
17493
17494                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
17495 echo "configure:17496: checking for WCHAR_MIN and WCHAR_MAX" >&5
17496       cat > conftest.$ac_ext <<EOF
17497 #line 17498 "configure"
17498 #include "confdefs.h"
17499 #include <wchar.h>
17500 int main() {
17501 int i = WCHAR_MIN; int j = WCHAR_MAX;
17502 ; return 0; }
17503 EOF
17504 if { (eval echo configure:17505: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17505   rm -rf conftest*
17506   has_wchar_minmax=yes
17507 else
17508   echo "configure: failed program was:" >&5
17509   cat conftest.$ac_ext >&5
17510   rm -rf conftest*
17511   has_wchar_minmax=no
17512 fi
17513 rm -f conftest*
17514       echo "$ac_t""$has_wchar_minmax" 1>&6
17515
17516                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
17517 echo "configure:17518: checking for WEOF" >&5
17518       cat > conftest.$ac_ext <<EOF
17519 #line 17520 "configure"
17520 #include "confdefs.h"
17521
17522         #include <wchar.h>
17523         #include <stddef.h>
17524 int main() {
17525 wint_t i = WEOF;
17526 ; return 0; }
17527 EOF
17528 if { (eval echo configure:17529: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17529   rm -rf conftest*
17530   has_weof=yes
17531 else
17532   echo "configure: failed program was:" >&5
17533   cat conftest.$ac_ext >&5
17534   rm -rf conftest*
17535   has_weof=no
17536 fi
17537 rm -f conftest*
17538       echo "$ac_t""$has_weof" 1>&6
17539
17540             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
17541       wcsrtombs mbsrtowcs
17542 do
17543 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17544 echo "configure:17545: checking for $ac_func" >&5
17545 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17546   echo $ac_n "(cached) $ac_c" 1>&6
17547 else
17548   cat > conftest.$ac_ext <<EOF
17549 #line 17550 "configure"
17550 #include "confdefs.h"
17551 /* System header to define __stub macros and hopefully few prototypes,
17552     which can conflict with char $ac_func(); below.  */
17553 #include <assert.h>
17554 /* Override any gcc2 internal prototype to avoid an error.  */
17555 /* We use char because int might match the return type of a gcc2
17556     builtin and then its argument prototype would still apply.  */
17557 char $ac_func();
17558
17559 int main() {
17560
17561 /* The GNU C library defines this for functions which it implements
17562     to always fail with ENOSYS.  Some functions are actually named
17563     something starting with __ and the normal name is an alias.  */
17564 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17565 choke me
17566 #else
17567 $ac_func();
17568 #endif
17569
17570 ; return 0; }
17571 EOF
17572 if { (eval echo configure:17573: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17573   rm -rf conftest*
17574   eval "ac_cv_func_$ac_func=yes"
17575 else
17576   echo "configure: failed program was:" >&5
17577   cat conftest.$ac_ext >&5
17578   rm -rf conftest*
17579   eval "ac_cv_func_$ac_func=no"
17580 fi
17581 rm -f conftest*
17582 fi
17583
17584 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17585   echo "$ac_t""yes" 1>&6
17586     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17587   cat >> confdefs.h <<EOF
17588 #define $ac_tr_func 1
17589 EOF
17590  ac_wfuncs=yes
17591 else
17592   echo "$ac_t""no" 1>&6
17593 ac_wfuncs=no
17594 fi
17595 done
17596
17597
17598       echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
17599 echo "configure:17600: checking for ISO C9X wchar_t support" >&5
17600       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
17601          && test x"$ac_wfuncs" = xyes; then
17602         ac_isoC9X_wchar_t=yes
17603       else
17604         ac_isoC9X_wchar_t=no
17605       fi
17606       echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
17607
17608                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
17609 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
17610 echo "configure:17611: checking for iconv.h" >&5
17611 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17612   echo $ac_n "(cached) $ac_c" 1>&6
17613 else
17614   cat > conftest.$ac_ext <<EOF
17615 #line 17616 "configure"
17616 #include "confdefs.h"
17617 #include <iconv.h>
17618 EOF
17619 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17620 { (eval echo configure:17621: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17621 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17622 if test -z "$ac_err"; then
17623   rm -rf conftest*
17624   eval "ac_cv_header_$ac_safe=yes"
17625 else
17626   echo "$ac_err" >&5
17627   echo "configure: failed program was:" >&5
17628   cat conftest.$ac_ext >&5
17629   rm -rf conftest*
17630   eval "ac_cv_header_$ac_safe=no"
17631 fi
17632 rm -f conftest*
17633 fi
17634 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17635   echo "$ac_t""yes" 1>&6
17636   ac_has_iconv_h=yes
17637 else
17638   echo "$ac_t""no" 1>&6
17639 ac_has_iconv_h=no
17640 fi
17641
17642       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
17643 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
17644 echo "configure:17645: checking for langinfo.h" >&5
17645 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17646   echo $ac_n "(cached) $ac_c" 1>&6
17647 else
17648   cat > conftest.$ac_ext <<EOF
17649 #line 17650 "configure"
17650 #include "confdefs.h"
17651 #include <langinfo.h>
17652 EOF
17653 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17654 { (eval echo configure:17655: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17655 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17656 if test -z "$ac_err"; then
17657   rm -rf conftest*
17658   eval "ac_cv_header_$ac_safe=yes"
17659 else
17660   echo "$ac_err" >&5
17661   echo "configure: failed program was:" >&5
17662   cat conftest.$ac_ext >&5
17663   rm -rf conftest*
17664   eval "ac_cv_header_$ac_safe=no"
17665 fi
17666 rm -f conftest*
17667 fi
17668 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17669   echo "$ac_t""yes" 1>&6
17670   ac_has_langinfo_h=yes
17671 else
17672   echo "$ac_t""no" 1>&6
17673 ac_has_langinfo_h=no
17674 fi
17675
17676       for ac_func in iconv_open iconv_close iconv nl_langinfo
17677 do
17678 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17679 echo "configure:17680: checking for $ac_func" >&5
17680 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17681   echo $ac_n "(cached) $ac_c" 1>&6
17682 else
17683   cat > conftest.$ac_ext <<EOF
17684 #line 17685 "configure"
17685 #include "confdefs.h"
17686 /* System header to define __stub macros and hopefully few prototypes,
17687     which can conflict with char $ac_func(); below.  */
17688 #include <assert.h>
17689 /* Override any gcc2 internal prototype to avoid an error.  */
17690 /* We use char because int might match the return type of a gcc2
17691     builtin and then its argument prototype would still apply.  */
17692 char $ac_func();
17693
17694 int main() {
17695
17696 /* The GNU C library defines this for functions which it implements
17697     to always fail with ENOSYS.  Some functions are actually named
17698     something starting with __ and the normal name is an alias.  */
17699 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17700 choke me
17701 #else
17702 $ac_func();
17703 #endif
17704
17705 ; return 0; }
17706 EOF
17707 if { (eval echo configure:17708: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17708   rm -rf conftest*
17709   eval "ac_cv_func_$ac_func=yes"
17710 else
17711   echo "configure: failed program was:" >&5
17712   cat conftest.$ac_ext >&5
17713   rm -rf conftest*
17714   eval "ac_cv_func_$ac_func=no"
17715 fi
17716 rm -f conftest*
17717 fi
17718
17719 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17720   echo "$ac_t""yes" 1>&6
17721     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17722   cat >> confdefs.h <<EOF
17723 #define $ac_tr_func 1
17724 EOF
17725  \
17726       ac_XPG2funcs=yes
17727 else
17728   echo "$ac_t""no" 1>&6
17729 ac_XPG2funcs=no
17730 fi
17731 done
17732
17733
17734       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
17735 echo "configure:17736: checking for XPG2 wchar_t support" >&5
17736       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
17737          && test x"$ac_XPG2funcs" = xyes; then
17738         ac_XPG2_wchar_t=yes
17739       else
17740         ac_XPG2_wchar_t=no
17741       fi
17742       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
17743
17744                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
17745 echo "configure:17746: checking for enabled wchar_t specializations" >&5
17746       if test x"$ac_isoC9X_wchar_t" = xyes \
17747          && test x"$ac_XPG2_wchar_t" = xyes; then
17748         libinst_wstring_la="libinst-wstring.la"
17749         cat >> confdefs.h <<\EOF
17750 #define _GLIBCPP_USE_WCHAR_T 1
17751 EOF
17752
17753         echo "$ac_t"""yes"" 1>&6
17754       else
17755         libinst_wstring_la=""
17756         echo "$ac_t"""no"" 1>&6
17757       fi
17758
17759
17760     else
17761       echo "configure: warning: <wchar.h> not found" 1>&2
17762       cat >> confdefs.h <<\EOF
17763 #define _GLIBCPP_NEED_MBSTATE_T 1
17764 EOF
17765
17766     fi
17767
17768   else
17769         :
17770   fi
17771
17772
17773   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
17774 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
17775 echo "configure:17776: checking for ctype.h" >&5
17776 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17777   echo $ac_n "(cached) $ac_c" 1>&6
17778 else
17779   cat > conftest.$ac_ext <<EOF
17780 #line 17781 "configure"
17781 #include "confdefs.h"
17782 #include <ctype.h>
17783 EOF
17784 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17785 { (eval echo configure:17786: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17786 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17787 if test -z "$ac_err"; then
17788   rm -rf conftest*
17789   eval "ac_cv_header_$ac_safe=yes"
17790 else
17791   echo "$ac_err" >&5
17792   echo "configure: failed program was:" >&5
17793   cat conftest.$ac_ext >&5
17794   rm -rf conftest*
17795   eval "ac_cv_header_$ac_safe=no"
17796 fi
17797 rm -f conftest*
17798 fi
17799 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17800   echo "$ac_t""yes" 1>&6
17801
17802
17803         ctype_default=yes
17804
17805         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
17806 echo "configure:17807: checking <ctype> for GNU/Linux" >&5
17807     cat > conftest.$ac_ext <<EOF
17808 #line 17809 "configure"
17809 #include "confdefs.h"
17810 #include <ctype.h>
17811 int main() {
17812 int
17813     foo (int a)
17814     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
17815         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
17816         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17817 ; return 0; }
17818 EOF
17819 if { (eval echo configure:17820: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17820   rm -rf conftest*
17821   \
17822     ctype_linux=yes
17823 else
17824   echo "configure: failed program was:" >&5
17825   cat conftest.$ac_ext >&5
17826   rm -rf conftest*
17827   ctype_linux=no
17828 fi
17829 rm -f conftest*
17830     echo "$ac_t""$ctype_linux" 1>&6
17831     if test $ctype_linux = "yes"; then
17832       ctype_include_dir="config/os/gnu-linux"
17833       ctype_default=no
17834     fi
17835
17836         if test $ctype_default = "yes"; then
17837     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
17838 echo "configure:17839: checking <ctype> for FreeBSD 4.0" >&5
17839     cat > conftest.$ac_ext <<EOF
17840 #line 17841 "configure"
17841 #include "confdefs.h"
17842 #include <ctype.h>
17843 int main() {
17844 int
17845     foo (int a)
17846     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17847         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17848 ; return 0; }
17849 EOF
17850 if { (eval echo configure:17851: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17851   rm -rf conftest*
17852   \
17853     ctype_bsd=yes
17854 else
17855   echo "configure: failed program was:" >&5
17856   cat conftest.$ac_ext >&5
17857   rm -rf conftest*
17858   ctype_bsd=no
17859 fi
17860 rm -f conftest*
17861     echo "$ac_t""$ctype_bsd" 1>&6
17862     if test $ctype_bsd = "yes"; then
17863       ctype_include_dir="config/os/bsd"
17864       ctype_default=no
17865     fi
17866     fi
17867
17868         if test $ctype_default = "yes"; then
17869     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
17870 echo "configure:17871: checking <ctype> for FreeBSD 3.4" >&5
17871     cat > conftest.$ac_ext <<EOF
17872 #line 17873 "configure"
17873 #include "confdefs.h"
17874 #include <ctype.h>
17875 int main() {
17876 int
17877     foo (int a)
17878     { return _S + _R + _C + _U + _L + _A \
17879       + _D + _P + _X + _G + __istype (a, 0);}
17880 ; return 0; }
17881 EOF
17882 if { (eval echo configure:17883: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17883   rm -rf conftest*
17884   \
17885     ctype_freebsd34=yes
17886 else
17887   echo "configure: failed program was:" >&5
17888   cat conftest.$ac_ext >&5
17889   rm -rf conftest*
17890   ctype_freebsd34=no
17891 fi
17892 rm -f conftest*
17893     echo "$ac_t""$ctype_freebsd34" 1>&6
17894     if test $ctype_freebsd34 = "yes"; then
17895       ctype_include_dir="config/os/bsd"
17896       ctype_default=no
17897     fi
17898     fi
17899
17900         if test $ctype_default = "yes"; then
17901     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
17902 echo "configure:17903: checking <ctype> for Solaris 2.6,7,8" >&5
17903     cat > conftest.$ac_ext <<EOF
17904 #line 17905 "configure"
17905 #include "confdefs.h"
17906 #include <ctype.h>
17907 int main() {
17908 int
17909     foo (int a)
17910     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17911         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17912         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17913 ; return 0; }
17914 EOF
17915 if { (eval echo configure:17916: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17916   rm -rf conftest*
17917   \
17918     ctype_solaris=yes
17919 else
17920   echo "configure: failed program was:" >&5
17921   cat conftest.$ac_ext >&5
17922   rm -rf conftest*
17923   ctype_solaris=no
17924 fi
17925 rm -f conftest*
17926     echo "$ac_t""$ctype_solaris" 1>&6
17927
17928     if test $ctype_solaris = "yes"; then
17929       echo $ac_n "checking   for version""... $ac_c" 1>&6
17930 echo "configure:17931: checking   for version" >&5
17931       ac_ext=C
17932 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17933 ac_cpp='$CXXCPP $CPPFLAGS'
17934 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17935 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17936 cross_compiling=$ac_cv_prog_cxx_cross
17937
17938       cat > conftest.$ac_ext <<EOF
17939 #line 17940 "configure"
17940 #include "confdefs.h"
17941 #include <ctype.h>
17942 int main() {
17943 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17944 ; return 0; }
17945 EOF
17946 if { (eval echo configure:17947: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17947   rm -rf conftest*
17948   \
17949       ctype_solaris26=yes
17950 else
17951   echo "configure: failed program was:" >&5
17952   cat conftest.$ac_ext >&5
17953   rm -rf conftest*
17954   ctype_solaris26=no
17955 fi
17956 rm -f conftest*
17957       ac_ext=c
17958 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17959 ac_cpp='$CPP $CPPFLAGS'
17960 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17961 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17962 cross_compiling=$ac_cv_prog_cc_cross
17963
17964       if test $ctype_solaris26 = "yes"; then
17965         ctype_include_dir="config/os/solaris/solaris2.6"
17966         echo "$ac_t""Solaris 2.6" 1>&6
17967         ctype_default=no
17968       else
17969         ctype_include_dir="config/os/solaris/solaris2.7"
17970         echo "$ac_t""Solaris 7,8" 1>&6
17971         ctype_default=no
17972       fi
17973     fi
17974     fi
17975
17976         if test $ctype_default = "yes"; then
17977     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
17978 echo "configure:17979: checking <ctype> for Solaris 2.5.1" >&5
17979     cat > conftest.$ac_ext <<EOF
17980 #line 17981 "configure"
17981 #include "confdefs.h"
17982 #include <ctype.h>
17983 int main() {
17984 int
17985     foo (int a)
17986     { return _U + _L + _N + _S + _P + _C + _X + _B \
17987         + __ctype[a];}
17988 ; return 0; }
17989 EOF
17990 if { (eval echo configure:17991: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17991   rm -rf conftest*
17992   \
17993     ctype_solaris25=yes
17994 else
17995   echo "configure: failed program was:" >&5
17996   cat conftest.$ac_ext >&5
17997   rm -rf conftest*
17998   ctype_solaris25=no
17999 fi
18000 rm -f conftest*
18001     echo "$ac_t""$ctype_solaris25" 1>&6
18002     if test $ctype_solaris25 = "yes"; then
18003       ctype_include_dir="config/os/solaris/solaris2.5"
18004       ctype_default=no
18005     fi
18006     fi
18007
18008         if test $ctype_default = "yes"; then
18009     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
18010 echo "configure:18011: checking <ctype> for AIX" >&5
18011     cat > conftest.$ac_ext <<EOF
18012 #line 18013 "configure"
18013 #include "confdefs.h"
18014 #include <ctype.h>
18015 int main() {
18016 int
18017     foo (int a)
18018     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18019         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18020         + _VALC('a') + _IS('c', 0);}
18021 ; return 0; }
18022 EOF
18023 if { (eval echo configure:18024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18024   rm -rf conftest*
18025   \
18026     ctype_aix=yes
18027 else
18028   echo "configure: failed program was:" >&5
18029   cat conftest.$ac_ext >&5
18030   rm -rf conftest*
18031   ctype_aix=no
18032 fi
18033 rm -f conftest*
18034     echo "$ac_t""$ctype_aix" 1>&6
18035     if test $ctype_aix = "yes"; then
18036       ctype_include_dir="config/os/aix"
18037       ctype_default=no
18038     fi
18039     fi
18040
18041         if test $ctype_default = "yes"; then
18042     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18043 echo "configure:18044: checking <ctype> for IRIX" >&5
18044     cat > conftest.$ac_ext <<EOF
18045 #line 18046 "configure"
18046 #include "confdefs.h"
18047 #include <ctype.h>
18048 int main() {
18049 int
18050     foo (int a)
18051     { return _U + _L + _N + _S + _P + _C + _B + _X + \
18052              _A + _PR + _G + _BL;}
18053 ; return 0; }
18054 EOF
18055 if { (eval echo configure:18056: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18056   rm -rf conftest*
18057   \
18058     ctype_irix=yes
18059 else
18060   echo "configure: failed program was:" >&5
18061   cat conftest.$ac_ext >&5
18062   rm -rf conftest*
18063   ctype_irix=no
18064 fi
18065 rm -f conftest*
18066     echo "$ac_t""$ctype_irix" 1>&6
18067     if test $ctype_irix = "yes"; then
18068       ctype_include_dir="config/os/irix"
18069       ctype_default=no
18070     fi
18071     fi
18072
18073         if test $ctype_default = "yes"; then
18074     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
18075 echo "configure:18076: checking <ctype> for newlib" >&5
18076     cat > conftest.$ac_ext <<EOF
18077 #line 18078 "configure"
18078 #include "confdefs.h"
18079 #include <ctype.h>
18080 int main() {
18081 int
18082     foo (int a)
18083     { return _U + _L + _N + _S + _P + _C + _X + _B \
18084         + _ctype_[a];}
18085 ; return 0; }
18086 EOF
18087 if { (eval echo configure:18088: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18088   rm -rf conftest*
18089   \
18090     ctype_newlib=yes
18091 else
18092   echo "configure: failed program was:" >&5
18093   cat conftest.$ac_ext >&5
18094   rm -rf conftest*
18095   ctype_newlib=no
18096 fi
18097 rm -f conftest*
18098     echo "$ac_t""$ctype_newlib" 1>&6
18099     if test $ctype_newlib = "yes"; then
18100       ctype_include_dir="config/newlib"
18101       ctype_default=no
18102     fi
18103     fi
18104
18105     if test $ctype_default = "yes"; then
18106       ctype_include_dir="config/os/generic"
18107       echo "configure: warning: "Using default ctype headers."" 1>&2
18108     fi
18109
18110
18111
18112
18113
18114 else
18115   echo "$ac_t""no" 1>&6
18116 fi
18117
18118
18119
18120   ac_test_CXXFLAGS="${CXXFLAGS+set}"
18121   ac_save_CXXFLAGS="$CXXFLAGS"
18122   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
18123
18124   for ac_func in strtof
18125 do
18126 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18127 echo "configure:18128: checking for $ac_func" >&5
18128 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18129   echo $ac_n "(cached) $ac_c" 1>&6
18130 else
18131   cat > conftest.$ac_ext <<EOF
18132 #line 18133 "configure"
18133 #include "confdefs.h"
18134 /* System header to define __stub macros and hopefully few prototypes,
18135     which can conflict with char $ac_func(); below.  */
18136 #include <assert.h>
18137 /* Override any gcc2 internal prototype to avoid an error.  */
18138 /* We use char because int might match the return type of a gcc2
18139     builtin and then its argument prototype would still apply.  */
18140 char $ac_func();
18141
18142 int main() {
18143
18144 /* The GNU C library defines this for functions which it implements
18145     to always fail with ENOSYS.  Some functions are actually named
18146     something starting with __ and the normal name is an alias.  */
18147 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18148 choke me
18149 #else
18150 $ac_func();
18151 #endif
18152
18153 ; return 0; }
18154 EOF
18155 if { (eval echo configure:18156: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18156   rm -rf conftest*
18157   eval "ac_cv_func_$ac_func=yes"
18158 else
18159   echo "configure: failed program was:" >&5
18160   cat conftest.$ac_ext >&5
18161   rm -rf conftest*
18162   eval "ac_cv_func_$ac_func=no"
18163 fi
18164 rm -f conftest*
18165 fi
18166
18167 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18168   echo "$ac_t""yes" 1>&6
18169     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18170   cat >> confdefs.h <<EOF
18171 #define $ac_tr_func 1
18172 EOF
18173
18174 else
18175   echo "$ac_t""no" 1>&6
18176 fi
18177 done
18178
18179
18180   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
18181 echo "configure:18182: checking for strtold declaration" >&5
18182   if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
18183   echo $ac_n "(cached) $ac_c" 1>&6
18184 else
18185
18186
18187     ac_ext=C
18188 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18189 ac_cpp='$CXXCPP $CPPFLAGS'
18190 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18191 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18192 cross_compiling=$ac_cv_prog_cxx_cross
18193
18194     cat > conftest.$ac_ext <<EOF
18195 #line 18196 "configure"
18196 #include "confdefs.h"
18197 #include <stdlib.h>
18198 int main() {
18199  strtold(0, 0);
18200 ; return 0; }
18201 EOF
18202 if { (eval echo configure:18203: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18203   rm -rf conftest*
18204   glibcpp_cv_func_strtold_use=yes
18205 else
18206   echo "configure: failed program was:" >&5
18207   cat conftest.$ac_ext >&5
18208   rm -rf conftest*
18209   glibcpp_cv_func_strtold_use=no
18210 fi
18211 rm -f conftest*
18212     ac_ext=c
18213 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18214 ac_cpp='$CPP $CPPFLAGS'
18215 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18216 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18217 cross_compiling=$ac_cv_prog_cc_cross
18218
18219
18220 fi
18221
18222   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
18223   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
18224     for ac_func in strtold
18225 do
18226 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18227 echo "configure:18228: checking for $ac_func" >&5
18228 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18229   echo $ac_n "(cached) $ac_c" 1>&6
18230 else
18231   cat > conftest.$ac_ext <<EOF
18232 #line 18233 "configure"
18233 #include "confdefs.h"
18234 /* System header to define __stub macros and hopefully few prototypes,
18235     which can conflict with char $ac_func(); below.  */
18236 #include <assert.h>
18237 /* Override any gcc2 internal prototype to avoid an error.  */
18238 /* We use char because int might match the return type of a gcc2
18239     builtin and then its argument prototype would still apply.  */
18240 char $ac_func();
18241
18242 int main() {
18243
18244 /* The GNU C library defines this for functions which it implements
18245     to always fail with ENOSYS.  Some functions are actually named
18246     something starting with __ and the normal name is an alias.  */
18247 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18248 choke me
18249 #else
18250 $ac_func();
18251 #endif
18252
18253 ; return 0; }
18254 EOF
18255 if { (eval echo configure:18256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18256   rm -rf conftest*
18257   eval "ac_cv_func_$ac_func=yes"
18258 else
18259   echo "configure: failed program was:" >&5
18260   cat conftest.$ac_ext >&5
18261   rm -rf conftest*
18262   eval "ac_cv_func_$ac_func=no"
18263 fi
18264 rm -f conftest*
18265 fi
18266
18267 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18268   echo "$ac_t""yes" 1>&6
18269     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18270   cat >> confdefs.h <<EOF
18271 #define $ac_tr_func 1
18272 EOF
18273
18274 else
18275   echo "$ac_t""no" 1>&6
18276 fi
18277 done
18278
18279   fi
18280
18281
18282   CXXFLAGS="$ac_save_CXXFLAGS"
18283
18284
18285   for ac_hdr in unistd.h
18286 do
18287 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18288 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18289 echo "configure:18290: checking for $ac_hdr" >&5
18290 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18291   echo $ac_n "(cached) $ac_c" 1>&6
18292 else
18293   cat > conftest.$ac_ext <<EOF
18294 #line 18295 "configure"
18295 #include "confdefs.h"
18296 #include <$ac_hdr>
18297 EOF
18298 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18299 { (eval echo configure:18300: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18300 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18301 if test -z "$ac_err"; then
18302   rm -rf conftest*
18303   eval "ac_cv_header_$ac_safe=yes"
18304 else
18305   echo "$ac_err" >&5
18306   echo "configure: failed program was:" >&5
18307   cat conftest.$ac_ext >&5
18308   rm -rf conftest*
18309   eval "ac_cv_header_$ac_safe=no"
18310 fi
18311 rm -f conftest*
18312 fi
18313 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18314   echo "$ac_t""yes" 1>&6
18315     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18316   cat >> confdefs.h <<EOF
18317 #define $ac_tr_hdr 1
18318 EOF
18319
18320 else
18321   echo "$ac_t""no" 1>&6
18322 fi
18323 done
18324
18325 for ac_func in getpagesize
18326 do
18327 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18328 echo "configure:18329: checking for $ac_func" >&5
18329 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18330   echo $ac_n "(cached) $ac_c" 1>&6
18331 else
18332   cat > conftest.$ac_ext <<EOF
18333 #line 18334 "configure"
18334 #include "confdefs.h"
18335 /* System header to define __stub macros and hopefully few prototypes,
18336     which can conflict with char $ac_func(); below.  */
18337 #include <assert.h>
18338 /* Override any gcc2 internal prototype to avoid an error.  */
18339 /* We use char because int might match the return type of a gcc2
18340     builtin and then its argument prototype would still apply.  */
18341 char $ac_func();
18342
18343 int main() {
18344
18345 /* The GNU C library defines this for functions which it implements
18346     to always fail with ENOSYS.  Some functions are actually named
18347     something starting with __ and the normal name is an alias.  */
18348 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18349 choke me
18350 #else
18351 $ac_func();
18352 #endif
18353
18354 ; return 0; }
18355 EOF
18356 if { (eval echo configure:18357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18357   rm -rf conftest*
18358   eval "ac_cv_func_$ac_func=yes"
18359 else
18360   echo "configure: failed program was:" >&5
18361   cat conftest.$ac_ext >&5
18362   rm -rf conftest*
18363   eval "ac_cv_func_$ac_func=no"
18364 fi
18365 rm -f conftest*
18366 fi
18367
18368 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18369   echo "$ac_t""yes" 1>&6
18370     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18371   cat >> confdefs.h <<EOF
18372 #define $ac_tr_func 1
18373 EOF
18374
18375 else
18376   echo "$ac_t""no" 1>&6
18377 fi
18378 done
18379
18380 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
18381 echo "configure:18382: checking for working mmap" >&5
18382 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
18383   echo $ac_n "(cached) $ac_c" 1>&6
18384 else
18385   if test "$cross_compiling" = yes; then
18386   ac_cv_func_mmap_fixed_mapped=no
18387 else
18388   cat > conftest.$ac_ext <<EOF
18389 #line 18390 "configure"
18390 #include "confdefs.h"
18391
18392 /* Thanks to Mike Haertel and Jim Avera for this test.
18393    Here is a matrix of mmap possibilities:
18394         mmap private not fixed
18395         mmap private fixed at somewhere currently unmapped
18396         mmap private fixed at somewhere already mapped
18397         mmap shared not fixed
18398         mmap shared fixed at somewhere currently unmapped
18399         mmap shared fixed at somewhere already mapped
18400    For private mappings, we should verify that changes cannot be read()
18401    back from the file, nor mmap's back from the file at a different
18402    address.  (There have been systems where private was not correctly
18403    implemented like the infamous i386 svr4.0, and systems where the
18404    VM page cache was not coherent with the filesystem buffer cache
18405    like early versions of FreeBSD and possibly contemporary NetBSD.)
18406    For shared mappings, we should conversely verify that changes get
18407    propogated back to all the places they're supposed to be.
18408
18409    Grep wants private fixed already mapped.
18410    The main things grep needs to know about mmap are:
18411    * does it exist and is it safe to write into the mmap'd area
18412    * how to use it (BSD variants)  */
18413 #include <sys/types.h>
18414 #include <fcntl.h>
18415 #include <sys/mman.h>
18416
18417 /* This mess was copied from the GNU getpagesize.h.  */
18418 #ifndef HAVE_GETPAGESIZE
18419 # ifdef HAVE_UNISTD_H
18420 #  include <unistd.h>
18421 # endif
18422
18423 /* Assume that all systems that can run configure have sys/param.h.  */
18424 # ifndef HAVE_SYS_PARAM_H
18425 #  define HAVE_SYS_PARAM_H 1
18426 # endif
18427
18428 # ifdef _SC_PAGESIZE
18429 #  define getpagesize() sysconf(_SC_PAGESIZE)
18430 # else /* no _SC_PAGESIZE */
18431 #  ifdef HAVE_SYS_PARAM_H
18432 #   include <sys/param.h>
18433 #   ifdef EXEC_PAGESIZE
18434 #    define getpagesize() EXEC_PAGESIZE
18435 #   else /* no EXEC_PAGESIZE */
18436 #    ifdef NBPG
18437 #     define getpagesize() NBPG * CLSIZE
18438 #     ifndef CLSIZE
18439 #      define CLSIZE 1
18440 #     endif /* no CLSIZE */
18441 #    else /* no NBPG */
18442 #     ifdef NBPC
18443 #      define getpagesize() NBPC
18444 #     else /* no NBPC */
18445 #      ifdef PAGESIZE
18446 #       define getpagesize() PAGESIZE
18447 #      endif /* PAGESIZE */
18448 #     endif /* no NBPC */
18449 #    endif /* no NBPG */
18450 #   endif /* no EXEC_PAGESIZE */
18451 #  else /* no HAVE_SYS_PARAM_H */
18452 #   define getpagesize() 8192   /* punt totally */
18453 #  endif /* no HAVE_SYS_PARAM_H */
18454 # endif /* no _SC_PAGESIZE */
18455
18456 #endif /* no HAVE_GETPAGESIZE */
18457
18458 #ifdef __cplusplus
18459 extern "C" { void *malloc(unsigned); }
18460 #else
18461 char *malloc();
18462 #endif
18463
18464 int
18465 main()
18466 {
18467         char *data, *data2, *data3;
18468         int i, pagesize;
18469         int fd;
18470
18471         pagesize = getpagesize();
18472
18473         /*
18474          * First, make a file with some known garbage in it.
18475          */
18476         data = malloc(pagesize);
18477         if (!data)
18478                 exit(1);
18479         for (i = 0; i < pagesize; ++i)
18480                 *(data + i) = rand();
18481         umask(0);
18482         fd = creat("conftestmmap", 0600);
18483         if (fd < 0)
18484                 exit(1);
18485         if (write(fd, data, pagesize) != pagesize)
18486                 exit(1);
18487         close(fd);
18488
18489         /*
18490          * Next, try to mmap the file at a fixed address which
18491          * already has something else allocated at it.  If we can,
18492          * also make sure that we see the same garbage.
18493          */
18494         fd = open("conftestmmap", O_RDWR);
18495         if (fd < 0)
18496                 exit(1);
18497         data2 = malloc(2 * pagesize);
18498         if (!data2)
18499                 exit(1);
18500         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
18501         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
18502             MAP_PRIVATE | MAP_FIXED, fd, 0L))
18503                 exit(1);
18504         for (i = 0; i < pagesize; ++i)
18505                 if (*(data + i) != *(data2 + i))
18506                         exit(1);
18507
18508         /*
18509          * Finally, make sure that changes to the mapped area
18510          * do not percolate back to the file as seen by read().
18511          * (This is a bug on some variants of i386 svr4.0.)
18512          */
18513         for (i = 0; i < pagesize; ++i)
18514                 *(data2 + i) = *(data2 + i) + 1;
18515         data3 = malloc(pagesize);
18516         if (!data3)
18517                 exit(1);
18518         if (read(fd, data3, pagesize) != pagesize)
18519                 exit(1);
18520         for (i = 0; i < pagesize; ++i)
18521                 if (*(data + i) != *(data3 + i))
18522                         exit(1);
18523         close(fd);
18524         unlink("conftestmmap");
18525         exit(0);
18526 }
18527
18528 EOF
18529 if { (eval echo configure:18530: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
18530 then
18531   ac_cv_func_mmap_fixed_mapped=yes
18532 else
18533   echo "configure: failed program was:" >&5
18534   cat conftest.$ac_ext >&5
18535   rm -fr conftest*
18536   ac_cv_func_mmap_fixed_mapped=no
18537 fi
18538 rm -fr conftest*
18539 fi
18540
18541 fi
18542
18543 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
18544 if test $ac_cv_func_mmap_fixed_mapped = yes; then
18545   cat >> confdefs.h <<\EOF
18546 #define HAVE_MMAP 1
18547 EOF
18548
18549 fi
18550
18551 fi
18552
18553
18554
18555 if test "$CANADIAN" = yes; then
18556   CANADIAN_TRUE=
18557   CANADIAN_FALSE='#'
18558 else
18559   CANADIAN_TRUE='#'
18560   CANADIAN_FALSE=
18561 fi
18562
18563
18564 if test "$NULL_TARGET" = yes; then
18565   NULL_TARGET_TRUE=
18566   NULL_TARGET_FALSE='#'
18567 else
18568   NULL_TARGET_TRUE='#'
18569   NULL_TARGET_FALSE=
18570 fi
18571
18572
18573 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
18574   NATIVE_TRUE=
18575   NATIVE_FALSE='#'
18576 else
18577   NATIVE_TRUE='#'
18578   NATIVE_FALSE=
18579 fi
18580
18581
18582 if test -z "$with_cross_host"; then
18583   USE_LIBDIR_TRUE=
18584   USE_LIBDIR_FALSE='#'
18585 else
18586   USE_LIBDIR_TRUE='#'
18587   USE_LIBDIR_FALSE=
18588 fi
18589
18590 cat > confcache <<\EOF
18591 # This file is a shell script that caches the results of configure
18592 # tests run on this system so they can be shared between configure
18593 # scripts and configure runs.  It is not useful on other systems.
18594 # If it contains results you don't want to keep, you may remove or edit it.
18595 #
18596 # By default, configure uses ./config.cache as the cache file,
18597 # creating it if it does not exist already.  You can give configure
18598 # the --cache-file=FILE option to use a different cache file; that is
18599 # what configure does when it calls configure scripts in
18600 # subdirectories, so they share the cache.
18601 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18602 # config.status only pays attention to the cache file if you give it the
18603 # --recheck option to rerun configure.
18604 #
18605 EOF
18606 # The following way of writing the cache mishandles newlines in values,
18607 # but we know of no workaround that is simple, portable, and efficient.
18608 # So, don't put newlines in cache variables' values.
18609 # Ultrix sh set writes to stderr and can't be redirected directly,
18610 # and sets the high bit in the cache file unless we assign to the vars.
18611 (set) 2>&1 |
18612   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18613   *ac_space=\ *)
18614     # `set' does not quote correctly, so add quotes (double-quote substitution
18615     # turns \\\\ into \\, and sed turns \\ into \).
18616     sed -n \
18617       -e "s/'/'\\\\''/g" \
18618       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18619     ;;
18620   *)
18621     # `set' quotes correctly as required by POSIX, so do not add quotes.
18622     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18623     ;;
18624   esac >> confcache
18625 if cmp -s $cache_file confcache; then
18626   :
18627 else
18628   if test -w $cache_file; then
18629     echo "updating cache $cache_file"
18630     cat confcache > $cache_file
18631   else
18632     echo "not updating unwritable cache $cache_file"
18633   fi
18634 fi
18635 rm -f confcache
18636
18637 if test $ac_cv_header_locale_h = yes; then
18638     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
18639 echo "configure:18640: checking for LC_MESSAGES" >&5
18640 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
18641   echo $ac_n "(cached) $ac_c" 1>&6
18642 else
18643   cat > conftest.$ac_ext <<EOF
18644 #line 18645 "configure"
18645 #include "confdefs.h"
18646 #include <locale.h>
18647 int main() {
18648 return LC_MESSAGES
18649 ; return 0; }
18650 EOF
18651 if { (eval echo configure:18652: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18652   rm -rf conftest*
18653   ac_cv_val_LC_MESSAGES=yes
18654 else
18655   echo "configure: failed program was:" >&5
18656   cat conftest.$ac_ext >&5
18657   rm -rf conftest*
18658   ac_cv_val_LC_MESSAGES=no
18659 fi
18660 rm -f conftest*
18661 fi
18662
18663 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
18664     if test $ac_cv_val_LC_MESSAGES = yes; then
18665       cat >> confdefs.h <<\EOF
18666 #define HAVE_LC_MESSAGES 1
18667 EOF
18668
18669     fi
18670   fi
18671
18672 if test "${multilib}" = "yes"; then
18673   multilib_arg="--enable-multilib"
18674 else
18675   multilib_arg=
18676 fi
18677
18678
18679 # Generate the various Makefiles, include files, and scripts.
18680
18681 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
18682 # Needed so that g++ can find the correct include subdir automatically.
18683 INTERFACE=v3
18684
18685 # Check for the interface version number for specifying where header
18686 # files are installed, if a version number is provided.
18687 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
18688 echo "configure:18689: checking for interface version number" >&5
18689 libstdcxx_interface=$INTERFACE
18690 echo "$ac_t""$libstdcxx_interface" 1>&6
18691
18692
18693 # Process the option --with-gxx-include-dir=<path to include-files directory>
18694 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
18695 echo "configure:18696: checking for --with-gxx-include-dir" >&5
18696 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
18697 if test "${with_gxx_include_dir+set}" = set; then
18698   withval="$with_gxx_include_dir"
18699   case "${withval}" in
18700   yes)
18701     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
18702     gxx_include_dir=no
18703     ;;
18704   no)
18705     gxx_include_dir=no
18706     ;;
18707   *)
18708     gxx_include_dir=${withval}
18709     ;;
18710 esac
18711 else
18712   gxx_include_dir=no
18713 fi
18714
18715 echo "$ac_t""$gxx_include_dir" 1>&6
18716
18717
18718
18719 if test x${gxx_include_dir} != xno; then
18720   GXX_INCLUDE_DIR_TRUE=
18721   GXX_INCLUDE_DIR_FALSE='#'
18722 else
18723   GXX_INCLUDE_DIR_TRUE='#'
18724   GXX_INCLUDE_DIR_FALSE=
18725 fi
18726
18727 # Process the option "--enable-version-specific-runtime-libs"
18728 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
18729 echo "configure:18730: checking for --enable-version-specific-runtime-libs" >&5
18730 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
18731 if test "${enable_version_specific_runtime_libs+set}" = set; then
18732   enableval="$enable_version_specific_runtime_libs"
18733     version_specific_libs=yes
18734 # Need the gcc compiler version to know where to install libraries
18735 # and header files if --enable-version-specific-runtime-libs option
18736 # is selected.
18737 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
18738 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
18739 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
18740 #gcc_version=$gcc_num-$gcc_date
18741 gcc_version=$gcc_num
18742
18743
18744 else
18745   version_specific_libs=no
18746 fi
18747
18748 echo "$ac_t""$version_specific_libs" 1>&6
18749 if test x${version_specific_libs} = xyes; then
18750
18751
18752 if test x${version_specific_libs} = xyes; then
18753   VERSION_SPECIFIC_LIBS_TRUE=
18754   VERSION_SPECIFIC_LIBS_FALSE='#'
18755 else
18756   VERSION_SPECIFIC_LIBS_TRUE='#'
18757   VERSION_SPECIFIC_LIBS_FALSE=
18758 fi
18759   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
18760 fi
18761
18762
18763
18764 # Export all the include and flag information to makefiles.
18765
18766   # Root level of the include sources.
18767   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
18768
18769   # Can either use include/c or include/c_std to grab "C" headers. This
18770   # variable is set to the include directory currently in use.
18771   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
18772
18773   # Passed down for cross compilers, canadian crosses.
18774   TOPLEVEL_INCLUDES='-I$(includedir)'
18775
18776   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
18777
18778   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
18779
18780   #if GLIBCPP_NEED_LIBIO
18781   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
18782   #else
18783   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
18784   #endif
18785
18786   #if GLIBCPP_USE_CSHADOW
18787   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
18788   #                   -I$(top_blddir)/cshadow'
18789   #else
18790   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
18791   #endif
18792
18793   # Now, export this to all the little Makefiles....
18794
18795
18796
18797
18798
18799
18800
18801
18802   # Optimization flags that are probably a good idea for thrill-seekers. Just
18803   # uncomment the lines below and make, everything else is ready to go...
18804   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
18805   OPTIMIZE_CXXFLAGS=
18806
18807
18808   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
18809
18810
18811
18812 # This should be done by mkincludedir, but hack around it now.
18813 blddir=`pwd`
18814 echo "checking for $blddir/include"
18815
18816 if test ! -d "$blddir/include"; then
18817   mkdir "$blddir/include"
18818 fi
18819
18820 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
18821 # so that multilib installs will end up installed in the correct
18822 # place. To work around this not being passed down from config-ml.in
18823 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
18824 # append it here.
18825 trap '' 1 2 15
18826 cat > confcache <<\EOF
18827 # This file is a shell script that caches the results of configure
18828 # tests run on this system so they can be shared between configure
18829 # scripts and configure runs.  It is not useful on other systems.
18830 # If it contains results you don't want to keep, you may remove or edit it.
18831 #
18832 # By default, configure uses ./config.cache as the cache file,
18833 # creating it if it does not exist already.  You can give configure
18834 # the --cache-file=FILE option to use a different cache file; that is
18835 # what configure does when it calls configure scripts in
18836 # subdirectories, so they share the cache.
18837 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18838 # config.status only pays attention to the cache file if you give it the
18839 # --recheck option to rerun configure.
18840 #
18841 EOF
18842 # The following way of writing the cache mishandles newlines in values,
18843 # but we know of no workaround that is simple, portable, and efficient.
18844 # So, don't put newlines in cache variables' values.
18845 # Ultrix sh set writes to stderr and can't be redirected directly,
18846 # and sets the high bit in the cache file unless we assign to the vars.
18847 (set) 2>&1 |
18848   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18849   *ac_space=\ *)
18850     # `set' does not quote correctly, so add quotes (double-quote substitution
18851     # turns \\\\ into \\, and sed turns \\ into \).
18852     sed -n \
18853       -e "s/'/'\\\\''/g" \
18854       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18855     ;;
18856   *)
18857     # `set' quotes correctly as required by POSIX, so do not add quotes.
18858     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18859     ;;
18860   esac >> confcache
18861 if cmp -s $cache_file confcache; then
18862   :
18863 else
18864   if test -w $cache_file; then
18865     echo "updating cache $cache_file"
18866     cat confcache > $cache_file
18867   else
18868     echo "not updating unwritable cache $cache_file"
18869   fi
18870 fi
18871 rm -f confcache
18872
18873 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
18874
18875 test "x$prefix" = xNONE && prefix=$ac_default_prefix
18876 # Let make expand exec_prefix.
18877 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
18878
18879 # Any assignment to VPATH causes Sun make to only execute
18880 # the first set of double-colon rules, so remove it if not needed.
18881 # If there is a colon in the path, we need to keep it.
18882 if test "x$srcdir" = x.; then
18883   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
18884 fi
18885
18886 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
18887
18888 DEFS=-DHAVE_CONFIG_H
18889
18890 # Without the "./", some shells look in PATH for config.status.
18891 : ${CONFIG_STATUS=./config.status}
18892
18893 echo creating $CONFIG_STATUS
18894 rm -f $CONFIG_STATUS
18895 cat > $CONFIG_STATUS <<EOF
18896 #! /bin/sh
18897 # Generated automatically by configure.
18898 # Run this file to recreate the current configuration.
18899 # This directory was configured as follows,
18900 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
18901 #
18902 # $0 $ac_configure_args
18903 #
18904 # Compiler output produced by configure, useful for debugging
18905 # configure, is in ./config.log if it exists.
18906
18907 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
18908 for ac_option
18909 do
18910   case "\$ac_option" in
18911   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
18912     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
18913     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
18914   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
18915     echo "$CONFIG_STATUS generated by autoconf version 2.13"
18916     exit 0 ;;
18917   -help | --help | --hel | --he | --h)
18918     echo "\$ac_cs_usage"; exit 0 ;;
18919   *) echo "\$ac_cs_usage"; exit 1 ;;
18920   esac
18921 done
18922
18923 ac_given_srcdir=$srcdir
18924 ac_given_INSTALL="$INSTALL"
18925
18926 trap 'rm -fr `echo "mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
18927 EOF
18928 cat >> $CONFIG_STATUS <<EOF
18929
18930 # Protect against being on the right side of a sed subst in config.status.
18931 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
18932  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
18933 $ac_vpsub
18934 $extrasub
18935 s%@SHELL@%$SHELL%g
18936 s%@CFLAGS@%$CFLAGS%g
18937 s%@CPPFLAGS@%$CPPFLAGS%g
18938 s%@CXXFLAGS@%$CXXFLAGS%g
18939 s%@FFLAGS@%$FFLAGS%g
18940 s%@DEFS@%$DEFS%g
18941 s%@LDFLAGS@%$LDFLAGS%g
18942 s%@LIBS@%$LIBS%g
18943 s%@exec_prefix@%$exec_prefix%g
18944 s%@prefix@%$prefix%g
18945 s%@program_transform_name@%$program_transform_name%g
18946 s%@bindir@%$bindir%g
18947 s%@sbindir@%$sbindir%g
18948 s%@libexecdir@%$libexecdir%g
18949 s%@datadir@%$datadir%g
18950 s%@sysconfdir@%$sysconfdir%g
18951 s%@sharedstatedir@%$sharedstatedir%g
18952 s%@localstatedir@%$localstatedir%g
18953 s%@libdir@%$libdir%g
18954 s%@includedir@%$includedir%g
18955 s%@oldincludedir@%$oldincludedir%g
18956 s%@infodir@%$infodir%g
18957 s%@mandir@%$mandir%g
18958 s%@host@%$host%g
18959 s%@host_alias@%$host_alias%g
18960 s%@host_cpu@%$host_cpu%g
18961 s%@host_vendor@%$host_vendor%g
18962 s%@host_os@%$host_os%g
18963 s%@target@%$target%g
18964 s%@target_alias@%$target_alias%g
18965 s%@target_cpu@%$target_cpu%g
18966 s%@target_vendor@%$target_vendor%g
18967 s%@target_os@%$target_os%g
18968 s%@build@%$build%g
18969 s%@build_alias@%$build_alias%g
18970 s%@build_cpu@%$build_cpu%g
18971 s%@build_vendor@%$build_vendor%g
18972 s%@build_os@%$build_os%g
18973 s%@glibcpp_basedir@%$glibcpp_basedir%g
18974 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
18975 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
18976 s%@INSTALL_DATA@%$INSTALL_DATA%g
18977 s%@PACKAGE@%$PACKAGE%g
18978 s%@VERSION@%$VERSION%g
18979 s%@ACLOCAL@%$ACLOCAL%g
18980 s%@AUTOCONF@%$AUTOCONF%g
18981 s%@AUTOMAKE@%$AUTOMAKE%g
18982 s%@AUTOHEADER@%$AUTOHEADER%g
18983 s%@MAKEINFO@%$MAKEINFO%g
18984 s%@SET_MAKE@%$SET_MAKE%g
18985 s%@CC@%$CC%g
18986 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
18987 s%@CXX@%$CXX%g
18988 s%@AS@%$AS%g
18989 s%@AR@%$AR%g
18990 s%@RANLIB@%$RANLIB%g
18991 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
18992 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
18993 s%@MAINT@%$MAINT%g
18994 s%@EXEEXT@%$EXEEXT%g
18995 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
18996 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
18997 s%@LN_S@%$LN_S%g
18998 s%@OBJEXT@%$OBJEXT%g
18999 s%@STRIP@%$STRIP%g
19000 s%@LIBTOOL@%$LIBTOOL%g
19001 s%@CXXCPP@%$CXXCPP%g
19002 s%@enable_shared@%$enable_shared%g
19003 s%@enable_static@%$enable_static%g
19004 s%@ifGNUmake@%$ifGNUmake%g
19005 s%@CPP@%$CPP%g
19006 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
19007 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
19008 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
19009 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
19010 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
19011 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
19012 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
19013 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
19014 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
19015 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
19016 s%@WERROR@%$WERROR%g
19017 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
19018 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
19019 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
19020 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
19021 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
19022 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
19023 s%@libinst_wstring_la@%$libinst_wstring_la%g
19024 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
19025 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
19026 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
19027 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
19028 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
19029 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
19030 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
19031 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
19032 s%@libstdcxx_interface@%$libstdcxx_interface%g
19033 s%@gxx_include_dir@%$gxx_include_dir%g
19034 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
19035 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
19036 s%@gcc_version@%$gcc_version%g
19037 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
19038 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
19039 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
19040 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
19041 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
19042 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
19043 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
19044 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
19045 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
19046 s%@WARN_FLAGS@%$WARN_FLAGS%g
19047
19048 CEOF
19049 EOF
19050
19051 cat >> $CONFIG_STATUS <<\EOF
19052
19053 # Split the substitutions into bite-sized pieces for seds with
19054 # small command number limits, like on Digital OSF/1 and HP-UX.
19055 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
19056 ac_file=1 # Number of current file.
19057 ac_beg=1 # First line for current file.
19058 ac_end=$ac_max_sed_cmds # Line after last line for current file.
19059 ac_more_lines=:
19060 ac_sed_cmds=""
19061 while $ac_more_lines; do
19062   if test $ac_beg -gt 1; then
19063     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
19064   else
19065     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
19066   fi
19067   if test ! -s conftest.s$ac_file; then
19068     ac_more_lines=false
19069     rm -f conftest.s$ac_file
19070   else
19071     if test -z "$ac_sed_cmds"; then
19072       ac_sed_cmds="sed -f conftest.s$ac_file"
19073     else
19074       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
19075     fi
19076     ac_file=`expr $ac_file + 1`
19077     ac_beg=$ac_end
19078     ac_end=`expr $ac_end + $ac_max_sed_cmds`
19079   fi
19080 done
19081 if test -z "$ac_sed_cmds"; then
19082   ac_sed_cmds=cat
19083 fi
19084 EOF
19085
19086 cat >> $CONFIG_STATUS <<EOF
19087
19088 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
19089 EOF
19090 cat >> $CONFIG_STATUS <<\EOF
19091 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
19092   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19093   case "$ac_file" in
19094   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19095        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19096   *) ac_file_in="${ac_file}.in" ;;
19097   esac
19098
19099   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
19100
19101   # Remove last slash and all that follows it.  Not all systems have dirname.
19102   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19103   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19104     # The file is in a subdirectory.
19105     test ! -d "$ac_dir" && mkdir "$ac_dir"
19106     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
19107     # A "../" for each directory in $ac_dir_suffix.
19108     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
19109   else
19110     ac_dir_suffix= ac_dots=
19111   fi
19112
19113   case "$ac_given_srcdir" in
19114   .)  srcdir=.
19115       if test -z "$ac_dots"; then top_srcdir=.
19116       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
19117   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
19118   *) # Relative path.
19119     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
19120     top_srcdir="$ac_dots$ac_given_srcdir" ;;
19121   esac
19122
19123   case "$ac_given_INSTALL" in
19124   [/$]*) INSTALL="$ac_given_INSTALL" ;;
19125   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
19126   esac
19127
19128   echo creating "$ac_file"
19129   rm -f "$ac_file"
19130   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
19131   case "$ac_file" in
19132   *Makefile*) ac_comsub="1i\\
19133 # $configure_input" ;;
19134   *) ac_comsub= ;;
19135   esac
19136
19137   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19138   sed -e "$ac_comsub
19139 s%@configure_input@%$configure_input%g
19140 s%@srcdir@%$srcdir%g
19141 s%@top_srcdir@%$top_srcdir%g
19142 s%@INSTALL@%$INSTALL%g
19143 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
19144 fi; done
19145 rm -f conftest.s*
19146
19147 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
19148 # NAME is the cpp macro being defined and VALUE is the value it is being given.
19149 #
19150 # ac_d sets the value in "#define NAME VALUE" lines.
19151 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
19152 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
19153 ac_dC='\3'
19154 ac_dD='%g'
19155 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
19156 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19157 ac_uB='\([      ]\)%\1#\2define\3'
19158 ac_uC=' '
19159 ac_uD='\4%g'
19160 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
19161 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19162 ac_eB='$%\1#\2define\3'
19163 ac_eC=' '
19164 ac_eD='%g'
19165
19166 if test "${CONFIG_HEADERS+set}" != set; then
19167 EOF
19168 cat >> $CONFIG_STATUS <<EOF
19169   CONFIG_HEADERS="config.h"
19170 EOF
19171 cat >> $CONFIG_STATUS <<\EOF
19172 fi
19173 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
19174   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19175   case "$ac_file" in
19176   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19177        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19178   *) ac_file_in="${ac_file}.in" ;;
19179   esac
19180
19181   echo creating $ac_file
19182
19183   rm -f conftest.frag conftest.in conftest.out
19184   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19185   cat $ac_file_inputs > conftest.in
19186
19187 EOF
19188
19189 # Transform confdefs.h into a sed script conftest.vals that substitutes
19190 # the proper values into config.h.in to produce config.h.  And first:
19191 # Protect against being on the right side of a sed subst in config.status.
19192 # Protect against being in an unquoted here document in config.status.
19193 rm -f conftest.vals
19194 cat > conftest.hdr <<\EOF
19195 s/[\\&%]/\\&/g
19196 s%[\\$`]%\\&%g
19197 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
19198 s%ac_d%ac_u%gp
19199 s%ac_u%ac_e%gp
19200 EOF
19201 sed -n -f conftest.hdr confdefs.h > conftest.vals
19202 rm -f conftest.hdr
19203
19204 # This sed command replaces #undef with comments.  This is necessary, for
19205 # example, in the case of _POSIX_SOURCE, which is predefined and required
19206 # on some systems where configure will not decide to define it.
19207 cat >> conftest.vals <<\EOF
19208 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
19209 EOF
19210
19211 # Break up conftest.vals because some shells have a limit on
19212 # the size of here documents, and old seds have small limits too.
19213
19214 rm -f conftest.tail
19215 while :
19216 do
19217   ac_lines=`grep -c . conftest.vals`
19218   # grep -c gives empty output for an empty file on some AIX systems.
19219   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
19220   # Write a limited-size here document to conftest.frag.
19221   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
19222   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
19223   echo 'CEOF
19224   sed -f conftest.frag conftest.in > conftest.out
19225   rm -f conftest.in
19226   mv conftest.out conftest.in
19227 ' >> $CONFIG_STATUS
19228   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
19229   rm -f conftest.vals
19230   mv conftest.tail conftest.vals
19231 done
19232 rm -f conftest.vals
19233
19234 cat >> $CONFIG_STATUS <<\EOF
19235   rm -f conftest.frag conftest.h
19236   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
19237   cat conftest.in >> conftest.h
19238   rm -f conftest.in
19239   if cmp -s $ac_file conftest.h 2>/dev/null; then
19240     echo "$ac_file is unchanged"
19241     rm -f conftest.h
19242   else
19243     # Remove last slash and all that follows it.  Not all systems have dirname.
19244       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19245       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19246       # The file is in a subdirectory.
19247       test ! -d "$ac_dir" && mkdir "$ac_dir"
19248     fi
19249     rm -f $ac_file
19250     mv conftest.h $ac_file
19251   fi
19252 fi; done
19253
19254 EOF
19255
19256 cat >> $CONFIG_STATUS <<EOF
19257 ac_sources="$os_include_dir/bits/os_defines.h $CSTDIO_H $CSTDIO_CC $CCODECVT_C config/$THREADH $ATOMICITYH/bits/atomicity.h $ctype_include_dir/bits/ctype_base.h $ctype_include_dir/bits/ctype_inline.h $ctype_include_dir/bits/ctype_noninline.h $ctype_include_dir/bits/ctype_base.h $ctype_include_dir/bits/ctype_inline.h $ctype_include_dir/bits/ctype_noninline.h $ctype_include_dir/bits/ctype_base.h $ctype_include_dir/bits/ctype_inline.h $ctype_include_dir/bits/ctype_noninline.h"
19258 ac_dests="include/bits/os_defines.h include/bits/c++io.h src/c++io.cc libio/c_codecvt.c include/bits/c++threads.h include/bits/atomicity.h include/bits/ctype_base.h \
19259         include/bits/ctype_inline.h \
19260         include/bits/ctype_noninline.h include/bits/ctype_base.h \
19261         include/bits/ctype_inline.h \
19262         include/bits/ctype_noninline.h include/bits/ctype_base.h include/bits/ctype_inline.h \
19263     include/bits/ctype_noninline.h"
19264 EOF
19265
19266 cat >> $CONFIG_STATUS <<\EOF
19267 srcdir=$ac_given_srcdir
19268 while test -n "$ac_sources"; do
19269   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
19270   set $ac_sources; ac_source=$1; shift; ac_sources=$*
19271
19272   echo "linking $srcdir/$ac_source to $ac_dest"
19273
19274   if test ! -r $srcdir/$ac_source; then
19275     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
19276   fi
19277   rm -f $ac_dest
19278
19279   # Make relative symlinks.
19280   # Remove last slash and all that follows it.  Not all systems have dirname.
19281   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
19282   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
19283     # The dest file is in a subdirectory.
19284     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
19285     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
19286     # A "../" for each directory in $ac_dest_dir_suffix.
19287     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
19288   else
19289     ac_dest_dir_suffix= ac_dots=
19290   fi
19291
19292   case "$srcdir" in
19293   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
19294   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
19295   esac
19296
19297   # Make a symlink if possible; otherwise try a hard link.
19298   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
19299     ln $srcdir/$ac_source $ac_dest; then :
19300   else
19301     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
19302   fi
19303 done
19304 EOF
19305 cat >> $CONFIG_STATUS <<EOF
19306
19307 srcdir=${srcdir}
19308 host=${host}
19309 target=${target}
19310 with_multisubdir=${with_multisubdir}
19311 ac_configure_args="${multilib_arg} ${ac_configure_args}"
19312 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
19313 glibcpp_basedir=${glibcpp_basedir}
19314 CC="${CC}"
19315 CXX="${CXX}"
19316
19317 EOF
19318 cat >> $CONFIG_STATUS <<\EOF
19319 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
19320 if test -n "$CONFIG_FILES"; then
19321   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
19322   grep '^MULTISUBDIR =' Makefile >> src/Makefile
19323 fi
19324 chmod +x mkcheck
19325
19326 exit 0
19327 EOF
19328 chmod +x $CONFIG_STATUS
19329 rm -fr confdefs* $ac_clean_files
19330 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
19331
19332
19333
19334 # Generate bits/c++config.h
19335 # NB: This must be the first generated file as others include it. . .
19336
19337
19338 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
19339 if test ! -f stamp-limits; then
19340
19341   touch stamp-limits
19342 fi
19343
19344
19345 # Sanity checking & User-visible messages.
19346 # Checks down here, otherwise they get scrolled off before
19347 # the user will notice.
19348
19349 # Trying to get more people to read documentation.  Possibly remove
19350 # check and warn all the time. There is no "informational" AC_MSG_
19351 # macro, so these are going to be printed even when --quiet/--silent
19352 # is given.
19353 if test ! -f stamp-sanity-warned; then
19354   touch stamp-sanity-warned
19355   echo ""
19356   echo "Please make certain that you read the installation information here:"
19357   echo "  faster => ${srcdir}/docs/install.html"
19358   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
19359   echo ""
19360   echo "and the configuration information here:"
19361   echo "  faster => ${srcdir}/docs/configopts.html"
19362   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
19363   echo ""
19364   echo "before proceeding with ${_cv_gnu_make_command}."
19365   echo ""
19366 fi
19367
19368
19369 $srcdir/mkc++config $blddir $srcdir
19370 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
19371
19372