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-cstdio        enable stdio for target io package. (default)
  40      --enable-cstdio=LIB    use LIB target-speific io package."
  41 ac_help="$ac_help
  42   --enable-c-mbchar       enable multibyte (wide) characters [default=yes]"
  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 srcdir=
  76 target=NONE
  77 verbose=
  78 x_includes=NONE
  79 x_libraries=NONE
  80 bindir='${exec_prefix}/bin'
  81 sbindir='${exec_prefix}/sbin'
  82 libexecdir='${exec_prefix}/libexec'
  83 datadir='${prefix}/share'
  84 sysconfdir='${prefix}/etc'
  85 sharedstatedir='${prefix}/com'
  86 localstatedir='${prefix}/var'
  87 libdir='${exec_prefix}/lib'
  88 includedir='${prefix}/include'
  89 oldincludedir='/usr/include'
  90 infodir='${prefix}/info'
  91 mandir='${prefix}/man'
  92
  93 # Initialize some other variables.
  94 subdirs=
  95 MFLAGS= MAKEFLAGS=
  96 SHELL=${CONFIG_SHELL-/bin/sh}
  97 # Maximum number of lines to put in a shell here document.
  98 ac_max_here_lines=12
  99
 100 ac_prev=
 101 for ac_option
 102 do
 103
 104   # If the previous option needs an argument, assign it.
 105   if test -n "$ac_prev"; then
 106     eval "$ac_prev=\$ac_option"
 107     ac_prev=
 108     continue
 109   fi
 110
 111   case "$ac_option" in
 112   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 113   *) ac_optarg= ;;
 114   esac
 115
 116   # Accept the important Cygnus configure options, so we can diagnose typos.
 117
 118   case "$ac_option" in
 119
 120   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 121     ac_prev=bindir ;;
 122   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 123     bindir="$ac_optarg" ;;
 124
 125   -build | --build | --buil | --bui | --bu)
 126     ac_prev=build ;;
 127   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 128     build="$ac_optarg" ;;
 129
 130   -cache-file | --cache-file | --cache-fil | --cache-fi \
 131   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 132     ac_prev=cache_file ;;
 133   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 134   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 135     cache_file="$ac_optarg" ;;
 136
 137   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 138     ac_prev=datadir ;;
 139   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 140   | --da=*)
 141     datadir="$ac_optarg" ;;
 142
 143   -disable-* | --disable-*)
 144     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 145     # Reject names that are not valid shell variable names.
 146     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 147       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 148     fi
 149     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 150     eval "enable_${ac_feature}=no" ;;
 151
 152   -enable-* | --enable-*)
 153     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 154     # Reject names that are not valid shell variable names.
 155     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 156       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 157     fi
 158     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 159     case "$ac_option" in
 160       *=*) ;;
 161       *) ac_optarg=yes ;;
 162     esac
 163     eval "enable_${ac_feature}='$ac_optarg'" ;;
 164
 165   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 166   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 167   | --exec | --exe | --ex)
 168     ac_prev=exec_prefix ;;
 169   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 170   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 171   | --exec=* | --exe=* | --ex=*)
 172     exec_prefix="$ac_optarg" ;;
 173
 174   -gas | --gas | --ga | --g)
 175     # Obsolete; use --with-gas.
 176     with_gas=yes ;;
 177
 178   -help | --help | --hel | --he)
 179     # Omit some internal or obsolete options to make the list less imposing.
 180     # This message is too long to be a string in the A/UX 3.1 sh.
 181     cat << EOF
 182 Usage: configure [options] [host]
 183 Options: [defaults in brackets after descriptions]
 184 Configuration:
 185   --cache-file=FILE       cache test results in FILE
 186   --help                  print this message
 187   --no-create             do not create output files
 188   --quiet, --silent       do not print \`checking...' messages
 189   --version               print the version of autoconf that created configure
 190 Directory and file names:
 191   --prefix=PREFIX         install architecture-independent files in PREFIX
 192                           [$ac_default_prefix]
 193   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 194                           [same as prefix]
 195   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 196   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 197   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 198   --datadir=DIR           read-only architecture-independent data in DIR
 199                           [PREFIX/share]
 200   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 201   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 202                           [PREFIX/com]
 203   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 204   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 205   --includedir=DIR        C header files in DIR [PREFIX/include]
 206   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 207   --infodir=DIR           info documentation in DIR [PREFIX/info]
 208   --mandir=DIR            man documentation in DIR [PREFIX/man]
 209   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 210   --program-prefix=PREFIX prepend PREFIX to installed program names
 211   --program-suffix=SUFFIX append SUFFIX to installed program names
 212   --program-transform-name=PROGRAM
 213                           run sed PROGRAM on installed program names
 214 EOF
 215     cat << EOF
 216 Host type:
 217   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 218   --host=HOST             configure for HOST [guessed]
 219   --target=TARGET         configure for TARGET [TARGET=HOST]
 220 Features and packages:
 221   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 222   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 223   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 224   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 225   --x-includes=DIR        X include files are in DIR
 226   --x-libraries=DIR       X library files are in DIR
 227 EOF
 228     if test -n "$ac_help"; then
 229       echo "--enable and --with options recognized:$ac_help"
 230     fi
 231     exit 0 ;;
 232
 233   -host | --host | --hos | --ho)
 234     ac_prev=host ;;
 235   -host=* | --host=* | --hos=* | --ho=*)
 236     host="$ac_optarg" ;;
 237
 238   -includedir | --includedir | --includedi | --included | --include \
 239   | --includ | --inclu | --incl | --inc)
 240     ac_prev=includedir ;;
 241   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 242   | --includ=* | --inclu=* | --incl=* | --inc=*)
 243     includedir="$ac_optarg" ;;
 244
 245   -infodir | --infodir | --infodi | --infod | --info | --inf)
 246     ac_prev=infodir ;;
 247   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 248     infodir="$ac_optarg" ;;
 249
 250   -libdir | --libdir | --libdi | --libd)
 251     ac_prev=libdir ;;
 252   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 253     libdir="$ac_optarg" ;;
 254
 255   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 256   | --libexe | --libex | --libe)
 257     ac_prev=libexecdir ;;
 258   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 259   | --libexe=* | --libex=* | --libe=*)
 260     libexecdir="$ac_optarg" ;;
 261
 262   -localstatedir | --localstatedir | --localstatedi | --localstated \
 263   | --localstate | --localstat | --localsta | --localst \
 264   | --locals | --local | --loca | --loc | --lo)
 265     ac_prev=localstatedir ;;
 266   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 267   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 268   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 269     localstatedir="$ac_optarg" ;;
 270
 271   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 272     ac_prev=mandir ;;
 273   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 274     mandir="$ac_optarg" ;;
 275
 276   -nfp | --nfp | --nf)
 277     # Obsolete; use --without-fp.
 278     with_fp=no ;;
 279
 280   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 281   | --no-cr | --no-c)
 282     no_create=yes ;;
 283
 284   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 285   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 286     no_recursion=yes ;;
 287
 288   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 289   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 290   | --oldin | --oldi | --old | --ol | --o)
 291     ac_prev=oldincludedir ;;
 292   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 293   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 294   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 295     oldincludedir="$ac_optarg" ;;
 296
 297   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 298     ac_prev=prefix ;;
 299   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 300     prefix="$ac_optarg" ;;
 301
 302   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 303   | --program-pre | --program-pr | --program-p)
 304     ac_prev=program_prefix ;;
 305   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 306   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 307     program_prefix="$ac_optarg" ;;
 308
 309   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 310   | --program-suf | --program-su | --program-s)
 311     ac_prev=program_suffix ;;
 312   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 313   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 314     program_suffix="$ac_optarg" ;;
 315
 316   -program-transform-name | --program-transform-name \
 317   | --program-transform-nam | --program-transform-na \
 318   | --program-transform-n | --program-transform- \
 319   | --program-transform | --program-transfor \
 320   | --program-transfo | --program-transf \
 321   | --program-trans | --program-tran \
 322   | --progr-tra | --program-tr | --program-t)
 323     ac_prev=program_transform_name ;;
 324   -program-transform-name=* | --program-transform-name=* \
 325   | --program-transform-nam=* | --program-transform-na=* \
 326   | --program-transform-n=* | --program-transform-=* \
 327   | --program-transform=* | --program-transfor=* \
 328   | --program-transfo=* | --program-transf=* \
 329   | --program-trans=* | --program-tran=* \
 330   | --progr-tra=* | --program-tr=* | --program-t=*)
 331     program_transform_name="$ac_optarg" ;;
 332
 333   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 334   | -silent | --silent | --silen | --sile | --sil)
 335     silent=yes ;;
 336
 337   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 338     ac_prev=sbindir ;;
 339   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 340   | --sbi=* | --sb=*)
 341     sbindir="$ac_optarg" ;;
 342
 343   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 344   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 345   | --sharedst | --shareds | --shared | --share | --shar \
 346   | --sha | --sh)
 347     ac_prev=sharedstatedir ;;
 348   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 349   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 350   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 351   | --sha=* | --sh=*)
 352     sharedstatedir="$ac_optarg" ;;
 353
 354   -site | --site | --sit)
 355     ac_prev=site ;;
 356   -site=* | --site=* | --sit=*)
 357     site="$ac_optarg" ;;
 358
 359   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 360     ac_prev=srcdir ;;
 361   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 362     srcdir="$ac_optarg" ;;
 363
 364   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 365   | --syscon | --sysco | --sysc | --sys | --sy)
 366     ac_prev=sysconfdir ;;
 367   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 368   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 369     sysconfdir="$ac_optarg" ;;
 370
 371   -target | --target | --targe | --targ | --tar | --ta | --t)
 372     ac_prev=target ;;
 373   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 374     target="$ac_optarg" ;;
 375
 376   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 377     verbose=yes ;;
 378
 379   -version | --version | --versio | --versi | --vers)
 380     echo "configure generated by autoconf version 2.13"
 381     exit 0 ;;
 382
 383   -with-* | --with-*)
 384     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 385     # Reject names that are not valid shell variable names.
 386     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 387       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 388     fi
 389     ac_package=`echo $ac_package| sed 's/-/_/g'`
 390     case "$ac_option" in
 391       *=*) ;;
 392       *) ac_optarg=yes ;;
 393     esac
 394     eval "with_${ac_package}='$ac_optarg'" ;;
 395
 396   -without-* | --without-*)
 397     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 398     # Reject names that are not valid shell variable names.
 399     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 400       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 401     fi
 402     ac_package=`echo $ac_package| sed 's/-/_/g'`
 403     eval "with_${ac_package}=no" ;;
 404
 405   --x)
 406     # Obsolete; use --with-x.
 407     with_x=yes ;;
 408
 409   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 410   | --x-incl | --x-inc | --x-in | --x-i)
 411     ac_prev=x_includes ;;
 412   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 413   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 414     x_includes="$ac_optarg" ;;
 415
 416   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 417   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 418     ac_prev=x_libraries ;;
 419   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 420   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 421     x_libraries="$ac_optarg" ;;
 422
 423   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 424     ;;
 425
 426   *)
 427     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 428       echo "configure: warning: $ac_option: invalid host type" 1>&2
 429     fi
 430     if test "x$nonopt" != xNONE; then
 431       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 432     fi
 433     nonopt="$ac_option"
 434     ;;
 435
 436   esac
 437 done
 438
 439 if test -n "$ac_prev"; then
 440   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 441 fi
 442
 443 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 444
 445 # File descriptor usage:
 446 # 0 standard input
 447 # 1 file creation
 448 # 2 errors and warnings
 449 # 3 some systems may open it to /dev/tty
 450 # 4 used on the Kubota Titan
 451 # 6 checking for... messages and results
 452 # 5 compiler messages saved in config.log
 453 if test "$silent" = yes; then
 454   exec 6>/dev/null
 455 else
 456   exec 6>&1
 457 fi
 458 exec 5>./config.log
 459
 460 echo "\
 461 This file contains any messages produced by compilers while
 462 running configure, to aid debugging if configure makes a mistake.
 463 " 1>&5
 464
 465 # Strip out --no-create and --no-recursion so they do not pile up.
 466 # Also quote any args containing shell metacharacters.
 467 ac_configure_args=
 468 for ac_arg
 469 do
 470   case "$ac_arg" in
 471   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 472   | --no-cr | --no-c) ;;
 473   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 474   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 475   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 476   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 477   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 478   esac
 479 done
 480
 481 # NLS nuisances.
 482 # Only set these to C if already set.  These must not be set unconditionally
 483 # because not all systems understand e.g. LANG=C (notably SCO).
 484 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 485 # Non-C LC_CTYPE values break the ctype check.
 486 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 487 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 488 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 489 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 490
 491 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 492 rm -rf conftest* confdefs.h
 493 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 494 echo > confdefs.h
 495
 496 # A filename unique to this package, relative to the directory that
 497 # configure is in, which we can look for to find out if srcdir is correct.
 498 ac_unique_file=src/complex.cc
 499
 500 # Find the source files, if location was not specified.
 501 if test -z "$srcdir"; then
 502   ac_srcdir_defaulted=yes
 503   # Try the directory containing this script, then its parent.
 504   ac_prog=$0
 505   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 506   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 507   srcdir=$ac_confdir
 508   if test ! -r $srcdir/$ac_unique_file; then
 509     srcdir=..
 510   fi
 511 else
 512   ac_srcdir_defaulted=no
 513 fi
 514 if test ! -r $srcdir/$ac_unique_file; then
 515   if test "$ac_srcdir_defaulted" = yes; then
 516     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 517   else
 518     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 519   fi
 520 fi
 521 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 522
 523 # Prefer explicitly selected file to automatically selected ones.
 524 if test -z "$CONFIG_SITE"; then
 525   if test "x$prefix" != xNONE; then
 526     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527   else
 528     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529   fi
 530 fi
 531 for ac_site_file in $CONFIG_SITE; do
 532   if test -r "$ac_site_file"; then
 533     echo "loading site script $ac_site_file"
 534     . "$ac_site_file"
 535   fi
 536 done
 537
 538 if test -r "$cache_file"; then
 539   echo "loading cache $cache_file"
 540   . $cache_file
 541 else
 542   echo "creating cache $cache_file"
 543   > $cache_file
 544 fi
 545
 546 ac_ext=c
 547 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 548 ac_cpp='$CPP $CPPFLAGS'
 549 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 550 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 551 cross_compiling=$ac_cv_prog_cc_cross
 552
 553 ac_exeext=
 554 ac_objext=o
 555 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 556   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 557   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 558     ac_n= ac_c='
 559 ' ac_t='        '
 560   else
 561     ac_n=-n ac_c= ac_t=
 562   fi
 563 else
 564   ac_n= ac_c='\c' ac_t=
 565 fi
 566
 567
 568 ac_aux_dir=
 569 for ac_dir in .. $srcdir/..; do
 570   if test -f $ac_dir/install-sh; then
 571     ac_aux_dir=$ac_dir
 572     ac_install_sh="$ac_aux_dir/install-sh -c"
 573     break
 574   elif test -f $ac_dir/install.sh; then
 575     ac_aux_dir=$ac_dir
 576     ac_install_sh="$ac_aux_dir/install.sh -c"
 577     break
 578   fi
 579 done
 580 if test -z "$ac_aux_dir"; then
 581   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 582 fi
 583 ac_config_guess=$ac_aux_dir/config.guess
 584 ac_config_sub=$ac_aux_dir/config.sub
 585 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 586
 587
 588 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 589
 590 # Do some error checking and defaulting for the host and target type.
 591 # The inputs are:
 592 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 593 #
 594 # The rules are:
 595 # 1. You are not allowed to specify --host, --target, and nonopt at the
 596 #    same time.
 597 # 2. Host defaults to nonopt.
 598 # 3. If nonopt is not specified, then host defaults to the current host,
 599 #    as determined by config.guess.
 600 # 4. Target and build default to nonopt.
 601 # 5. If nonopt is not specified, then target and build default to host.
 602
 603 # The aliases save the names the user supplied, while $host etc.
 604 # will get canonicalized.
 605 case $host---$target---$nonopt in
 606 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 607 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 608 esac
 609
 610
 611 # Make sure we can run config.sub.
 612 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 613 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 614 fi
 615
 616 echo $ac_n "checking host system type""... $ac_c" 1>&6
 617 echo "configure:618: checking host system type" >&5
 618
 619 host_alias=$host
 620 case "$host_alias" in
 621 NONE)
 622   case $nonopt in
 623   NONE)
 624     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 625     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 626     fi ;;
 627   *) host_alias=$nonopt ;;
 628   esac ;;
 629 esac
 630
 631 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 632 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 633 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 634 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 635 echo "$ac_t""$host" 1>&6
 636
 637 echo $ac_n "checking target system type""... $ac_c" 1>&6
 638 echo "configure:639: checking target system type" >&5
 639
 640 target_alias=$target
 641 case "$target_alias" in
 642 NONE)
 643   case $nonopt in
 644   NONE) target_alias=$host_alias ;;
 645   *) target_alias=$nonopt ;;
 646   esac ;;
 647 esac
 648
 649 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 650 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 651 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 652 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 653 echo "$ac_t""$target" 1>&6
 654
 655 echo $ac_n "checking build system type""... $ac_c" 1>&6
 656 echo "configure:657: checking build system type" >&5
 657
 658 build_alias=$build
 659 case "$build_alias" in
 660 NONE)
 661   case $nonopt in
 662   NONE) build_alias=$host_alias ;;
 663   *) build_alias=$nonopt ;;
 664   esac ;;
 665 esac
 666
 667 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 668 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 669 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 670 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 671 echo "$ac_t""$build" 1>&6
 672
 673 test "$host_alias" != "$target_alias" &&
 674   test "$program_prefix$program_suffix$program_transform_name" = \
 675     NONENONEs,x,x, &&
 676   program_prefix=${target_alias}-
 677
 678
 679 # We use these options to decide which functions to include.
 680 # Check whether --with-target-subdir or --without-target-subdir was given.
 681 if test "${with_target_subdir+set}" = set; then
 682   withval="$with_target_subdir"
 683   :
 684 fi
 685
 686 # Check whether --with-cross-host or --without-cross-host was given.
 687 if test "${with_cross_host+set}" = set; then
 688   withval="$with_cross_host"
 689   :
 690 fi
 691
 692
 693 # Find a good install program.  We prefer a C program (faster),
 694 # so one script is as good as another.  But avoid the broken or
 695 # incompatible versions:
 696 # SysV /etc/install, /usr/sbin/install
 697 # SunOS /usr/etc/install
 698 # IRIX /sbin/install
 699 # AIX /bin/install
 700 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 701 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 702 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 703 # ./install, which can be erroneously created by make from ./install.sh.
 704 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 705 echo "configure:706: checking for a BSD compatible install" >&5
 706 if test -z "$INSTALL"; then
 707 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 708   echo $ac_n "(cached) $ac_c" 1>&6
 709 else
 710     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 711   for ac_dir in $PATH; do
 712     # Account for people who put trailing slashes in PATH elements.
 713     case "$ac_dir/" in
 714     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 715     *)
 716       # OSF1 and SCO ODT 3.0 have their own names for install.
 717       # Don't use installbsd from OSF since it installs stuff as root
 718       # by default.
 719       for ac_prog in ginstall scoinst install; do
 720         if test -f $ac_dir/$ac_prog; then
 721           if test $ac_prog = install &&
 722             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 723             # AIX install.  It has an incompatible calling convention.
 724             :
 725           else
 726             ac_cv_path_install="$ac_dir/$ac_prog -c"
 727             break 2
 728           fi
 729         fi
 730       done
 731       ;;
 732     esac
 733   done
 734   IFS="$ac_save_IFS"
 735
 736 fi
 737   if test "${ac_cv_path_install+set}" = set; then
 738     INSTALL="$ac_cv_path_install"
 739   else
 740     # As a last resort, use the slow shell script.  We don't cache a
 741     # path for INSTALL within a source directory, because that will
 742     # break other packages using the cache if that directory is
 743     # removed, or if the path is relative.
 744     INSTALL="$ac_install_sh"
 745   fi
 746 fi
 747 echo "$ac_t""$INSTALL" 1>&6
 748
 749 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 750 # It thinks the first close brace ends the variable substitution.
 751 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 752
 753 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 754
 755 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 756
 757 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 758 echo "configure:759: checking whether build environment is sane" >&5
 759 # Just in case
 760 sleep 1
 761 echo timestamp > conftestfile
 762 # Do `set' in a subshell so we don't clobber the current shell's
 763 # arguments.  Must try -L first in case configure is actually a
 764 # symlink; some systems play weird games with the mod time of symlinks
 765 # (eg FreeBSD returns the mod time of the symlink's containing
 766 # directory).
 767 if (
 768    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 769    if test "$*" = "X"; then
 770       # -L didn't work.
 771       set X `ls -t $srcdir/configure conftestfile`
 772    fi
 773    if test "$*" != "X $srcdir/configure conftestfile" \
 774       && test "$*" != "X conftestfile $srcdir/configure"; then
 775
 776       # If neither matched, then we have a broken ls.  This can happen
 777       # if, for instance, CONFIG_SHELL is bash and it inherits a
 778       # broken ls alias from the environment.  This has actually
 779       # happened.  Such a system could not be considered "sane".
 780       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 781 alias in your environment" 1>&2; exit 1; }
 782    fi
 783
 784    test "$2" = conftestfile
 785    )
 786 then
 787    # Ok.
 788    :
 789 else
 790    { echo "configure: error: newly created file is older than distributed files!
 791 Check your system clock" 1>&2; exit 1; }
 792 fi
 793 rm -f conftest*
 794 echo "$ac_t""yes" 1>&6
 795 if test "$program_transform_name" = s,x,x,; then
 796   program_transform_name=
 797 else
 798   # Double any \ or $.  echo might interpret backslashes.
 799   cat <<\EOF_SED > conftestsed
 800 s,\\,\\\\,g; s,\$,$$,g
 801 EOF_SED
 802   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 803   rm -f conftestsed
 804 fi
 805 test "$program_prefix" != NONE &&
 806   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 807 # Use a double $ so make ignores it.
 808 test "$program_suffix" != NONE &&
 809   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 810
 811 # sed with no file args requires a program.
 812 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 813
 814 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 815 echo "configure:816: checking whether ${MAKE-make} sets \${MAKE}" >&5
 816 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 817 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 818   echo $ac_n "(cached) $ac_c" 1>&6
 819 else
 820   cat > conftestmake <<\EOF
 821 all:
 822         @echo 'ac_maketemp="${MAKE}"'
 823 EOF
 824 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 825 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 826 if test -n "$ac_maketemp"; then
 827   eval ac_cv_prog_make_${ac_make}_set=yes
 828 else
 829   eval ac_cv_prog_make_${ac_make}_set=no
 830 fi
 831 rm -f conftestmake
 832 fi
 833 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 834   echo "$ac_t""yes" 1>&6
 835   SET_MAKE=
 836 else
 837   echo "$ac_t""no" 1>&6
 838   SET_MAKE="MAKE=${MAKE-make}"
 839 fi
 840
 841 if test $host != $build; then
 842   ac_tool_prefix=${host_alias}-
 843 else
 844   ac_tool_prefix=
 845 fi
 846
 847 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 848 echo "configure:849: checking for Cygwin environment" >&5
 849 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 850   echo $ac_n "(cached) $ac_c" 1>&6
 851 else
 852   cat > conftest.$ac_ext <<EOF
 853 #line 854 "configure"
 854 #include "confdefs.h"
 855
 856 int main() {
 857
 858 #ifndef __CYGWIN__
 859 #define __CYGWIN__ __CYGWIN32__
 860 #endif
 861 return __CYGWIN__;
 862 ; return 0; }
 863 EOF
 864 if { (eval echo configure:865: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 865   rm -rf conftest*
 866   ac_cv_cygwin=yes
 867 else
 868   echo "configure: failed program was:" >&5
 869   cat conftest.$ac_ext >&5
 870   rm -rf conftest*
 871   ac_cv_cygwin=no
 872 fi
 873 rm -f conftest*
 874 rm -f conftest*
 875 fi
 876
 877 echo "$ac_t""$ac_cv_cygwin" 1>&6
 878 CYGWIN=
 879 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 880 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 881 echo "configure:882: checking for mingw32 environment" >&5
 882 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 883   echo $ac_n "(cached) $ac_c" 1>&6
 884 else
 885   cat > conftest.$ac_ext <<EOF
 886 #line 887 "configure"
 887 #include "confdefs.h"
 888
 889 int main() {
 890 return __MINGW32__;
 891 ; return 0; }
 892 EOF
 893 if { (eval echo configure:894: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 894   rm -rf conftest*
 895   ac_cv_mingw32=yes
 896 else
 897   echo "configure: failed program was:" >&5
 898   cat conftest.$ac_ext >&5
 899   rm -rf conftest*
 900   ac_cv_mingw32=no
 901 fi
 902 rm -f conftest*
 903 rm -f conftest*
 904 fi
 905
 906 echo "$ac_t""$ac_cv_mingw32" 1>&6
 907 MINGW32=
 908 test "$ac_cv_mingw32" = yes && MINGW32=yes
 909
 910     # Check whether --enable-multilib or --disable-multilib was given.
 911 if test "${enable_multilib+set}" = set; then
 912   enableval="$enable_multilib"
 913   case "${enableval}" in
 914     yes) multilib=yes ;;
 915     no)  multilib=no ;;
 916     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 917    esac
 918 else
 919   multilib=yes
 920 fi
 921
 922       if test "${srcdir}" = "."; then
 923     if test "${with_target_subdir}" != "."; then
 924       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 925     else
 926       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 927     fi
 928   else
 929     glibcpp_basedir="${srcdir}/."
 930   fi
 931
 932
 933
 934 PACKAGE=libstdc++
 935
 936 VERSION=2.90.8
 937
 938 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 939   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 940 fi
 941 cat >> confdefs.h <<EOF
 942 #define PACKAGE "$PACKAGE"
 943 EOF
 944
 945 cat >> confdefs.h <<EOF
 946 #define VERSION "$VERSION"
 947 EOF
 948
 949
 950
 951 missing_dir=`cd $ac_aux_dir && pwd`
 952 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 953 echo "configure:954: checking for working aclocal" >&5
 954 # Run test in a subshell; some versions of sh will print an error if
 955 # an executable is not found, even if stderr is redirected.
 956 # Redirect stdin to placate older versions of autoconf.  Sigh.
 957 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 958    ACLOCAL=aclocal
 959    echo "$ac_t""found" 1>&6
 960 else
 961    ACLOCAL="$missing_dir/missing aclocal"
 962    echo "$ac_t""missing" 1>&6
 963 fi
 964
 965 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 966 echo "configure:967: checking for working autoconf" >&5
 967 # Run test in a subshell; some versions of sh will print an error if
 968 # an executable is not found, even if stderr is redirected.
 969 # Redirect stdin to placate older versions of autoconf.  Sigh.
 970 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 971    AUTOCONF=autoconf
 972    echo "$ac_t""found" 1>&6
 973 else
 974    AUTOCONF="$missing_dir/missing autoconf"
 975    echo "$ac_t""missing" 1>&6
 976 fi
 977
 978 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 979 echo "configure:980: checking for working automake" >&5
 980 # Run test in a subshell; some versions of sh will print an error if
 981 # an executable is not found, even if stderr is redirected.
 982 # Redirect stdin to placate older versions of autoconf.  Sigh.
 983 if (automake --version) < /dev/null > /dev/null 2>&1; then
 984    AUTOMAKE=automake
 985    echo "$ac_t""found" 1>&6
 986 else
 987    AUTOMAKE="$missing_dir/missing automake"
 988    echo "$ac_t""missing" 1>&6
 989 fi
 990
 991 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
 992 echo "configure:993: checking for working autoheader" >&5
 993 # Run test in a subshell; some versions of sh will print an error if
 994 # an executable is not found, even if stderr is redirected.
 995 # Redirect stdin to placate older versions of autoconf.  Sigh.
 996 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
 997    AUTOHEADER=autoheader
 998    echo "$ac_t""found" 1>&6
 999 else
1000    AUTOHEADER="$missing_dir/missing autoheader"
1001    echo "$ac_t""missing" 1>&6
1002 fi
1003
1004 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1005 echo "configure:1006: checking for working makeinfo" >&5
1006 # Run test in a subshell; some versions of sh will print an error if
1007 # an executable is not found, even if stderr is redirected.
1008 # Redirect stdin to placate older versions of autoconf.  Sigh.
1009 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1010    MAKEINFO=makeinfo
1011    echo "$ac_t""found" 1>&6
1012 else
1013    MAKEINFO="$missing_dir/missing makeinfo"
1014    echo "$ac_t""missing" 1>&6
1015 fi
1016
1017
1018
1019   # Never versions of autoconf add an underscore to these functions.
1020   # Prevent future problems ...
1021
1022
1023
1024
1025
1026 #  AC_PROG_CC
1027
1028 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1029 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1030 # are probably using a cross compiler, which will not be able to fully
1031 # link an executable.  This should really be fixed in autoconf
1032 # itself.
1033
1034
1035
1036
1037 # Extract the first word of "gcc", so it can be a program name with args.
1038 set dummy gcc; ac_word=$2
1039 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1040 echo "configure:1041: checking for $ac_word" >&5
1041 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1042   echo $ac_n "(cached) $ac_c" 1>&6
1043 else
1044   if test -n "$CC"; then
1045   ac_cv_prog_CC="$CC" # Let the user override the test.
1046 else
1047   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1048   ac_dummy="$PATH"
1049   for ac_dir in $ac_dummy; do
1050     test -z "$ac_dir" && ac_dir=.
1051     if test -f $ac_dir/$ac_word; then
1052       ac_cv_prog_CC="gcc"
1053       break
1054     fi
1055   done
1056   IFS="$ac_save_ifs"
1057 fi
1058 fi
1059 CC="$ac_cv_prog_CC"
1060 if test -n "$CC"; then
1061   echo "$ac_t""$CC" 1>&6
1062 else
1063   echo "$ac_t""no" 1>&6
1064 fi
1065
1066 if test -z "$CC"; then
1067   # Extract the first word of "cc", so it can be a program name with args.
1068 set dummy cc; ac_word=$2
1069 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1070 echo "configure:1071: checking for $ac_word" >&5
1071 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1072   echo $ac_n "(cached) $ac_c" 1>&6
1073 else
1074   if test -n "$CC"; then
1075   ac_cv_prog_CC="$CC" # Let the user override the test.
1076 else
1077   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1078   ac_prog_rejected=no
1079   ac_dummy="$PATH"
1080   for ac_dir in $ac_dummy; do
1081     test -z "$ac_dir" && ac_dir=.
1082     if test -f $ac_dir/$ac_word; then
1083       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1084         ac_prog_rejected=yes
1085         continue
1086       fi
1087       ac_cv_prog_CC="cc"
1088       break
1089     fi
1090   done
1091   IFS="$ac_save_ifs"
1092 if test $ac_prog_rejected = yes; then
1093   # We found a bogon in the path, so make sure we never use it.
1094   set dummy $ac_cv_prog_CC
1095   shift
1096   if test $# -gt 0; then
1097     # We chose a different compiler from the bogus one.
1098     # However, it has the same basename, so the bogon will be chosen
1099     # first if we set CC to just the basename; use the full file name.
1100     shift
1101     set dummy "$ac_dir/$ac_word" "$@"
1102     shift
1103     ac_cv_prog_CC="$@"
1104   fi
1105 fi
1106 fi
1107 fi
1108 CC="$ac_cv_prog_CC"
1109 if test -n "$CC"; then
1110   echo "$ac_t""$CC" 1>&6
1111 else
1112   echo "$ac_t""no" 1>&6
1113 fi
1114
1115   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1116 fi
1117
1118 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1119 echo "configure:1120: checking whether we are using GNU C" >&5
1120 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1121   echo $ac_n "(cached) $ac_c" 1>&6
1122 else
1123   cat > conftest.c <<EOF
1124 #ifdef __GNUC__
1125   yes;
1126 #endif
1127 EOF
1128 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1129: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1129   ac_cv_prog_gcc=yes
1130 else
1131   ac_cv_prog_gcc=no
1132 fi
1133 fi
1134
1135 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1136
1137 if test $ac_cv_prog_gcc = yes; then
1138   GCC=yes
1139   ac_test_CFLAGS="${CFLAGS+set}"
1140   ac_save_CFLAGS="$CFLAGS"
1141   CFLAGS=
1142   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1143 echo "configure:1144: checking whether ${CC-cc} accepts -g" >&5
1144 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1145   echo $ac_n "(cached) $ac_c" 1>&6
1146 else
1147   echo 'void f(){}' > conftest.c
1148 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1149   ac_cv_prog_cc_g=yes
1150 else
1151   ac_cv_prog_cc_g=no
1152 fi
1153 rm -f conftest*
1154
1155 fi
1156
1157 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1158   if test "$ac_test_CFLAGS" = set; then
1159     CFLAGS="$ac_save_CFLAGS"
1160   elif test $ac_cv_prog_cc_g = yes; then
1161     CFLAGS="-g -O2"
1162   else
1163     CFLAGS="-O2"
1164   fi
1165 else
1166   GCC=
1167   test "${CFLAGS+set}" = set || CFLAGS="-g"
1168 fi
1169
1170
1171 # Can't just call these here as g++ requires libstc++ to be built....
1172 #  AC_PROG_CXX
1173
1174 # Likewise for AC_PROG_CXX.
1175
1176
1177
1178 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1179 # flags that come in CXX while configuring libstdc++.  They're different
1180 # from those used for all other target libraries.  If CXX is set in
1181 # the environment, respect that here.
1182 CXX_libstdcxx=$CXX
1183 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1184 do
1185 # Extract the first word of "$ac_prog", so it can be a program name with args.
1186 set dummy $ac_prog; ac_word=$2
1187 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1188 echo "configure:1189: checking for $ac_word" >&5
1189 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1190   echo $ac_n "(cached) $ac_c" 1>&6
1191 else
1192   if test -n "$CXX_libstdcxx"; then
1193   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1194 else
1195   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1196   ac_dummy="$PATH"
1197   for ac_dir in $ac_dummy; do
1198     test -z "$ac_dir" && ac_dir=.
1199     if test -f $ac_dir/$ac_word; then
1200       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1201       break
1202     fi
1203   done
1204   IFS="$ac_save_ifs"
1205 fi
1206 fi
1207 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1208 if test -n "$CXX_libstdcxx"; then
1209   echo "$ac_t""$CXX_libstdcxx" 1>&6
1210 else
1211   echo "$ac_t""no" 1>&6
1212 fi
1213
1214 test -n "$CXX_libstdcxx" && break
1215 done
1216 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1217
1218 CXX=$CXX_libstdcxx
1219
1220 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1221
1222 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1223 echo "configure:1224: checking whether we are using GNU C++" >&5
1224 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1225   echo $ac_n "(cached) $ac_c" 1>&6
1226 else
1227   cat > conftest.C <<EOF
1228 #ifdef __GNUC__
1229   yes;
1230 #endif
1231 EOF
1232 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1233: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1233   ac_cv_prog_gxx=yes
1234 else
1235   ac_cv_prog_gxx=no
1236 fi
1237 fi
1238
1239 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1240
1241 if test $ac_cv_prog_gxx = yes; then
1242   GXX=yes
1243   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1244   ac_save_CXXFLAGS="$CXXFLAGS"
1245   CXXFLAGS=
1246   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1247 echo "configure:1248: checking whether ${CXX-g++} accepts -g" >&5
1248 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1249   echo $ac_n "(cached) $ac_c" 1>&6
1250 else
1251   echo 'void f(){}' > conftest.cc
1252 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1253   ac_cv_prog_cxx_g=yes
1254 else
1255   ac_cv_prog_cxx_g=no
1256 fi
1257 rm -f conftest*
1258
1259 fi
1260
1261 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1262   if test "$ac_test_CXXFLAGS" = set; then
1263     CXXFLAGS="$ac_save_CXXFLAGS"
1264   elif test $ac_cv_prog_cxx_g = yes; then
1265     CXXFLAGS="-g -O2"
1266   else
1267     CXXFLAGS="-O2"
1268   fi
1269 else
1270   GXX=
1271   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1272 fi
1273
1274
1275   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1276 set dummy ${ac_tool_prefix}as; ac_word=$2
1277 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1278 echo "configure:1279: checking for $ac_word" >&5
1279 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1280   echo $ac_n "(cached) $ac_c" 1>&6
1281 else
1282   if test -n "$AS"; then
1283   ac_cv_prog_AS="$AS" # Let the user override the test.
1284 else
1285   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1286   ac_dummy="$PATH"
1287   for ac_dir in $ac_dummy; do
1288     test -z "$ac_dir" && ac_dir=.
1289     if test -f $ac_dir/$ac_word; then
1290       ac_cv_prog_AS="${ac_tool_prefix}as"
1291       break
1292     fi
1293   done
1294   IFS="$ac_save_ifs"
1295   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1296 fi
1297 fi
1298 AS="$ac_cv_prog_AS"
1299 if test -n "$AS"; then
1300   echo "$ac_t""$AS" 1>&6
1301 else
1302   echo "$ac_t""no" 1>&6
1303 fi
1304
1305
1306
1307   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1308 set dummy ${ac_tool_prefix}ar; ac_word=$2
1309 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1310 echo "configure:1311: checking for $ac_word" >&5
1311 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1312   echo $ac_n "(cached) $ac_c" 1>&6
1313 else
1314   if test -n "$AR"; then
1315   ac_cv_prog_AR="$AR" # Let the user override the test.
1316 else
1317   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1318   ac_dummy="$PATH"
1319   for ac_dir in $ac_dummy; do
1320     test -z "$ac_dir" && ac_dir=.
1321     if test -f $ac_dir/$ac_word; then
1322       ac_cv_prog_AR="${ac_tool_prefix}ar"
1323       break
1324     fi
1325   done
1326   IFS="$ac_save_ifs"
1327   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1328 fi
1329 fi
1330 AR="$ac_cv_prog_AR"
1331 if test -n "$AR"; then
1332   echo "$ac_t""$AR" 1>&6
1333 else
1334   echo "$ac_t""no" 1>&6
1335 fi
1336
1337
1338
1339   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1340 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1341 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1342 echo "configure:1343: checking for $ac_word" >&5
1343 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1344   echo $ac_n "(cached) $ac_c" 1>&6
1345 else
1346   if test -n "$RANLIB"; then
1347   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1348 else
1349   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1350   ac_dummy="$PATH"
1351   for ac_dir in $ac_dummy; do
1352     test -z "$ac_dir" && ac_dir=.
1353     if test -f $ac_dir/$ac_word; then
1354       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1355       break
1356     fi
1357   done
1358   IFS="$ac_save_ifs"
1359 fi
1360 fi
1361 RANLIB="$ac_cv_prog_RANLIB"
1362 if test -n "$RANLIB"; then
1363   echo "$ac_t""$RANLIB" 1>&6
1364 else
1365   echo "$ac_t""no" 1>&6
1366 fi
1367
1368
1369 if test -z "$ac_cv_prog_RANLIB"; then
1370 if test -n "$ac_tool_prefix"; then
1371   # Extract the first word of "ranlib", so it can be a program name with args.
1372 set dummy ranlib; ac_word=$2
1373 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1374 echo "configure:1375: checking for $ac_word" >&5
1375 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1376   echo $ac_n "(cached) $ac_c" 1>&6
1377 else
1378   if test -n "$RANLIB"; then
1379   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1380 else
1381   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1382   ac_dummy="$PATH"
1383   for ac_dir in $ac_dummy; do
1384     test -z "$ac_dir" && ac_dir=.
1385     if test -f $ac_dir/$ac_word; then
1386       ac_cv_prog_RANLIB="ranlib"
1387       break
1388     fi
1389   done
1390   IFS="$ac_save_ifs"
1391   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1392 fi
1393 fi
1394 RANLIB="$ac_cv_prog_RANLIB"
1395 if test -n "$RANLIB"; then
1396   echo "$ac_t""$RANLIB" 1>&6
1397 else
1398   echo "$ac_t""no" 1>&6
1399 fi
1400
1401 else
1402   RANLIB=":"
1403 fi
1404 fi
1405
1406
1407   # Find a good install program.  We prefer a C program (faster),
1408 # so one script is as good as another.  But avoid the broken or
1409 # incompatible versions:
1410 # SysV /etc/install, /usr/sbin/install
1411 # SunOS /usr/etc/install
1412 # IRIX /sbin/install
1413 # AIX /bin/install
1414 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1415 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1416 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1417 # ./install, which can be erroneously created by make from ./install.sh.
1418 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1419 echo "configure:1420: checking for a BSD compatible install" >&5
1420 if test -z "$INSTALL"; then
1421 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1422   echo $ac_n "(cached) $ac_c" 1>&6
1423 else
1424     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1425   for ac_dir in $PATH; do
1426     # Account for people who put trailing slashes in PATH elements.
1427     case "$ac_dir/" in
1428     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1429     *)
1430       # OSF1 and SCO ODT 3.0 have their own names for install.
1431       # Don't use installbsd from OSF since it installs stuff as root
1432       # by default.
1433       for ac_prog in ginstall scoinst install; do
1434         if test -f $ac_dir/$ac_prog; then
1435           if test $ac_prog = install &&
1436             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1437             # AIX install.  It has an incompatible calling convention.
1438             :
1439           else
1440             ac_cv_path_install="$ac_dir/$ac_prog -c"
1441             break 2
1442           fi
1443         fi
1444       done
1445       ;;
1446     esac
1447   done
1448   IFS="$ac_save_IFS"
1449
1450 fi
1451   if test "${ac_cv_path_install+set}" = set; then
1452     INSTALL="$ac_cv_path_install"
1453   else
1454     # As a last resort, use the slow shell script.  We don't cache a
1455     # path for INSTALL within a source directory, because that will
1456     # break other packages using the cache if that directory is
1457     # removed, or if the path is relative.
1458     INSTALL="$ac_install_sh"
1459   fi
1460 fi
1461 echo "$ac_t""$INSTALL" 1>&6
1462
1463 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1464 # It thinks the first close brace ends the variable substitution.
1465 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1466
1467 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1468
1469 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1470
1471
1472   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1473 echo "configure:1474: checking whether to enable maintainer-specific portions of Makefiles" >&5
1474     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1475 if test "${enable_maintainer_mode+set}" = set; then
1476   enableval="$enable_maintainer_mode"
1477   USE_MAINTAINER_MODE=$enableval
1478 else
1479   USE_MAINTAINER_MODE=no
1480 fi
1481
1482   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1483
1484
1485 if test $USE_MAINTAINER_MODE = yes; then
1486   MAINTAINER_MODE_TRUE=
1487   MAINTAINER_MODE_FALSE='#'
1488 else
1489   MAINTAINER_MODE_TRUE='#'
1490   MAINTAINER_MODE_FALSE=
1491 fi
1492   MAINT=$MAINTAINER_MODE_TRUE
1493
1494
1495
1496   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1497   # at least currently, we never actually build a program, so we never
1498   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1499   # fails, because we are probably configuring with a cross compiler
1500   # which cant create executables.  So we include AC_EXEEXT to keep
1501   # automake happy, but we dont execute it, since we dont care about
1502   # the result.
1503   if false; then
1504
1505
1506 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1507 echo "configure:1508: checking for executable suffix" >&5
1508 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1509   echo $ac_n "(cached) $ac_c" 1>&6
1510 else
1511   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1512   ac_cv_exeext=.exe
1513 else
1514   rm -f conftest*
1515   echo 'int main () { return 0; }' > conftest.$ac_ext
1516   ac_cv_exeext=
1517   if { (eval echo configure:1518: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1518     for file in conftest.*; do
1519       case $file in
1520       *.c | *.o | *.obj) ;;
1521       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1522       esac
1523     done
1524   else
1525     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1526   fi
1527   rm -f conftest*
1528   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1529 fi
1530 fi
1531
1532 EXEEXT=""
1533 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1534 echo "$ac_t""${ac_cv_exeext}" 1>&6
1535 ac_exeext=$EXEEXT
1536
1537   fi
1538
1539   # configure.host sets the following important variables
1540   #        glibcpp_cflags    - host specific C compiler flags
1541   #        glibcpp_cxxflags  - host specific C++ compiler flags
1542   glibcpp_cflags=
1543   glibcpp_cxxflags=
1544
1545   . ${glibcpp_basedir}/configure.host
1546
1547   case ${glibcpp_basedir} in
1548     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1549     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1550   esac
1551
1552   # This does for the target what configure.host does for the host.  In
1553   # addition to modifying the same flags, it also sets up symlinks.
1554
1555     . ${glibcpp_basedir}/configure.target
1556     echo "$ac_t""CPU config directory is $cpu_include_dir" 1>&6
1557     echo "$ac_t""OS config directory is $os_include_dir" 1>&6
1558
1559
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
2535 if test ! -f stamp-sanity-compiler; then
2536   echo $ac_n "checking for g++ that will successfully compile libstdc++-v3""... $ac_c" 1>&6
2537 echo "configure:2538: checking for g++ that will successfully compile libstdc++-v3" >&5
2538
2539   ac_ext=C
2540 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2541 ac_cpp='$CXXCPP $CPPFLAGS'
2542 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2543 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2544 cross_compiling=$ac_cv_prog_cxx_cross
2545
2546   cat > conftest.$ac_ext <<EOF
2547 #line 2548 "configure"
2548 #include "confdefs.h"
2549
2550   #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2551     ok
2552   #endif
2553
2554 EOF
2555 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2556   egrep "ok" >/dev/null 2>&1; then
2557   rm -rf conftest*
2558   gpp_satisfactory=yes
2559 else
2560   rm -rf conftest*
2561   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2562 fi
2563 rm -f conftest*
2564
2565   ac_ext=c
2566 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2567 ac_cpp='$CPP $CPPFLAGS'
2568 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2569 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2570 cross_compiling=$ac_cv_prog_cc_cross
2571
2572   echo "$ac_t""$gpp_satisfactory" 1>&6
2573   touch stamp-sanity-compiler
2574 fi
2575
2576
2577 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2578 # Check whether --enable-debug or --disable-debug was given.
2579 if test "${enable_debug+set}" = set; then
2580   enableval="$enable_debug"
2581   case "${enableval}" in
2582  yes) enable_debug=yes ;;
2583  no)  enable_debug=no ;;
2584  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2585  esac
2586 else
2587   enable_debug=no
2588 fi
2589
2590 case "${enable_debug}" in
2591     yes)
2592         DEBUG_FLAGS='-O0 -ggdb3'
2593         ;;
2594     no)
2595         DEBUG_FLAGS='-g'
2596         ;;
2597 esac
2598
2599
2600 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2601 echo "configure:2602: checking how to run the C preprocessor" >&5
2602 # On Suns, sometimes $CPP names a directory.
2603 if test -n "$CPP" && test -d "$CPP"; then
2604   CPP=
2605 fi
2606 if test -z "$CPP"; then
2607 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2608   echo $ac_n "(cached) $ac_c" 1>&6
2609 else
2610     # This must be in double quotes, not single quotes, because CPP may get
2611   # substituted into the Makefile and "${CC-cc}" will confuse make.
2612   CPP="${CC-cc} -E"
2613   # On the NeXT, cc -E runs the code through the compiler's parser,
2614   # not just through cpp.
2615   cat > conftest.$ac_ext <<EOF
2616 #line 2617 "configure"
2617 #include "confdefs.h"
2618 #include <assert.h>
2619 Syntax Error
2620 EOF
2621 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2622 { (eval echo configure:2623: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2623 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2624 if test -z "$ac_err"; then
2625   :
2626 else
2627   echo "$ac_err" >&5
2628   echo "configure: failed program was:" >&5
2629   cat conftest.$ac_ext >&5
2630   rm -rf conftest*
2631   CPP="${CC-cc} -E -traditional-cpp"
2632   cat > conftest.$ac_ext <<EOF
2633 #line 2634 "configure"
2634 #include "confdefs.h"
2635 #include <assert.h>
2636 Syntax Error
2637 EOF
2638 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2639 { (eval echo configure:2640: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2640 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2641 if test -z "$ac_err"; then
2642   :
2643 else
2644   echo "$ac_err" >&5
2645   echo "configure: failed program was:" >&5
2646   cat conftest.$ac_ext >&5
2647   rm -rf conftest*
2648   CPP="${CC-cc} -nologo -E"
2649   cat > conftest.$ac_ext <<EOF
2650 #line 2651 "configure"
2651 #include "confdefs.h"
2652 #include <assert.h>
2653 Syntax Error
2654 EOF
2655 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2656 { (eval echo configure:2657: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2657 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2658 if test -z "$ac_err"; then
2659   :
2660 else
2661   echo "$ac_err" >&5
2662   echo "configure: failed program was:" >&5
2663   cat conftest.$ac_ext >&5
2664   rm -rf conftest*
2665   CPP=/lib/cpp
2666 fi
2667 rm -f conftest*
2668 fi
2669 rm -f conftest*
2670 fi
2671 rm -f conftest*
2672   ac_cv_prog_CPP="$CPP"
2673 fi
2674   CPP="$ac_cv_prog_CPP"
2675 else
2676   ac_cv_prog_CPP="$CPP"
2677 fi
2678 echo "$ac_t""$CPP" 1>&6
2679
2680
2681   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2682 echo "configure:2683: checking for cstdio to use" >&5
2683   # Check whether --enable-cstdio or --disable-cstdio was given.
2684 if test "${enable_cstdio+set}" = set; then
2685   enableval="$enable_cstdio"
2686   if test x$enable_cstdio = xno; then
2687      enable_cstdio=stdio
2688   fi
2689 else
2690   enable_cstdio=stdio
2691 fi
2692
2693
2694   enable_cstdio_flag=$enable_cstdio
2695
2696     case x${enable_cstdio_flag} in
2697     xlibio)
2698       CSTDIO_H=config/c_io_libio.h
2699       CSTDIO_CC=config/c_io_libio.cc
2700       echo "$ac_t""libio" 1>&6
2701
2702       # see if we are on a system with libio native (ie, linux)
2703       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2704 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2705 echo "configure:2706: checking for libio.h" >&5
2706 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2707   echo $ac_n "(cached) $ac_c" 1>&6
2708 else
2709   cat > conftest.$ac_ext <<EOF
2710 #line 2711 "configure"
2711 #include "confdefs.h"
2712 #include <libio.h>
2713 EOF
2714 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2715 { (eval echo configure:2716: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2716 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2717 if test -z "$ac_err"; then
2718   rm -rf conftest*
2719   eval "ac_cv_header_$ac_safe=yes"
2720 else
2721   echo "$ac_err" >&5
2722   echo "configure: failed program was:" >&5
2723   cat conftest.$ac_ext >&5
2724   rm -rf conftest*
2725   eval "ac_cv_header_$ac_safe=no"
2726 fi
2727 rm -f conftest*
2728 fi
2729 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2730   echo "$ac_t""yes" 1>&6
2731   has_libio=yes
2732 else
2733   echo "$ac_t""no" 1>&6
2734 has_libio=no
2735 fi
2736
2737
2738       # Need to check and see what version of glibc is being used. If
2739       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2740       # compile most of libio for linux systems.
2741       if test x$has_libio = x"yes"; then
2742         case "$target" in
2743           *-*-linux*)
2744               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2745 echo "configure:2746: checking for glibc version >= 2.2" >&5
2746               cat > conftest.$ac_ext <<EOF
2747 #line 2748 "configure"
2748 #include "confdefs.h"
2749
2750             #include <features.h>
2751               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2752                     ok
2753               #endif
2754
2755 EOF
2756 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2757   egrep "ok" >/dev/null 2>&1; then
2758   rm -rf conftest*
2759   glibc_satisfactory=yes
2760 else
2761   rm -rf conftest*
2762   glibc_satisfactory=no
2763 fi
2764 rm -f conftest*
2765
2766               echo "$ac_t""$glibc_satisfactory" 1>&6
2767             ;;
2768         esac
2769
2770         # XXX at the moment, admit defeat and force the recompilation
2771         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2772         glibc_satisfactory=no
2773
2774         if test x$glibc_satisfactory = x"yes"; then
2775            need_libio=no
2776            need_wlibio=no
2777         else
2778            need_libio=yes
2779            # bkoz XXX need to add checks to enable this
2780            # pme XXX here's a first pass at such a check
2781            if test x$enable_c_mbchar != xno; then
2782               need_wlibio=yes
2783            else
2784               need_wlibio=no
2785            fi
2786         fi
2787
2788       else
2789          # Using libio, but <libio.h> doesn't exist on the target system. . .
2790          need_libio=yes
2791          # bkoz XXX need to add checks to enable this
2792          # pme XXX here's a first pass at such a check
2793          if test x$enable_c_mbchar != xno; then
2794              need_wlibio=yes
2795          else
2796              need_wlibio=no
2797          fi
2798       fi
2799       ;;
2800     xstdio | x | xno | xnone | xyes)
2801       # default
2802       CSTDIO_H=config/c_io_stdio.h
2803       CSTDIO_CC=config/c_io_stdio.cc
2804       echo "$ac_t""stdio" 1>&6
2805
2806       # We're not using stdio.
2807       need_libio=no
2808       need_wlibio=no
2809       # Wide characters are not supported with this package.
2810       enable_c_mbchar=no
2811       ;;
2812     *)
2813       echo "$enable_cstdio is an unknown io package" 1>&2
2814       exit 1
2815       ;;
2816   esac
2817
2818
2819
2820   # 2000-08-04 bkoz hack
2821   CCODECVT_C=config/c_io_libio_codecvt.c
2822
2823   # 2000-08-04 bkoz hack
2824
2825
2826
2827 if test "$need_libio" = yes; then
2828   GLIBCPP_NEED_LIBIO_TRUE=
2829   GLIBCPP_NEED_LIBIO_FALSE='#'
2830 else
2831   GLIBCPP_NEED_LIBIO_TRUE='#'
2832   GLIBCPP_NEED_LIBIO_FALSE=
2833 fi
2834
2835
2836 if test "$need_wlibio" = yes; then
2837   GLIBCPP_NEED_WLIBIO_TRUE=
2838   GLIBCPP_NEED_WLIBIO_FALSE='#'
2839 else
2840   GLIBCPP_NEED_WLIBIO_TRUE='#'
2841   GLIBCPP_NEED_WLIBIO_FALSE=
2842 fi
2843   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2844         libio_la=../libio/libio.la
2845   else
2846         libio_la=
2847   fi
2848
2849
2850 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2851 if test "${enable_c_mbchar+set}" = set; then
2852   enableval="$enable_c_mbchar"
2853   case "$enableval" in
2854  yes) enable_c_mbchar=yes ;;
2855  no)  enable_c_mbchar=no ;;
2856  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2857  esac
2858 else
2859   enable_c_mbchar=yes
2860 fi
2861
2862
2863   # Check whether --enable-long-long or --disable-long-long was given.
2864 if test "${enable_long_long+set}" = set; then
2865   enableval="$enable_long_long"
2866     case "$enableval" in
2867    yes) enable_long_long=yes ;;
2868    no)  enable_long_long=no ;;
2869    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2870    esac
2871 else
2872   enable_long_long=yes
2873 fi
2874
2875   # Check for the existance of functions used if long long is enabled.
2876   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2877 echo "configure:2878: checking for strtoll" >&5
2878 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2879   echo $ac_n "(cached) $ac_c" 1>&6
2880 else
2881   cat > conftest.$ac_ext <<EOF
2882 #line 2883 "configure"
2883 #include "confdefs.h"
2884 /* System header to define __stub macros and hopefully few prototypes,
2885     which can conflict with char strtoll(); below.  */
2886 #include <assert.h>
2887 /* Override any gcc2 internal prototype to avoid an error.  */
2888 /* We use char because int might match the return type of a gcc2
2889     builtin and then its argument prototype would still apply.  */
2890 char strtoll();
2891
2892 int main() {
2893
2894 /* The GNU C library defines this for functions which it implements
2895     to always fail with ENOSYS.  Some functions are actually named
2896     something starting with __ and the normal name is an alias.  */
2897 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2898 choke me
2899 #else
2900 strtoll();
2901 #endif
2902
2903 ; return 0; }
2904 EOF
2905 if { (eval echo configure:2906: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2906   rm -rf conftest*
2907   eval "ac_cv_func_strtoll=yes"
2908 else
2909   echo "configure: failed program was:" >&5
2910   cat conftest.$ac_ext >&5
2911   rm -rf conftest*
2912   eval "ac_cv_func_strtoll=no"
2913 fi
2914 rm -f conftest*
2915 fi
2916
2917 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2918   echo "$ac_t""yes" 1>&6
2919   :
2920 else
2921   echo "$ac_t""no" 1>&6
2922 ac_strtoll=no
2923 fi
2924
2925   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2926 echo "configure:2927: checking for strtoull" >&5
2927 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2928   echo $ac_n "(cached) $ac_c" 1>&6
2929 else
2930   cat > conftest.$ac_ext <<EOF
2931 #line 2932 "configure"
2932 #include "confdefs.h"
2933 /* System header to define __stub macros and hopefully few prototypes,
2934     which can conflict with char strtoull(); below.  */
2935 #include <assert.h>
2936 /* Override any gcc2 internal prototype to avoid an error.  */
2937 /* We use char because int might match the return type of a gcc2
2938     builtin and then its argument prototype would still apply.  */
2939 char strtoull();
2940
2941 int main() {
2942
2943 /* The GNU C library defines this for functions which it implements
2944     to always fail with ENOSYS.  Some functions are actually named
2945     something starting with __ and the normal name is an alias.  */
2946 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2947 choke me
2948 #else
2949 strtoull();
2950 #endif
2951
2952 ; return 0; }
2953 EOF
2954 if { (eval echo configure:2955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2955   rm -rf conftest*
2956   eval "ac_cv_func_strtoull=yes"
2957 else
2958   echo "configure: failed program was:" >&5
2959   cat conftest.$ac_ext >&5
2960   rm -rf conftest*
2961   eval "ac_cv_func_strtoull=no"
2962 fi
2963 rm -f conftest*
2964 fi
2965
2966 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2967   echo "$ac_t""yes" 1>&6
2968   :
2969 else
2970   echo "$ac_t""no" 1>&6
2971 ac_strtoull=no
2972 fi
2973
2974
2975   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2976 echo "configure:2977: checking for enabled long long" >&5
2977   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2978     enable_long_long=no;
2979   fi;
2980   echo "$ac_t""$enable_long_long" 1>&6
2981
2982     if test x"$enable_long_long" = xyes; then
2983     cat >> confdefs.h <<\EOF
2984 #define _GLIBCPP_USE_LONG_LONG 1
2985 EOF
2986
2987   fi
2988
2989 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2990 echo "configure:2991: checking for enabled cshadow headers" >&5
2991 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2992 if test "${enable_cshadow_headers+set}" = set; then
2993   enableval="$enable_cshadow_headers"
2994
2995   case "$enableval" in
2996    yes) enable_cshadow_headers=yes
2997         ;;
2998    no)  enable_cshadow_headers=no
2999         ;;
3000    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3001         ;;
3002   esac
3003 else
3004   enable_cshadow_headers=no
3005 fi
3006
3007   echo "$ac_t""$enable_cshadow_headers" 1>&6
3008
3009       case "$enable_cshadow_headers" in
3010     yes)
3011         CSHADOW_FLAGS="-fno-builtin"
3012         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3013         cat >> confdefs.h <<\EOF
3014 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3015 EOF
3016
3017         ;;
3018     no)
3019         CSHADOW_FLAGS=""
3020         C_INCLUDE_DIR='${top_srcdir}/include/c'
3021         ;;
3022   esac
3023
3024
3025
3026
3027
3028 if test "$enable_cshadow_headers" = yes; then
3029   GLIBCPP_USE_CSHADOW_TRUE=
3030   GLIBCPP_USE_CSHADOW_FALSE='#'
3031 else
3032   GLIBCPP_USE_CSHADOW_TRUE='#'
3033   GLIBCPP_USE_CSHADOW_FALSE=
3034 fi
3035
3036
3037       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3038 echo "configure:3039: checking for threads package to use" >&5
3039   # Check whether --enable-threads or --disable-threads was given.
3040 if test "${enable_threads+set}" = set; then
3041   enableval="$enable_threads"
3042   if test x$enable_threads = xno; then
3043     enable_threads=''
3044   fi
3045 else
3046   enable_threads=''
3047 fi
3048
3049
3050   enable_threads_flag=$enable_threads
3051
3052     case x${enable_threads_flag} in
3053         x | xno | xnone)
3054                 # No threads
3055                 target_thread_file='single'
3056                 ;;
3057         xyes)
3058                 # default
3059                 target_thread_file='posix'
3060                 ;;
3061         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3062         xsolaris | xwin32 | xdce | xvxworks)
3063                 target_thread_file=$enable_threads_flag
3064                 ;;
3065         *)
3066                 echo "$enable_threads is an unknown thread package" 1>&2
3067                 exit 1
3068                 ;;
3069   esac
3070
3071     THREADH=
3072   case "$target_thread_file" in
3073     no | none | single)
3074       THREADH=threads-no.h
3075       ;;
3076     posix | pthreads)
3077       THREADH=threads-posix.h
3078       ;;
3079     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3080       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3081       ;;
3082     *)
3083       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3084       ;;
3085   esac
3086   echo "$ac_t""$THREADH" 1>&6
3087
3088
3089   if test $THREADH != threads-no.h; then
3090     cat >> confdefs.h <<\EOF
3091 #define _GLIBCPP_USE_THREADS 1
3092 EOF
3093
3094   fi
3095
3096
3097     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3098 echo "configure:3099: checking for atomicity.h" >&5
3099     # We have ATOMICITY already from GLIBCPP_CONFIGURE
3100     if test "$ATOMICITYH" = "config/cpu/generic"; then
3101       echo "configure: warning: No ATOMICITY settings found, using generic atomic ops." 1>&2
3102     fi
3103     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3104
3105
3106 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3107 if test "${enable_cxx_flags+set}" = set; then
3108   enableval="$enable_cxx_flags"
3109   case "x$enableval" in
3110  xyes)
3111         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3112  xno|x)
3113         enable_cxx_flags='' ;;
3114  *)
3115         enable_cxx_flags="$enableval" ;;
3116  esac
3117 else
3118   enable_cxx_flags='none'
3119 fi
3120
3121
3122 if test "$enable_cxx_flags" = "none"; then
3123   enable_cxx_flags='';
3124 fi
3125
3126 if test -n "$enable_cxx_flags"; then
3127     for f in $enable_cxx_flags; do
3128         case "$f" in
3129             -fhonor-std)  ;;
3130             -*)  ;;
3131             *)   # and we're trying to pass /what/ exactly?
3132                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3133         esac
3134     done
3135 fi
3136 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3137
3138
3139
3140
3141 if test -n "$with_cross_host"; then
3142
3143   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3144   # may not work correctly, because the compiler may not be able to
3145   # link executables.
3146
3147   xcompiling=1
3148   NATIVE=no
3149   # If Canadian cross, then don't pick up tools from the build
3150   # directory.
3151   if test "$build" != "$with_cross_host"; then
3152     CANADIAN=yes
3153     NULL_TARGET=yes
3154   else
3155     CANADIAN=no
3156     NULL_TARGET=no
3157   fi
3158
3159   case "$target_alias" in
3160     *-wince-*)
3161         # Configure for Microsoft Windows CE, or whatever they are
3162         # currently calling it.
3163         cat >> confdefs.h <<\EOF
3164 #define HAVE_FLOAT_H 1
3165 EOF
3166
3167
3168         cat >> confdefs.h <<\EOF
3169 #define HAVE__FINITE 1
3170 EOF
3171
3172         cat >> confdefs.h <<\EOF
3173 #define HAVE__ISNAN 1
3174 EOF
3175
3176         cat >> confdefs.h <<\EOF
3177 #define HAVE__COPYSIGN 1
3178 EOF
3179
3180         cat >> confdefs.h <<\EOF
3181 #define HAVE__FPCLASS 1
3182 EOF
3183
3184         cat >> confdefs.h <<\EOF
3185 #define HAVE_MODF 1
3186 EOF
3187
3188
3189         ctype_include_dir="config/os/wince"
3190
3191
3192
3193
3194
3195         cat >> confdefs.h <<\EOF
3196 #define _GLIBCPP_NEED_MBSTATE_T 1
3197 EOF
3198
3199
3200         cat >> confdefs.h <<\EOF
3201 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3202 EOF
3203
3204         cat >> confdefs.h <<\EOF
3205 #define _GLIBCPP_BUGGY_COMPLEX 1
3206 EOF
3207
3208         ;;
3209     *)
3210         # We assume newlib.  This lets us hard-code the functions we know
3211         # we'll have.
3212         cat >> confdefs.h <<\EOF
3213 #define HAVE_FINITE 1
3214 EOF
3215
3216         cat >> confdefs.h <<\EOF
3217 #define HAVE_ISNAN 1
3218 EOF
3219
3220         cat >> confdefs.h <<\EOF
3221 #define HAVE_ISNANF 1
3222 EOF
3223
3224         cat >> confdefs.h <<\EOF
3225 #define HAVE_ISINF 1
3226 EOF
3227
3228         cat >> confdefs.h <<\EOF
3229 #define HAVE_ISINFF 1
3230 EOF
3231
3232
3233         ctype_include_dir="config/os/newlib"
3234
3235
3236
3237
3238         cat >> confdefs.h <<\EOF
3239 #define _GLIBCPP_NEED_MBSTATE_T 1
3240 EOF
3241
3242
3243         cat >> confdefs.h <<\EOF
3244 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3245 EOF
3246
3247         cat >> confdefs.h <<\EOF
3248 #define _GLIBCPP_BUGGY_COMPLEX 1
3249 EOF
3250
3251         # need to check for faster f versions of math functions, ie sinf?
3252         ;;
3253   esac
3254 else
3255
3256   # We are being configured natively. We can do more elaborate tests
3257   # that include AC_TRY_COMPILE now, as the linker is assumed to be
3258   # working.
3259
3260   xcompiling=0
3261   NATIVE=yes
3262   CANADIAN=no
3263   NULL_TARGET=no
3264
3265   # Check for available headers.
3266   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
3267   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
3268 do
3269 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3270 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3271 echo "configure:3272: checking for $ac_hdr" >&5
3272 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3273   echo $ac_n "(cached) $ac_c" 1>&6
3274 else
3275   cat > conftest.$ac_ext <<EOF
3276 #line 3277 "configure"
3277 #include "confdefs.h"
3278 #include <$ac_hdr>
3279 EOF
3280 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3281 { (eval echo configure:3282: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3282 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3283 if test -z "$ac_err"; then
3284   rm -rf conftest*
3285   eval "ac_cv_header_$ac_safe=yes"
3286 else
3287   echo "$ac_err" >&5
3288   echo "configure: failed program was:" >&5
3289   cat conftest.$ac_ext >&5
3290   rm -rf conftest*
3291   eval "ac_cv_header_$ac_safe=no"
3292 fi
3293 rm -f conftest*
3294 fi
3295 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3296   echo "$ac_t""yes" 1>&6
3297     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3298   cat >> confdefs.h <<EOF
3299 #define $ac_tr_hdr 1
3300 EOF
3301
3302 else
3303   echo "$ac_t""no" 1>&6
3304 fi
3305 done
3306
3307
3308
3309   # All these tests are for C++; save the language and the compiler flags.
3310   # The CXXFLAGS thing is suspicious, but based on similar bits
3311   # found in GLIBCPP_CONFIGURE.
3312
3313   ac_ext=C
3314 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3315 ac_cpp='$CXXCPP $CPPFLAGS'
3316 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3317 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3318 cross_compiling=$ac_cv_prog_cxx_cross
3319
3320   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3321   ac_save_CXXFLAGS="$CXXFLAGS"
3322
3323   # Check for maintainer-mode bits.
3324   if test x"$USE_MAINTAINER_MODE" = xno; then
3325     WERROR=''
3326   else
3327     WERROR='-Werror'
3328   fi
3329
3330   # Check for more sophisticated diagnostic control.
3331   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
3332 echo "configure:3333: checking for g++ that supports -fdiagnostics-show-location=once" >&5
3333   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
3334   cat > conftest.$ac_ext <<EOF
3335 #line 3336 "configure"
3336 #include "confdefs.h"
3337
3338 int main() {
3339 int foo;
3340
3341 ; return 0; }
3342 EOF
3343 if { (eval echo configure:3344: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3344   rm -rf conftest*
3345   ac_gabydiags=yes
3346 else
3347   echo "configure: failed program was:" >&5
3348   cat conftest.$ac_ext >&5
3349   rm -rf conftest*
3350   ac_gabydiags=no
3351 fi
3352 rm -f conftest*
3353   if test "$ac_test_CXXFLAGS" = set; then
3354     CXXFLAGS="$ac_save_CXXFLAGS"
3355   else
3356     # this is the suspicious part
3357     CXXFLAGS=''
3358   fi
3359   if test "$ac_gabydiags" = "yes"; then
3360     WFMT_FLAGS='-fdiagnostics-show-location=once'
3361   fi
3362   echo "$ac_t""$ac_gabydiags" 1>&6
3363
3364   # Check for -ffunction-sections -fdata-sections
3365   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
3366 echo "configure:3367: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
3367   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
3368   cat > conftest.$ac_ext <<EOF
3369 #line 3370 "configure"
3370 #include "confdefs.h"
3371
3372 int main() {
3373 int foo;
3374
3375 ; return 0; }
3376 EOF
3377 if { (eval echo configure:3378: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3378   rm -rf conftest*
3379   ac_fdsections=yes
3380 else
3381   echo "configure: failed program was:" >&5
3382   cat conftest.$ac_ext >&5
3383   rm -rf conftest*
3384   ac_fdsections=no
3385 fi
3386 rm -f conftest*
3387   if test "$ac_test_CXXFLAGS" = set; then
3388     CXXFLAGS="$ac_save_CXXFLAGS"
3389   else
3390     # this is the suspicious part
3391     CXXFLAGS=''
3392   fi
3393   if test "$ac_fdsections" = "yes"; then
3394     SECTION_FLAGS='-ffunction-sections -fdata-sections'
3395   fi
3396   echo "$ac_t""$ac_fdsections" 1>&6
3397
3398   ac_ext=c
3399 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3400 ac_cpp='$CPP $CPPFLAGS'
3401 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3402 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3403 cross_compiling=$ac_cv_prog_cc_cross
3404
3405
3406
3407
3408
3409
3410   # If we're not using GNU ld, then there's no point in even trying these
3411   # tests.  Check for that first.  We should have already tested for gld
3412   # by now (in libtool), but require it now just to be safe...
3413   SECTION_LDFLAGS=''
3414   OPT_LDFLAGS=''
3415
3416
3417   # Set --gc-sections.
3418   if test "$ac_cv_prog_gnu_ld" = "broken"; then
3419     # GNU ld it is!  Joy and bunny rabbits!
3420
3421     # All these tests are for C++; save the language and the compiler flags.
3422     # Need to do this so that g++ won't try to link in libstdc++
3423     ac_test_CFLAGS="${CFLAGS+set}"
3424     ac_save_CFLAGS="$CFLAGS"
3425     CFLAGS='-x c++  -Wl,--gc-sections'
3426
3427     # Check for -Wl,--gc-sections
3428     # XXX This test is broken at the moment, as symbols required for
3429     # linking are now in libsupc++ (not built yet.....). In addition,
3430     # this test has cored on solaris in the past. In addition,
3431     # --gc-sections doesn't really work at the moment (keeps on discarding
3432     # used sections, first .eh_frame and now some of the glibc sections for
3433     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3434     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3435 echo "configure:3436: checking for ld that supports -Wl,--gc-sections" >&5
3436     if test "$cross_compiling" = yes; then
3437   ac_sectionLDflags=yes
3438 else
3439   cat > conftest.$ac_ext <<EOF
3440 #line 3441 "configure"
3441 #include "confdefs.h"
3442
3443      int main(void)
3444      {
3445        try { throw 1; }
3446        catch (...) { };
3447        return 0;
3448      }
3449
3450 EOF
3451 if { (eval echo configure:3452: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3452 then
3453   ac_sectionLDflags=yes
3454 else
3455   echo "configure: failed program was:" >&5
3456   cat conftest.$ac_ext >&5
3457   rm -fr conftest*
3458   ac_sectionLFflags=no
3459 fi
3460 rm -fr conftest*
3461 fi
3462
3463     if test "$ac_test_CFLAGS" = set; then
3464       CFLAGS="$ac_save_CFLAGS"
3465     else
3466       # this is the suspicious part
3467       CFLAGS=''
3468     fi
3469     if test "$ac_sectionLDflags" = "yes"; then
3470       SECTION_LDFLAGS='-Wl,--gc-sections'
3471     fi
3472     echo "$ac_t""$ac_sectionLDflags" 1>&6
3473   fi
3474
3475   # Set linker optimization flags.
3476   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3477     OPT_LDFLAGS='-Wl,-O1'
3478   fi
3479
3480
3481
3482
3483
3484
3485   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3486 echo "configure:3487: checking for __builtin_abs declaration" >&5
3487   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
3488   echo $ac_n "(cached) $ac_c" 1>&6
3489 else
3490
3491
3492     ac_ext=C
3493 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3494 ac_cpp='$CXXCPP $CPPFLAGS'
3495 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3496 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3497 cross_compiling=$ac_cv_prog_cxx_cross
3498
3499     cat > conftest.$ac_ext <<EOF
3500 #line 3501 "configure"
3501 #include "confdefs.h"
3502 #include <math.h>
3503 int main() {
3504  __builtin_abs(0);
3505 ; return 0; }
3506 EOF
3507 if { (eval echo configure:3508: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3508   rm -rf conftest*
3509   glibcpp_cv_func___builtin_abs_use=yes
3510 else
3511   echo "configure: failed program was:" >&5
3512   cat conftest.$ac_ext >&5
3513   rm -rf conftest*
3514   glibcpp_cv_func___builtin_abs_use=no
3515 fi
3516 rm -f conftest*
3517     ac_ext=c
3518 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3519 ac_cpp='$CPP $CPPFLAGS'
3520 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3521 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3522 cross_compiling=$ac_cv_prog_cc_cross
3523
3524
3525 fi
3526
3527   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
3528   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
3529     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3530 echo "configure:3531: checking for __builtin_abs linkage" >&5
3531     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
3532   echo $ac_n "(cached) $ac_c" 1>&6
3533 else
3534
3535       cat > conftest.$ac_ext <<EOF
3536 #line 3537 "configure"
3537 #include "confdefs.h"
3538 #include <math.h>
3539 int main() {
3540  __builtin_abs(0);
3541 ; return 0; }
3542 EOF
3543 if { (eval echo configure:3544: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3544   rm -rf conftest*
3545   glibcpp_cv_func___builtin_abs_link=yes
3546 else
3547   echo "configure: failed program was:" >&5
3548   cat conftest.$ac_ext >&5
3549   rm -rf conftest*
3550   glibcpp_cv_func___builtin_abs_link=no
3551 fi
3552 rm -f conftest*
3553
3554 fi
3555
3556     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
3557     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
3558       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3559       cat >> confdefs.h <<EOF
3560 #define ${ac_tr_func} 1
3561 EOF
3562
3563     fi
3564   fi
3565
3566
3567   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3568 echo "configure:3569: checking for __builtin_fabsf declaration" >&5
3569   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
3570   echo $ac_n "(cached) $ac_c" 1>&6
3571 else
3572
3573
3574     ac_ext=C
3575 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3576 ac_cpp='$CXXCPP $CPPFLAGS'
3577 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3578 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3579 cross_compiling=$ac_cv_prog_cxx_cross
3580
3581     cat > conftest.$ac_ext <<EOF
3582 #line 3583 "configure"
3583 #include "confdefs.h"
3584 #include <math.h>
3585 int main() {
3586  __builtin_fabsf(0);
3587 ; return 0; }
3588 EOF
3589 if { (eval echo configure:3590: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3590   rm -rf conftest*
3591   glibcpp_cv_func___builtin_fabsf_use=yes
3592 else
3593   echo "configure: failed program was:" >&5
3594   cat conftest.$ac_ext >&5
3595   rm -rf conftest*
3596   glibcpp_cv_func___builtin_fabsf_use=no
3597 fi
3598 rm -f conftest*
3599     ac_ext=c
3600 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3601 ac_cpp='$CPP $CPPFLAGS'
3602 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3603 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3604 cross_compiling=$ac_cv_prog_cc_cross
3605
3606
3607 fi
3608
3609   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
3610   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
3611     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3612 echo "configure:3613: checking for __builtin_fabsf linkage" >&5
3613     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
3614   echo $ac_n "(cached) $ac_c" 1>&6
3615 else
3616
3617       cat > conftest.$ac_ext <<EOF
3618 #line 3619 "configure"
3619 #include "confdefs.h"
3620 #include <math.h>
3621 int main() {
3622  __builtin_fabsf(0);
3623 ; return 0; }
3624 EOF
3625 if { (eval echo configure:3626: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3626   rm -rf conftest*
3627   glibcpp_cv_func___builtin_fabsf_link=yes
3628 else
3629   echo "configure: failed program was:" >&5
3630   cat conftest.$ac_ext >&5
3631   rm -rf conftest*
3632   glibcpp_cv_func___builtin_fabsf_link=no
3633 fi
3634 rm -f conftest*
3635
3636 fi
3637
3638     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
3639     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
3640       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3641       cat >> confdefs.h <<EOF
3642 #define ${ac_tr_func} 1
3643 EOF
3644
3645     fi
3646   fi
3647
3648
3649   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3650 echo "configure:3651: checking for __builtin_fabs declaration" >&5
3651   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
3652   echo $ac_n "(cached) $ac_c" 1>&6
3653 else
3654
3655
3656     ac_ext=C
3657 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3658 ac_cpp='$CXXCPP $CPPFLAGS'
3659 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3660 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3661 cross_compiling=$ac_cv_prog_cxx_cross
3662
3663     cat > conftest.$ac_ext <<EOF
3664 #line 3665 "configure"
3665 #include "confdefs.h"
3666 #include <math.h>
3667 int main() {
3668  __builtin_fabs(0);
3669 ; return 0; }
3670 EOF
3671 if { (eval echo configure:3672: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3672   rm -rf conftest*
3673   glibcpp_cv_func___builtin_fabs_use=yes
3674 else
3675   echo "configure: failed program was:" >&5
3676   cat conftest.$ac_ext >&5
3677   rm -rf conftest*
3678   glibcpp_cv_func___builtin_fabs_use=no
3679 fi
3680 rm -f conftest*
3681     ac_ext=c
3682 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3683 ac_cpp='$CPP $CPPFLAGS'
3684 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3685 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3686 cross_compiling=$ac_cv_prog_cc_cross
3687
3688
3689 fi
3690
3691   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
3692   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
3693     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3694 echo "configure:3695: checking for __builtin_fabs linkage" >&5
3695     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
3696   echo $ac_n "(cached) $ac_c" 1>&6
3697 else
3698
3699       cat > conftest.$ac_ext <<EOF
3700 #line 3701 "configure"
3701 #include "confdefs.h"
3702 #include <math.h>
3703 int main() {
3704  __builtin_fabs(0);
3705 ; return 0; }
3706 EOF
3707 if { (eval echo configure:3708: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3708   rm -rf conftest*
3709   glibcpp_cv_func___builtin_fabs_link=yes
3710 else
3711   echo "configure: failed program was:" >&5
3712   cat conftest.$ac_ext >&5
3713   rm -rf conftest*
3714   glibcpp_cv_func___builtin_fabs_link=no
3715 fi
3716 rm -f conftest*
3717
3718 fi
3719
3720     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
3721     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
3722       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3723       cat >> confdefs.h <<EOF
3724 #define ${ac_tr_func} 1
3725 EOF
3726
3727     fi
3728   fi
3729
3730
3731   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3732 echo "configure:3733: checking for __builtin_fabsl declaration" >&5
3733   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
3734   echo $ac_n "(cached) $ac_c" 1>&6
3735 else
3736
3737
3738     ac_ext=C
3739 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3740 ac_cpp='$CXXCPP $CPPFLAGS'
3741 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3742 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3743 cross_compiling=$ac_cv_prog_cxx_cross
3744
3745     cat > conftest.$ac_ext <<EOF
3746 #line 3747 "configure"
3747 #include "confdefs.h"
3748 #include <math.h>
3749 int main() {
3750  __builtin_fabsl(0);
3751 ; return 0; }
3752 EOF
3753 if { (eval echo configure:3754: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3754   rm -rf conftest*
3755   glibcpp_cv_func___builtin_fabsl_use=yes
3756 else
3757   echo "configure: failed program was:" >&5
3758   cat conftest.$ac_ext >&5
3759   rm -rf conftest*
3760   glibcpp_cv_func___builtin_fabsl_use=no
3761 fi
3762 rm -f conftest*
3763     ac_ext=c
3764 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3765 ac_cpp='$CPP $CPPFLAGS'
3766 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3767 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3768 cross_compiling=$ac_cv_prog_cc_cross
3769
3770
3771 fi
3772
3773   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
3774   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
3775     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3776 echo "configure:3777: checking for __builtin_fabsl linkage" >&5
3777     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
3778   echo $ac_n "(cached) $ac_c" 1>&6
3779 else
3780
3781       cat > conftest.$ac_ext <<EOF
3782 #line 3783 "configure"
3783 #include "confdefs.h"
3784 #include <math.h>
3785 int main() {
3786  __builtin_fabsl(0);
3787 ; return 0; }
3788 EOF
3789 if { (eval echo configure:3790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3790   rm -rf conftest*
3791   glibcpp_cv_func___builtin_fabsl_link=yes
3792 else
3793   echo "configure: failed program was:" >&5
3794   cat conftest.$ac_ext >&5
3795   rm -rf conftest*
3796   glibcpp_cv_func___builtin_fabsl_link=no
3797 fi
3798 rm -f conftest*
3799
3800 fi
3801
3802     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
3803     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
3804       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3805       cat >> confdefs.h <<EOF
3806 #define ${ac_tr_func} 1
3807 EOF
3808
3809     fi
3810   fi
3811
3812
3813   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3814 echo "configure:3815: checking for __builtin_labs declaration" >&5
3815   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
3816   echo $ac_n "(cached) $ac_c" 1>&6
3817 else
3818
3819
3820     ac_ext=C
3821 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3822 ac_cpp='$CXXCPP $CPPFLAGS'
3823 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3824 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3825 cross_compiling=$ac_cv_prog_cxx_cross
3826
3827     cat > conftest.$ac_ext <<EOF
3828 #line 3829 "configure"
3829 #include "confdefs.h"
3830 #include <math.h>
3831 int main() {
3832  __builtin_labs(0);
3833 ; return 0; }
3834 EOF
3835 if { (eval echo configure:3836: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3836   rm -rf conftest*
3837   glibcpp_cv_func___builtin_labs_use=yes
3838 else
3839   echo "configure: failed program was:" >&5
3840   cat conftest.$ac_ext >&5
3841   rm -rf conftest*
3842   glibcpp_cv_func___builtin_labs_use=no
3843 fi
3844 rm -f conftest*
3845     ac_ext=c
3846 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3847 ac_cpp='$CPP $CPPFLAGS'
3848 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3849 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3850 cross_compiling=$ac_cv_prog_cc_cross
3851
3852
3853 fi
3854
3855   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
3856   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
3857     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3858 echo "configure:3859: checking for __builtin_labs linkage" >&5
3859     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
3860   echo $ac_n "(cached) $ac_c" 1>&6
3861 else
3862
3863       cat > conftest.$ac_ext <<EOF
3864 #line 3865 "configure"
3865 #include "confdefs.h"
3866 #include <math.h>
3867 int main() {
3868  __builtin_labs(0);
3869 ; return 0; }
3870 EOF
3871 if { (eval echo configure:3872: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3872   rm -rf conftest*
3873   glibcpp_cv_func___builtin_labs_link=yes
3874 else
3875   echo "configure: failed program was:" >&5
3876   cat conftest.$ac_ext >&5
3877   rm -rf conftest*
3878   glibcpp_cv_func___builtin_labs_link=no
3879 fi
3880 rm -f conftest*
3881
3882 fi
3883
3884     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
3885     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
3886       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3887       cat >> confdefs.h <<EOF
3888 #define ${ac_tr_func} 1
3889 EOF
3890
3891     fi
3892   fi
3893
3894
3895
3896   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3897 echo "configure:3898: checking for __builtin_sqrtf declaration" >&5
3898   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
3899   echo $ac_n "(cached) $ac_c" 1>&6
3900 else
3901
3902
3903     ac_ext=C
3904 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3905 ac_cpp='$CXXCPP $CPPFLAGS'
3906 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3907 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3908 cross_compiling=$ac_cv_prog_cxx_cross
3909
3910     cat > conftest.$ac_ext <<EOF
3911 #line 3912 "configure"
3912 #include "confdefs.h"
3913 #include <math.h>
3914 int main() {
3915  __builtin_sqrtf(0);
3916 ; return 0; }
3917 EOF
3918 if { (eval echo configure:3919: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3919   rm -rf conftest*
3920   glibcpp_cv_func___builtin_sqrtf_use=yes
3921 else
3922   echo "configure: failed program was:" >&5
3923   cat conftest.$ac_ext >&5
3924   rm -rf conftest*
3925   glibcpp_cv_func___builtin_sqrtf_use=no
3926 fi
3927 rm -f conftest*
3928     ac_ext=c
3929 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3930 ac_cpp='$CPP $CPPFLAGS'
3931 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3932 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3933 cross_compiling=$ac_cv_prog_cc_cross
3934
3935
3936 fi
3937
3938   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
3939   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
3940     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3941 echo "configure:3942: checking for __builtin_sqrtf linkage" >&5
3942     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
3943   echo $ac_n "(cached) $ac_c" 1>&6
3944 else
3945
3946       cat > conftest.$ac_ext <<EOF
3947 #line 3948 "configure"
3948 #include "confdefs.h"
3949 #include <math.h>
3950 int main() {
3951  __builtin_sqrtf(0);
3952 ; return 0; }
3953 EOF
3954 if { (eval echo configure:3955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3955   rm -rf conftest*
3956   glibcpp_cv_func___builtin_sqrtf_link=yes
3957 else
3958   echo "configure: failed program was:" >&5
3959   cat conftest.$ac_ext >&5
3960   rm -rf conftest*
3961   glibcpp_cv_func___builtin_sqrtf_link=no
3962 fi
3963 rm -f conftest*
3964
3965 fi
3966
3967     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
3968     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
3969       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3970       cat >> confdefs.h <<EOF
3971 #define ${ac_tr_func} 1
3972 EOF
3973
3974     fi
3975   fi
3976
3977
3978   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
3979 echo "configure:3980: checking for __builtin_fsqrt declaration" >&5
3980   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
3981   echo $ac_n "(cached) $ac_c" 1>&6
3982 else
3983
3984
3985     ac_ext=C
3986 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3987 ac_cpp='$CXXCPP $CPPFLAGS'
3988 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3989 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3990 cross_compiling=$ac_cv_prog_cxx_cross
3991
3992     cat > conftest.$ac_ext <<EOF
3993 #line 3994 "configure"
3994 #include "confdefs.h"
3995 #include <math.h>
3996 int main() {
3997  __builtin_fsqrt(0);
3998 ; return 0; }
3999 EOF
4000 if { (eval echo configure:4001: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4001   rm -rf conftest*
4002   glibcpp_cv_func___builtin_fsqrt_use=yes
4003 else
4004   echo "configure: failed program was:" >&5
4005   cat conftest.$ac_ext >&5
4006   rm -rf conftest*
4007   glibcpp_cv_func___builtin_fsqrt_use=no
4008 fi
4009 rm -f conftest*
4010     ac_ext=c
4011 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4012 ac_cpp='$CPP $CPPFLAGS'
4013 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4014 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4015 cross_compiling=$ac_cv_prog_cc_cross
4016
4017
4018 fi
4019
4020   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
4021   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
4022     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
4023 echo "configure:4024: checking for __builtin_fsqrt linkage" >&5
4024     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
4025   echo $ac_n "(cached) $ac_c" 1>&6
4026 else
4027
4028       cat > conftest.$ac_ext <<EOF
4029 #line 4030 "configure"
4030 #include "confdefs.h"
4031 #include <math.h>
4032 int main() {
4033  __builtin_fsqrt(0);
4034 ; return 0; }
4035 EOF
4036 if { (eval echo configure:4037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4037   rm -rf conftest*
4038   glibcpp_cv_func___builtin_fsqrt_link=yes
4039 else
4040   echo "configure: failed program was:" >&5
4041   cat conftest.$ac_ext >&5
4042   rm -rf conftest*
4043   glibcpp_cv_func___builtin_fsqrt_link=no
4044 fi
4045 rm -f conftest*
4046
4047 fi
4048
4049     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
4050     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
4051       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4052       cat >> confdefs.h <<EOF
4053 #define ${ac_tr_func} 1
4054 EOF
4055
4056     fi
4057   fi
4058
4059
4060   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
4061 echo "configure:4062: checking for __builtin_sqrtl declaration" >&5
4062   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
4063   echo $ac_n "(cached) $ac_c" 1>&6
4064 else
4065
4066
4067     ac_ext=C
4068 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4069 ac_cpp='$CXXCPP $CPPFLAGS'
4070 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4071 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4072 cross_compiling=$ac_cv_prog_cxx_cross
4073
4074     cat > conftest.$ac_ext <<EOF
4075 #line 4076 "configure"
4076 #include "confdefs.h"
4077 #include <math.h>
4078 int main() {
4079  __builtin_sqrtl(0);
4080 ; return 0; }
4081 EOF
4082 if { (eval echo configure:4083: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4083   rm -rf conftest*
4084   glibcpp_cv_func___builtin_sqrtl_use=yes
4085 else
4086   echo "configure: failed program was:" >&5
4087   cat conftest.$ac_ext >&5
4088   rm -rf conftest*
4089   glibcpp_cv_func___builtin_sqrtl_use=no
4090 fi
4091 rm -f conftest*
4092     ac_ext=c
4093 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4094 ac_cpp='$CPP $CPPFLAGS'
4095 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4096 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4097 cross_compiling=$ac_cv_prog_cc_cross
4098
4099
4100 fi
4101
4102   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
4103   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
4104     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
4105 echo "configure:4106: checking for __builtin_sqrtl linkage" >&5
4106     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
4107   echo $ac_n "(cached) $ac_c" 1>&6
4108 else
4109
4110       cat > conftest.$ac_ext <<EOF
4111 #line 4112 "configure"
4112 #include "confdefs.h"
4113 #include <math.h>
4114 int main() {
4115  __builtin_sqrtl(0);
4116 ; return 0; }
4117 EOF
4118 if { (eval echo configure:4119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4119   rm -rf conftest*
4120   glibcpp_cv_func___builtin_sqrtl_link=yes
4121 else
4122   echo "configure: failed program was:" >&5
4123   cat conftest.$ac_ext >&5
4124   rm -rf conftest*
4125   glibcpp_cv_func___builtin_sqrtl_link=no
4126 fi
4127 rm -f conftest*
4128
4129 fi
4130
4131     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
4132     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
4133       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4134       cat >> confdefs.h <<EOF
4135 #define ${ac_tr_func} 1
4136 EOF
4137
4138     fi
4139   fi
4140
4141
4142
4143   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
4144 echo "configure:4145: checking for __builtin_sinf declaration" >&5
4145   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
4146   echo $ac_n "(cached) $ac_c" 1>&6
4147 else
4148
4149
4150     ac_ext=C
4151 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4152 ac_cpp='$CXXCPP $CPPFLAGS'
4153 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4154 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4155 cross_compiling=$ac_cv_prog_cxx_cross
4156
4157     cat > conftest.$ac_ext <<EOF
4158 #line 4159 "configure"
4159 #include "confdefs.h"
4160 #include <math.h>
4161 int main() {
4162  __builtin_sinf(0);
4163 ; return 0; }
4164 EOF
4165 if { (eval echo configure:4166: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4166   rm -rf conftest*
4167   glibcpp_cv_func___builtin_sinf_use=yes
4168 else
4169   echo "configure: failed program was:" >&5
4170   cat conftest.$ac_ext >&5
4171   rm -rf conftest*
4172   glibcpp_cv_func___builtin_sinf_use=no
4173 fi
4174 rm -f conftest*
4175     ac_ext=c
4176 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4177 ac_cpp='$CPP $CPPFLAGS'
4178 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4179 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4180 cross_compiling=$ac_cv_prog_cc_cross
4181
4182
4183 fi
4184
4185   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
4186   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
4187     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
4188 echo "configure:4189: checking for __builtin_sinf linkage" >&5
4189     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
4190   echo $ac_n "(cached) $ac_c" 1>&6
4191 else
4192
4193       cat > conftest.$ac_ext <<EOF
4194 #line 4195 "configure"
4195 #include "confdefs.h"
4196 #include <math.h>
4197 int main() {
4198  __builtin_sinf(0);
4199 ; return 0; }
4200 EOF
4201 if { (eval echo configure:4202: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4202   rm -rf conftest*
4203   glibcpp_cv_func___builtin_sinf_link=yes
4204 else
4205   echo "configure: failed program was:" >&5
4206   cat conftest.$ac_ext >&5
4207   rm -rf conftest*
4208   glibcpp_cv_func___builtin_sinf_link=no
4209 fi
4210 rm -f conftest*
4211
4212 fi
4213
4214     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
4215     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
4216       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4217       cat >> confdefs.h <<EOF
4218 #define ${ac_tr_func} 1
4219 EOF
4220
4221     fi
4222   fi
4223
4224
4225   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
4226 echo "configure:4227: checking for __builtin_sin declaration" >&5
4227   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
4228   echo $ac_n "(cached) $ac_c" 1>&6
4229 else
4230
4231
4232     ac_ext=C
4233 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4234 ac_cpp='$CXXCPP $CPPFLAGS'
4235 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4236 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4237 cross_compiling=$ac_cv_prog_cxx_cross
4238
4239     cat > conftest.$ac_ext <<EOF
4240 #line 4241 "configure"
4241 #include "confdefs.h"
4242 #include <math.h>
4243 int main() {
4244  __builtin_sin(0);
4245 ; return 0; }
4246 EOF
4247 if { (eval echo configure:4248: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4248   rm -rf conftest*
4249   glibcpp_cv_func___builtin_sin_use=yes
4250 else
4251   echo "configure: failed program was:" >&5
4252   cat conftest.$ac_ext >&5
4253   rm -rf conftest*
4254   glibcpp_cv_func___builtin_sin_use=no
4255 fi
4256 rm -f conftest*
4257     ac_ext=c
4258 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4259 ac_cpp='$CPP $CPPFLAGS'
4260 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4261 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4262 cross_compiling=$ac_cv_prog_cc_cross
4263
4264
4265 fi
4266
4267   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
4268   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
4269     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
4270 echo "configure:4271: checking for __builtin_sin linkage" >&5
4271     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
4272   echo $ac_n "(cached) $ac_c" 1>&6
4273 else
4274
4275       cat > conftest.$ac_ext <<EOF
4276 #line 4277 "configure"
4277 #include "confdefs.h"
4278 #include <math.h>
4279 int main() {
4280  __builtin_sin(0);
4281 ; return 0; }
4282 EOF
4283 if { (eval echo configure:4284: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4284   rm -rf conftest*
4285   glibcpp_cv_func___builtin_sin_link=yes
4286 else
4287   echo "configure: failed program was:" >&5
4288   cat conftest.$ac_ext >&5
4289   rm -rf conftest*
4290   glibcpp_cv_func___builtin_sin_link=no
4291 fi
4292 rm -f conftest*
4293
4294 fi
4295
4296     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
4297     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
4298       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4299       cat >> confdefs.h <<EOF
4300 #define ${ac_tr_func} 1
4301 EOF
4302
4303     fi
4304   fi
4305
4306
4307   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
4308 echo "configure:4309: checking for __builtin_sinl declaration" >&5
4309   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
4310   echo $ac_n "(cached) $ac_c" 1>&6
4311 else
4312
4313
4314     ac_ext=C
4315 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4316 ac_cpp='$CXXCPP $CPPFLAGS'
4317 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4318 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4319 cross_compiling=$ac_cv_prog_cxx_cross
4320
4321     cat > conftest.$ac_ext <<EOF
4322 #line 4323 "configure"
4323 #include "confdefs.h"
4324 #include <math.h>
4325 int main() {
4326  __builtin_sinl(0);
4327 ; return 0; }
4328 EOF
4329 if { (eval echo configure:4330: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4330   rm -rf conftest*
4331   glibcpp_cv_func___builtin_sinl_use=yes
4332 else
4333   echo "configure: failed program was:" >&5
4334   cat conftest.$ac_ext >&5
4335   rm -rf conftest*
4336   glibcpp_cv_func___builtin_sinl_use=no
4337 fi
4338 rm -f conftest*
4339     ac_ext=c
4340 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4341 ac_cpp='$CPP $CPPFLAGS'
4342 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4343 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4344 cross_compiling=$ac_cv_prog_cc_cross
4345
4346
4347 fi
4348
4349   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
4350   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
4351     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
4352 echo "configure:4353: checking for __builtin_sinl linkage" >&5
4353     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
4354   echo $ac_n "(cached) $ac_c" 1>&6
4355 else
4356
4357       cat > conftest.$ac_ext <<EOF
4358 #line 4359 "configure"
4359 #include "confdefs.h"
4360 #include <math.h>
4361 int main() {
4362  __builtin_sinl(0);
4363 ; return 0; }
4364 EOF
4365 if { (eval echo configure:4366: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4366   rm -rf conftest*
4367   glibcpp_cv_func___builtin_sinl_link=yes
4368 else
4369   echo "configure: failed program was:" >&5
4370   cat conftest.$ac_ext >&5
4371   rm -rf conftest*
4372   glibcpp_cv_func___builtin_sinl_link=no
4373 fi
4374 rm -f conftest*
4375
4376 fi
4377
4378     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
4379     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
4380       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4381       cat >> confdefs.h <<EOF
4382 #define ${ac_tr_func} 1
4383 EOF
4384
4385     fi
4386   fi
4387
4388
4389
4390   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
4391 echo "configure:4392: checking for __builtin_cosf declaration" >&5
4392   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
4393   echo $ac_n "(cached) $ac_c" 1>&6
4394 else
4395
4396
4397     ac_ext=C
4398 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4399 ac_cpp='$CXXCPP $CPPFLAGS'
4400 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4401 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4402 cross_compiling=$ac_cv_prog_cxx_cross
4403
4404     cat > conftest.$ac_ext <<EOF
4405 #line 4406 "configure"
4406 #include "confdefs.h"
4407 #include <math.h>
4408 int main() {
4409  __builtin_cosf(0);
4410 ; return 0; }
4411 EOF
4412 if { (eval echo configure:4413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4413   rm -rf conftest*
4414   glibcpp_cv_func___builtin_cosf_use=yes
4415 else
4416   echo "configure: failed program was:" >&5
4417   cat conftest.$ac_ext >&5
4418   rm -rf conftest*
4419   glibcpp_cv_func___builtin_cosf_use=no
4420 fi
4421 rm -f conftest*
4422     ac_ext=c
4423 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4424 ac_cpp='$CPP $CPPFLAGS'
4425 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4426 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4427 cross_compiling=$ac_cv_prog_cc_cross
4428
4429
4430 fi
4431
4432   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
4433   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
4434     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
4435 echo "configure:4436: checking for __builtin_cosf linkage" >&5
4436     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
4437   echo $ac_n "(cached) $ac_c" 1>&6
4438 else
4439
4440       cat > conftest.$ac_ext <<EOF
4441 #line 4442 "configure"
4442 #include "confdefs.h"
4443 #include <math.h>
4444 int main() {
4445  __builtin_cosf(0);
4446 ; return 0; }
4447 EOF
4448 if { (eval echo configure:4449: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4449   rm -rf conftest*
4450   glibcpp_cv_func___builtin_cosf_link=yes
4451 else
4452   echo "configure: failed program was:" >&5
4453   cat conftest.$ac_ext >&5
4454   rm -rf conftest*
4455   glibcpp_cv_func___builtin_cosf_link=no
4456 fi
4457 rm -f conftest*
4458
4459 fi
4460
4461     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
4462     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
4463       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4464       cat >> confdefs.h <<EOF
4465 #define ${ac_tr_func} 1
4466 EOF
4467
4468     fi
4469   fi
4470
4471
4472   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
4473 echo "configure:4474: checking for __builtin_cos declaration" >&5
4474   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
4475   echo $ac_n "(cached) $ac_c" 1>&6
4476 else
4477
4478
4479     ac_ext=C
4480 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4481 ac_cpp='$CXXCPP $CPPFLAGS'
4482 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4483 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4484 cross_compiling=$ac_cv_prog_cxx_cross
4485
4486     cat > conftest.$ac_ext <<EOF
4487 #line 4488 "configure"
4488 #include "confdefs.h"
4489 #include <math.h>
4490 int main() {
4491  __builtin_cos(0);
4492 ; return 0; }
4493 EOF
4494 if { (eval echo configure:4495: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4495   rm -rf conftest*
4496   glibcpp_cv_func___builtin_cos_use=yes
4497 else
4498   echo "configure: failed program was:" >&5
4499   cat conftest.$ac_ext >&5
4500   rm -rf conftest*
4501   glibcpp_cv_func___builtin_cos_use=no
4502 fi
4503 rm -f conftest*
4504     ac_ext=c
4505 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4506 ac_cpp='$CPP $CPPFLAGS'
4507 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4508 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4509 cross_compiling=$ac_cv_prog_cc_cross
4510
4511
4512 fi
4513
4514   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
4515   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
4516     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
4517 echo "configure:4518: checking for __builtin_cos linkage" >&5
4518     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
4519   echo $ac_n "(cached) $ac_c" 1>&6
4520 else
4521
4522       cat > conftest.$ac_ext <<EOF
4523 #line 4524 "configure"
4524 #include "confdefs.h"
4525 #include <math.h>
4526 int main() {
4527  __builtin_cos(0);
4528 ; return 0; }
4529 EOF
4530 if { (eval echo configure:4531: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4531   rm -rf conftest*
4532   glibcpp_cv_func___builtin_cos_link=yes
4533 else
4534   echo "configure: failed program was:" >&5
4535   cat conftest.$ac_ext >&5
4536   rm -rf conftest*
4537   glibcpp_cv_func___builtin_cos_link=no
4538 fi
4539 rm -f conftest*
4540
4541 fi
4542
4543     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
4544     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
4545       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4546       cat >> confdefs.h <<EOF
4547 #define ${ac_tr_func} 1
4548 EOF
4549
4550     fi
4551   fi
4552
4553
4554   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
4555 echo "configure:4556: checking for __builtin_cosl declaration" >&5
4556   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
4557   echo $ac_n "(cached) $ac_c" 1>&6
4558 else
4559
4560
4561     ac_ext=C
4562 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4563 ac_cpp='$CXXCPP $CPPFLAGS'
4564 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4565 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4566 cross_compiling=$ac_cv_prog_cxx_cross
4567
4568     cat > conftest.$ac_ext <<EOF
4569 #line 4570 "configure"
4570 #include "confdefs.h"
4571 #include <math.h>
4572 int main() {
4573  __builtin_cosl(0);
4574 ; return 0; }
4575 EOF
4576 if { (eval echo configure:4577: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4577   rm -rf conftest*
4578   glibcpp_cv_func___builtin_cosl_use=yes
4579 else
4580   echo "configure: failed program was:" >&5
4581   cat conftest.$ac_ext >&5
4582   rm -rf conftest*
4583   glibcpp_cv_func___builtin_cosl_use=no
4584 fi
4585 rm -f conftest*
4586     ac_ext=c
4587 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4588 ac_cpp='$CPP $CPPFLAGS'
4589 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4590 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4591 cross_compiling=$ac_cv_prog_cc_cross
4592
4593
4594 fi
4595
4596   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
4597   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
4598     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
4599 echo "configure:4600: checking for __builtin_cosl linkage" >&5
4600     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
4601   echo $ac_n "(cached) $ac_c" 1>&6
4602 else
4603
4604       cat > conftest.$ac_ext <<EOF
4605 #line 4606 "configure"
4606 #include "confdefs.h"
4607 #include <math.h>
4608 int main() {
4609  __builtin_cosl(0);
4610 ; return 0; }
4611 EOF
4612 if { (eval echo configure:4613: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4613   rm -rf conftest*
4614   glibcpp_cv_func___builtin_cosl_link=yes
4615 else
4616   echo "configure: failed program was:" >&5
4617   cat conftest.$ac_ext >&5
4618   rm -rf conftest*
4619   glibcpp_cv_func___builtin_cosl_link=no
4620 fi
4621 rm -f conftest*
4622
4623 fi
4624
4625     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
4626     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
4627       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4628       cat >> confdefs.h <<EOF
4629 #define ${ac_tr_func} 1
4630 EOF
4631
4632     fi
4633   fi
4634
4635
4636               dummyvar=no
4637   if test x$dummyvar = x"yes"; then
4638     cat >> confdefs.h <<\EOF
4639 #define HAVE___BUILTIN_ABS 1
4640 EOF
4641
4642     cat >> confdefs.h <<\EOF
4643 #define HAVE___BUILTIN_LABS 1
4644 EOF
4645
4646     cat >> confdefs.h <<\EOF
4647 #define HAVE___BUILTIN_COS 1
4648 EOF
4649
4650     cat >> confdefs.h <<\EOF
4651 #define HAVE___BUILTIN_COSF 1
4652 EOF
4653
4654     cat >> confdefs.h <<\EOF
4655 #define HAVE___BUILTIN_COSL 1
4656 EOF
4657
4658     cat >> confdefs.h <<\EOF
4659 #define HAVE___BUILTIN_FABS 1
4660 EOF
4661
4662     cat >> confdefs.h <<\EOF
4663 #define HAVE___BUILTIN_FABSF 1
4664 EOF
4665
4666     cat >> confdefs.h <<\EOF
4667 #define HAVE___BUILTIN_FABSL 1
4668 EOF
4669
4670     cat >> confdefs.h <<\EOF
4671 #define HAVE___BUILTIN_SIN 1
4672 EOF
4673
4674     cat >> confdefs.h <<\EOF
4675 #define HAVE___BUILTIN_SINF 1
4676 EOF
4677
4678     cat >> confdefs.h <<\EOF
4679 #define HAVE___BUILTIN_SINL 1
4680 EOF
4681
4682     cat >> confdefs.h <<\EOF
4683 #define HAVE___BUILTIN_FSQRT 1
4684 EOF
4685
4686     cat >> confdefs.h <<\EOF
4687 #define HAVE___BUILTIN_SQRTF 1
4688 EOF
4689
4690     cat >> confdefs.h <<\EOF
4691 #define HAVE___BUILTIN_SQRTL 1
4692 EOF
4693
4694   fi
4695
4696
4697   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4698   ac_save_CXXFLAGS="$CXXFLAGS"
4699   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4700
4701     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4702 echo "configure:4703: checking for sin in -lm" >&5
4703 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4704 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4705   echo $ac_n "(cached) $ac_c" 1>&6
4706 else
4707   ac_save_LIBS="$LIBS"
4708 LIBS="-lm  $LIBS"
4709 cat > conftest.$ac_ext <<EOF
4710 #line 4711 "configure"
4711 #include "confdefs.h"
4712 /* Override any gcc2 internal prototype to avoid an error.  */
4713 /* We use char because int might match the return type of a gcc2
4714     builtin and then its argument prototype would still apply.  */
4715 char sin();
4716
4717 int main() {
4718 sin()
4719 ; return 0; }
4720 EOF
4721 if { (eval echo configure:4722: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4722   rm -rf conftest*
4723   eval "ac_cv_lib_$ac_lib_var=yes"
4724 else
4725   echo "configure: failed program was:" >&5
4726   cat conftest.$ac_ext >&5
4727   rm -rf conftest*
4728   eval "ac_cv_lib_$ac_lib_var=no"
4729 fi
4730 rm -f conftest*
4731 LIBS="$ac_save_LIBS"
4732
4733 fi
4734 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4735   echo "$ac_t""yes" 1>&6
4736   libm="-lm"
4737 else
4738   echo "$ac_t""no" 1>&6
4739 fi
4740
4741   ac_save_LIBS="$LIBS"
4742   LIBS="$LIBS $libm"
4743
4744
4745   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4746 echo "configure:4747: checking for isinf declaration" >&5
4747   if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
4748   echo $ac_n "(cached) $ac_c" 1>&6
4749 else
4750
4751
4752     ac_ext=C
4753 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4754 ac_cpp='$CXXCPP $CPPFLAGS'
4755 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4756 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4757 cross_compiling=$ac_cv_prog_cxx_cross
4758
4759     cat > conftest.$ac_ext <<EOF
4760 #line 4761 "configure"
4761 #include "confdefs.h"
4762 #include <math.h>
4763 int main() {
4764  isinf(0);
4765 ; return 0; }
4766 EOF
4767 if { (eval echo configure:4768: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4768   rm -rf conftest*
4769   glibcpp_cv_func_isinf_use=yes
4770 else
4771   echo "configure: failed program was:" >&5
4772   cat conftest.$ac_ext >&5
4773   rm -rf conftest*
4774   glibcpp_cv_func_isinf_use=no
4775 fi
4776 rm -f conftest*
4777     ac_ext=c
4778 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4779 ac_cpp='$CPP $CPPFLAGS'
4780 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4781 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4782 cross_compiling=$ac_cv_prog_cc_cross
4783
4784
4785 fi
4786
4787   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
4788   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
4789     for ac_func in isinf
4790 do
4791 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4792 echo "configure:4793: checking for $ac_func" >&5
4793 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4794   echo $ac_n "(cached) $ac_c" 1>&6
4795 else
4796   cat > conftest.$ac_ext <<EOF
4797 #line 4798 "configure"
4798 #include "confdefs.h"
4799 /* System header to define __stub macros and hopefully few prototypes,
4800     which can conflict with char $ac_func(); below.  */
4801 #include <assert.h>
4802 /* Override any gcc2 internal prototype to avoid an error.  */
4803 /* We use char because int might match the return type of a gcc2
4804     builtin and then its argument prototype would still apply.  */
4805 char $ac_func();
4806
4807 int main() {
4808
4809 /* The GNU C library defines this for functions which it implements
4810     to always fail with ENOSYS.  Some functions are actually named
4811     something starting with __ and the normal name is an alias.  */
4812 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4813 choke me
4814 #else
4815 $ac_func();
4816 #endif
4817
4818 ; return 0; }
4819 EOF
4820 if { (eval echo configure:4821: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4821   rm -rf conftest*
4822   eval "ac_cv_func_$ac_func=yes"
4823 else
4824   echo "configure: failed program was:" >&5
4825   cat conftest.$ac_ext >&5
4826   rm -rf conftest*
4827   eval "ac_cv_func_$ac_func=no"
4828 fi
4829 rm -f conftest*
4830 fi
4831
4832 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4833   echo "$ac_t""yes" 1>&6
4834     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4835   cat >> confdefs.h <<EOF
4836 #define $ac_tr_func 1
4837 EOF
4838
4839 else
4840   echo "$ac_t""no" 1>&6
4841 fi
4842 done
4843
4844   fi
4845
4846
4847   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4848 echo "configure:4849: checking for isnan declaration" >&5
4849   if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
4850   echo $ac_n "(cached) $ac_c" 1>&6
4851 else
4852
4853
4854     ac_ext=C
4855 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4856 ac_cpp='$CXXCPP $CPPFLAGS'
4857 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4858 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4859 cross_compiling=$ac_cv_prog_cxx_cross
4860
4861     cat > conftest.$ac_ext <<EOF
4862 #line 4863 "configure"
4863 #include "confdefs.h"
4864 #include <math.h>
4865 int main() {
4866  isnan(0);
4867 ; return 0; }
4868 EOF
4869 if { (eval echo configure:4870: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4870   rm -rf conftest*
4871   glibcpp_cv_func_isnan_use=yes
4872 else
4873   echo "configure: failed program was:" >&5
4874   cat conftest.$ac_ext >&5
4875   rm -rf conftest*
4876   glibcpp_cv_func_isnan_use=no
4877 fi
4878 rm -f conftest*
4879     ac_ext=c
4880 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4881 ac_cpp='$CPP $CPPFLAGS'
4882 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4883 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4884 cross_compiling=$ac_cv_prog_cc_cross
4885
4886
4887 fi
4888
4889   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
4890   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
4891     for ac_func in isnan
4892 do
4893 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4894 echo "configure:4895: checking for $ac_func" >&5
4895 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4896   echo $ac_n "(cached) $ac_c" 1>&6
4897 else
4898   cat > conftest.$ac_ext <<EOF
4899 #line 4900 "configure"
4900 #include "confdefs.h"
4901 /* System header to define __stub macros and hopefully few prototypes,
4902     which can conflict with char $ac_func(); below.  */
4903 #include <assert.h>
4904 /* Override any gcc2 internal prototype to avoid an error.  */
4905 /* We use char because int might match the return type of a gcc2
4906     builtin and then its argument prototype would still apply.  */
4907 char $ac_func();
4908
4909 int main() {
4910
4911 /* The GNU C library defines this for functions which it implements
4912     to always fail with ENOSYS.  Some functions are actually named
4913     something starting with __ and the normal name is an alias.  */
4914 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4915 choke me
4916 #else
4917 $ac_func();
4918 #endif
4919
4920 ; return 0; }
4921 EOF
4922 if { (eval echo configure:4923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4923   rm -rf conftest*
4924   eval "ac_cv_func_$ac_func=yes"
4925 else
4926   echo "configure: failed program was:" >&5
4927   cat conftest.$ac_ext >&5
4928   rm -rf conftest*
4929   eval "ac_cv_func_$ac_func=no"
4930 fi
4931 rm -f conftest*
4932 fi
4933
4934 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4935   echo "$ac_t""yes" 1>&6
4936     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4937   cat >> confdefs.h <<EOF
4938 #define $ac_tr_func 1
4939 EOF
4940
4941 else
4942   echo "$ac_t""no" 1>&6
4943 fi
4944 done
4945
4946   fi
4947
4948
4949   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
4950 echo "configure:4951: checking for finite declaration" >&5
4951   if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
4952   echo $ac_n "(cached) $ac_c" 1>&6
4953 else
4954
4955
4956     ac_ext=C
4957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4958 ac_cpp='$CXXCPP $CPPFLAGS'
4959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4961 cross_compiling=$ac_cv_prog_cxx_cross
4962
4963     cat > conftest.$ac_ext <<EOF
4964 #line 4965 "configure"
4965 #include "confdefs.h"
4966 #include <math.h>
4967 int main() {
4968  finite(0);
4969 ; return 0; }
4970 EOF
4971 if { (eval echo configure:4972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4972   rm -rf conftest*
4973   glibcpp_cv_func_finite_use=yes
4974 else
4975   echo "configure: failed program was:" >&5
4976   cat conftest.$ac_ext >&5
4977   rm -rf conftest*
4978   glibcpp_cv_func_finite_use=no
4979 fi
4980 rm -f conftest*
4981     ac_ext=c
4982 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4983 ac_cpp='$CPP $CPPFLAGS'
4984 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4985 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4986 cross_compiling=$ac_cv_prog_cc_cross
4987
4988
4989 fi
4990
4991   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
4992   if test x$glibcpp_cv_func_finite_use = x"yes"; then
4993     for ac_func in finite
4994 do
4995 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4996 echo "configure:4997: checking for $ac_func" >&5
4997 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4998   echo $ac_n "(cached) $ac_c" 1>&6
4999 else
5000   cat > conftest.$ac_ext <<EOF
5001 #line 5002 "configure"
5002 #include "confdefs.h"
5003 /* System header to define __stub macros and hopefully few prototypes,
5004     which can conflict with char $ac_func(); below.  */
5005 #include <assert.h>
5006 /* Override any gcc2 internal prototype to avoid an error.  */
5007 /* We use char because int might match the return type of a gcc2
5008     builtin and then its argument prototype would still apply.  */
5009 char $ac_func();
5010
5011 int main() {
5012
5013 /* The GNU C library defines this for functions which it implements
5014     to always fail with ENOSYS.  Some functions are actually named
5015     something starting with __ and the normal name is an alias.  */
5016 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5017 choke me
5018 #else
5019 $ac_func();
5020 #endif
5021
5022 ; return 0; }
5023 EOF
5024 if { (eval echo configure:5025: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5025   rm -rf conftest*
5026   eval "ac_cv_func_$ac_func=yes"
5027 else
5028   echo "configure: failed program was:" >&5
5029   cat conftest.$ac_ext >&5
5030   rm -rf conftest*
5031   eval "ac_cv_func_$ac_func=no"
5032 fi
5033 rm -f conftest*
5034 fi
5035
5036 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5037   echo "$ac_t""yes" 1>&6
5038     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5039   cat >> confdefs.h <<EOF
5040 #define $ac_tr_func 1
5041 EOF
5042
5043 else
5044   echo "$ac_t""no" 1>&6
5045 fi
5046 done
5047
5048   fi
5049
5050
5051   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
5052 echo "configure:5053: checking for copysign declaration" >&5
5053   if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
5054   echo $ac_n "(cached) $ac_c" 1>&6
5055 else
5056
5057
5058     ac_ext=C
5059 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5060 ac_cpp='$CXXCPP $CPPFLAGS'
5061 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5062 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5063 cross_compiling=$ac_cv_prog_cxx_cross
5064
5065     cat > conftest.$ac_ext <<EOF
5066 #line 5067 "configure"
5067 #include "confdefs.h"
5068 #include <math.h>
5069 int main() {
5070  copysign(0, 0);
5071 ; return 0; }
5072 EOF
5073 if { (eval echo configure:5074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5074   rm -rf conftest*
5075   glibcpp_cv_func_copysign_use=yes
5076 else
5077   echo "configure: failed program was:" >&5
5078   cat conftest.$ac_ext >&5
5079   rm -rf conftest*
5080   glibcpp_cv_func_copysign_use=no
5081 fi
5082 rm -f conftest*
5083     ac_ext=c
5084 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5085 ac_cpp='$CPP $CPPFLAGS'
5086 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5087 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5088 cross_compiling=$ac_cv_prog_cc_cross
5089
5090
5091 fi
5092
5093   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
5094   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
5095     for ac_func in copysign
5096 do
5097 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5098 echo "configure:5099: checking for $ac_func" >&5
5099 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5100   echo $ac_n "(cached) $ac_c" 1>&6
5101 else
5102   cat > conftest.$ac_ext <<EOF
5103 #line 5104 "configure"
5104 #include "confdefs.h"
5105 /* System header to define __stub macros and hopefully few prototypes,
5106     which can conflict with char $ac_func(); below.  */
5107 #include <assert.h>
5108 /* Override any gcc2 internal prototype to avoid an error.  */
5109 /* We use char because int might match the return type of a gcc2
5110     builtin and then its argument prototype would still apply.  */
5111 char $ac_func();
5112
5113 int main() {
5114
5115 /* The GNU C library defines this for functions which it implements
5116     to always fail with ENOSYS.  Some functions are actually named
5117     something starting with __ and the normal name is an alias.  */
5118 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5119 choke me
5120 #else
5121 $ac_func();
5122 #endif
5123
5124 ; return 0; }
5125 EOF
5126 if { (eval echo configure:5127: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5127   rm -rf conftest*
5128   eval "ac_cv_func_$ac_func=yes"
5129 else
5130   echo "configure: failed program was:" >&5
5131   cat conftest.$ac_ext >&5
5132   rm -rf conftest*
5133   eval "ac_cv_func_$ac_func=no"
5134 fi
5135 rm -f conftest*
5136 fi
5137
5138 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5139   echo "$ac_t""yes" 1>&6
5140     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5141   cat >> confdefs.h <<EOF
5142 #define $ac_tr_func 1
5143 EOF
5144
5145 else
5146   echo "$ac_t""no" 1>&6
5147 fi
5148 done
5149
5150   fi
5151
5152
5153   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
5154 echo "configure:5155: checking for sincos declaration" >&5
5155   if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
5156   echo $ac_n "(cached) $ac_c" 1>&6
5157 else
5158
5159
5160     ac_ext=C
5161 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5162 ac_cpp='$CXXCPP $CPPFLAGS'
5163 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5164 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5165 cross_compiling=$ac_cv_prog_cxx_cross
5166
5167     cat > conftest.$ac_ext <<EOF
5168 #line 5169 "configure"
5169 #include "confdefs.h"
5170 #include <math.h>
5171 int main() {
5172  sincos(0, 0, 0);
5173 ; return 0; }
5174 EOF
5175 if { (eval echo configure:5176: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5176   rm -rf conftest*
5177   glibcpp_cv_func_sincos_use=yes
5178 else
5179   echo "configure: failed program was:" >&5
5180   cat conftest.$ac_ext >&5
5181   rm -rf conftest*
5182   glibcpp_cv_func_sincos_use=no
5183 fi
5184 rm -f conftest*
5185     ac_ext=c
5186 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5187 ac_cpp='$CPP $CPPFLAGS'
5188 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5189 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5190 cross_compiling=$ac_cv_prog_cc_cross
5191
5192
5193 fi
5194
5195   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
5196   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
5197     for ac_func in sincos
5198 do
5199 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5200 echo "configure:5201: checking for $ac_func" >&5
5201 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5202   echo $ac_n "(cached) $ac_c" 1>&6
5203 else
5204   cat > conftest.$ac_ext <<EOF
5205 #line 5206 "configure"
5206 #include "confdefs.h"
5207 /* System header to define __stub macros and hopefully few prototypes,
5208     which can conflict with char $ac_func(); below.  */
5209 #include <assert.h>
5210 /* Override any gcc2 internal prototype to avoid an error.  */
5211 /* We use char because int might match the return type of a gcc2
5212     builtin and then its argument prototype would still apply.  */
5213 char $ac_func();
5214
5215 int main() {
5216
5217 /* The GNU C library defines this for functions which it implements
5218     to always fail with ENOSYS.  Some functions are actually named
5219     something starting with __ and the normal name is an alias.  */
5220 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5221 choke me
5222 #else
5223 $ac_func();
5224 #endif
5225
5226 ; return 0; }
5227 EOF
5228 if { (eval echo configure:5229: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5229   rm -rf conftest*
5230   eval "ac_cv_func_$ac_func=yes"
5231 else
5232   echo "configure: failed program was:" >&5
5233   cat conftest.$ac_ext >&5
5234   rm -rf conftest*
5235   eval "ac_cv_func_$ac_func=no"
5236 fi
5237 rm -f conftest*
5238 fi
5239
5240 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5241   echo "$ac_t""yes" 1>&6
5242     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5243   cat >> confdefs.h <<EOF
5244 #define $ac_tr_func 1
5245 EOF
5246
5247 else
5248   echo "$ac_t""no" 1>&6
5249 fi
5250 done
5251
5252   fi
5253
5254
5255   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
5256 echo "configure:5257: checking for fpclass declaration" >&5
5257   if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
5258   echo $ac_n "(cached) $ac_c" 1>&6
5259 else
5260
5261
5262     ac_ext=C
5263 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5264 ac_cpp='$CXXCPP $CPPFLAGS'
5265 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5266 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5267 cross_compiling=$ac_cv_prog_cxx_cross
5268
5269     cat > conftest.$ac_ext <<EOF
5270 #line 5271 "configure"
5271 #include "confdefs.h"
5272 #include <math.h>
5273 int main() {
5274  fpclass(0);
5275 ; return 0; }
5276 EOF
5277 if { (eval echo configure:5278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5278   rm -rf conftest*
5279   glibcpp_cv_func_fpclass_use=yes
5280 else
5281   echo "configure: failed program was:" >&5
5282   cat conftest.$ac_ext >&5
5283   rm -rf conftest*
5284   glibcpp_cv_func_fpclass_use=no
5285 fi
5286 rm -f conftest*
5287     ac_ext=c
5288 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5289 ac_cpp='$CPP $CPPFLAGS'
5290 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5291 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5292 cross_compiling=$ac_cv_prog_cc_cross
5293
5294
5295 fi
5296
5297   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
5298   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
5299     for ac_func in fpclass
5300 do
5301 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5302 echo "configure:5303: checking for $ac_func" >&5
5303 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5304   echo $ac_n "(cached) $ac_c" 1>&6
5305 else
5306   cat > conftest.$ac_ext <<EOF
5307 #line 5308 "configure"
5308 #include "confdefs.h"
5309 /* System header to define __stub macros and hopefully few prototypes,
5310     which can conflict with char $ac_func(); below.  */
5311 #include <assert.h>
5312 /* Override any gcc2 internal prototype to avoid an error.  */
5313 /* We use char because int might match the return type of a gcc2
5314     builtin and then its argument prototype would still apply.  */
5315 char $ac_func();
5316
5317 int main() {
5318
5319 /* The GNU C library defines this for functions which it implements
5320     to always fail with ENOSYS.  Some functions are actually named
5321     something starting with __ and the normal name is an alias.  */
5322 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5323 choke me
5324 #else
5325 $ac_func();
5326 #endif
5327
5328 ; return 0; }
5329 EOF
5330 if { (eval echo configure:5331: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5331   rm -rf conftest*
5332   eval "ac_cv_func_$ac_func=yes"
5333 else
5334   echo "configure: failed program was:" >&5
5335   cat conftest.$ac_ext >&5
5336   rm -rf conftest*
5337   eval "ac_cv_func_$ac_func=no"
5338 fi
5339 rm -f conftest*
5340 fi
5341
5342 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5343   echo "$ac_t""yes" 1>&6
5344     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5345   cat >> confdefs.h <<EOF
5346 #define $ac_tr_func 1
5347 EOF
5348
5349 else
5350   echo "$ac_t""no" 1>&6
5351 fi
5352 done
5353
5354   fi
5355
5356
5357   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
5358 echo "configure:5359: checking for qfpclass declaration" >&5
5359   if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
5360   echo $ac_n "(cached) $ac_c" 1>&6
5361 else
5362
5363
5364     ac_ext=C
5365 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5366 ac_cpp='$CXXCPP $CPPFLAGS'
5367 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5368 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5369 cross_compiling=$ac_cv_prog_cxx_cross
5370
5371     cat > conftest.$ac_ext <<EOF
5372 #line 5373 "configure"
5373 #include "confdefs.h"
5374 #include <math.h>
5375 int main() {
5376  qfpclass(0);
5377 ; return 0; }
5378 EOF
5379 if { (eval echo configure:5380: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5380   rm -rf conftest*
5381   glibcpp_cv_func_qfpclass_use=yes
5382 else
5383   echo "configure: failed program was:" >&5
5384   cat conftest.$ac_ext >&5
5385   rm -rf conftest*
5386   glibcpp_cv_func_qfpclass_use=no
5387 fi
5388 rm -f conftest*
5389     ac_ext=c
5390 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5391 ac_cpp='$CPP $CPPFLAGS'
5392 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5393 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5394 cross_compiling=$ac_cv_prog_cc_cross
5395
5396
5397 fi
5398
5399   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
5400   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
5401     for ac_func in qfpclass
5402 do
5403 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5404 echo "configure:5405: checking for $ac_func" >&5
5405 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5406   echo $ac_n "(cached) $ac_c" 1>&6
5407 else
5408   cat > conftest.$ac_ext <<EOF
5409 #line 5410 "configure"
5410 #include "confdefs.h"
5411 /* System header to define __stub macros and hopefully few prototypes,
5412     which can conflict with char $ac_func(); below.  */
5413 #include <assert.h>
5414 /* Override any gcc2 internal prototype to avoid an error.  */
5415 /* We use char because int might match the return type of a gcc2
5416     builtin and then its argument prototype would still apply.  */
5417 char $ac_func();
5418
5419 int main() {
5420
5421 /* The GNU C library defines this for functions which it implements
5422     to always fail with ENOSYS.  Some functions are actually named
5423     something starting with __ and the normal name is an alias.  */
5424 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5425 choke me
5426 #else
5427 $ac_func();
5428 #endif
5429
5430 ; return 0; }
5431 EOF
5432 if { (eval echo configure:5433: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5433   rm -rf conftest*
5434   eval "ac_cv_func_$ac_func=yes"
5435 else
5436   echo "configure: failed program was:" >&5
5437   cat conftest.$ac_ext >&5
5438   rm -rf conftest*
5439   eval "ac_cv_func_$ac_func=no"
5440 fi
5441 rm -f conftest*
5442 fi
5443
5444 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5445   echo "$ac_t""yes" 1>&6
5446     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5447   cat >> confdefs.h <<EOF
5448 #define $ac_tr_func 1
5449 EOF
5450
5451 else
5452   echo "$ac_t""no" 1>&6
5453 fi
5454 done
5455
5456   fi
5457
5458
5459
5460   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5461 echo "configure:5462: checking for isnanf declaration" >&5
5462   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
5463   echo $ac_n "(cached) $ac_c" 1>&6
5464 else
5465
5466
5467     ac_ext=C
5468 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5469 ac_cpp='$CXXCPP $CPPFLAGS'
5470 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5471 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5472 cross_compiling=$ac_cv_prog_cxx_cross
5473
5474     cat > conftest.$ac_ext <<EOF
5475 #line 5476 "configure"
5476 #include "confdefs.h"
5477 #include <math.h>
5478 int main() {
5479  isnanf(0);
5480 ; return 0; }
5481 EOF
5482 if { (eval echo configure:5483: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5483   rm -rf conftest*
5484   glibcpp_cv_func_isnanf_use=yes
5485 else
5486   echo "configure: failed program was:" >&5
5487   cat conftest.$ac_ext >&5
5488   rm -rf conftest*
5489   glibcpp_cv_func_isnanf_use=no
5490 fi
5491 rm -f conftest*
5492     ac_ext=c
5493 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5494 ac_cpp='$CPP $CPPFLAGS'
5495 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5496 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5497 cross_compiling=$ac_cv_prog_cc_cross
5498
5499
5500 fi
5501
5502   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
5503   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
5504     for ac_func in isnanf
5505 do
5506 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5507 echo "configure:5508: checking for $ac_func" >&5
5508 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5509   echo $ac_n "(cached) $ac_c" 1>&6
5510 else
5511   cat > conftest.$ac_ext <<EOF
5512 #line 5513 "configure"
5513 #include "confdefs.h"
5514 /* System header to define __stub macros and hopefully few prototypes,
5515     which can conflict with char $ac_func(); below.  */
5516 #include <assert.h>
5517 /* Override any gcc2 internal prototype to avoid an error.  */
5518 /* We use char because int might match the return type of a gcc2
5519     builtin and then its argument prototype would still apply.  */
5520 char $ac_func();
5521
5522 int main() {
5523
5524 /* The GNU C library defines this for functions which it implements
5525     to always fail with ENOSYS.  Some functions are actually named
5526     something starting with __ and the normal name is an alias.  */
5527 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5528 choke me
5529 #else
5530 $ac_func();
5531 #endif
5532
5533 ; return 0; }
5534 EOF
5535 if { (eval echo configure:5536: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5536   rm -rf conftest*
5537   eval "ac_cv_func_$ac_func=yes"
5538 else
5539   echo "configure: failed program was:" >&5
5540   cat conftest.$ac_ext >&5
5541   rm -rf conftest*
5542   eval "ac_cv_func_$ac_func=no"
5543 fi
5544 rm -f conftest*
5545 fi
5546
5547 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5548   echo "$ac_t""yes" 1>&6
5549     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5550   cat >> confdefs.h <<EOF
5551 #define $ac_tr_func 1
5552 EOF
5553
5554 else
5555   echo "$ac_t""no" 1>&6
5556 fi
5557 done
5558
5559   fi
5560
5561
5562   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5563 echo "configure:5564: checking for isinff declaration" >&5
5564   if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
5565   echo $ac_n "(cached) $ac_c" 1>&6
5566 else
5567
5568
5569     ac_ext=C
5570 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5571 ac_cpp='$CXXCPP $CPPFLAGS'
5572 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5573 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5574 cross_compiling=$ac_cv_prog_cxx_cross
5575
5576     cat > conftest.$ac_ext <<EOF
5577 #line 5578 "configure"
5578 #include "confdefs.h"
5579 #include <math.h>
5580 int main() {
5581  isinff(0);
5582 ; return 0; }
5583 EOF
5584 if { (eval echo configure:5585: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5585   rm -rf conftest*
5586   glibcpp_cv_func_isinff_use=yes
5587 else
5588   echo "configure: failed program was:" >&5
5589   cat conftest.$ac_ext >&5
5590   rm -rf conftest*
5591   glibcpp_cv_func_isinff_use=no
5592 fi
5593 rm -f conftest*
5594     ac_ext=c
5595 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5596 ac_cpp='$CPP $CPPFLAGS'
5597 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5598 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5599 cross_compiling=$ac_cv_prog_cc_cross
5600
5601
5602 fi
5603
5604   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
5605   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
5606     for ac_func in isinff
5607 do
5608 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5609 echo "configure:5610: checking for $ac_func" >&5
5610 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5611   echo $ac_n "(cached) $ac_c" 1>&6
5612 else
5613   cat > conftest.$ac_ext <<EOF
5614 #line 5615 "configure"
5615 #include "confdefs.h"
5616 /* System header to define __stub macros and hopefully few prototypes,
5617     which can conflict with char $ac_func(); below.  */
5618 #include <assert.h>
5619 /* Override any gcc2 internal prototype to avoid an error.  */
5620 /* We use char because int might match the return type of a gcc2
5621     builtin and then its argument prototype would still apply.  */
5622 char $ac_func();
5623
5624 int main() {
5625
5626 /* The GNU C library defines this for functions which it implements
5627     to always fail with ENOSYS.  Some functions are actually named
5628     something starting with __ and the normal name is an alias.  */
5629 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5630 choke me
5631 #else
5632 $ac_func();
5633 #endif
5634
5635 ; return 0; }
5636 EOF
5637 if { (eval echo configure:5638: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5638   rm -rf conftest*
5639   eval "ac_cv_func_$ac_func=yes"
5640 else
5641   echo "configure: failed program was:" >&5
5642   cat conftest.$ac_ext >&5
5643   rm -rf conftest*
5644   eval "ac_cv_func_$ac_func=no"
5645 fi
5646 rm -f conftest*
5647 fi
5648
5649 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5650   echo "$ac_t""yes" 1>&6
5651     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5652   cat >> confdefs.h <<EOF
5653 #define $ac_tr_func 1
5654 EOF
5655
5656 else
5657   echo "$ac_t""no" 1>&6
5658 fi
5659 done
5660
5661   fi
5662
5663
5664   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5665 echo "configure:5666: checking for acosf declaration" >&5
5666   if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
5667   echo $ac_n "(cached) $ac_c" 1>&6
5668 else
5669
5670
5671     ac_ext=C
5672 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5673 ac_cpp='$CXXCPP $CPPFLAGS'
5674 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5675 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5676 cross_compiling=$ac_cv_prog_cxx_cross
5677
5678     cat > conftest.$ac_ext <<EOF
5679 #line 5680 "configure"
5680 #include "confdefs.h"
5681 #include <math.h>
5682 int main() {
5683  acosf(0);
5684 ; return 0; }
5685 EOF
5686 if { (eval echo configure:5687: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5687   rm -rf conftest*
5688   glibcpp_cv_func_acosf_use=yes
5689 else
5690   echo "configure: failed program was:" >&5
5691   cat conftest.$ac_ext >&5
5692   rm -rf conftest*
5693   glibcpp_cv_func_acosf_use=no
5694 fi
5695 rm -f conftest*
5696     ac_ext=c
5697 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5698 ac_cpp='$CPP $CPPFLAGS'
5699 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5700 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5701 cross_compiling=$ac_cv_prog_cc_cross
5702
5703
5704 fi
5705
5706   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
5707   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
5708     for ac_func in acosf
5709 do
5710 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5711 echo "configure:5712: checking for $ac_func" >&5
5712 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5713   echo $ac_n "(cached) $ac_c" 1>&6
5714 else
5715   cat > conftest.$ac_ext <<EOF
5716 #line 5717 "configure"
5717 #include "confdefs.h"
5718 /* System header to define __stub macros and hopefully few prototypes,
5719     which can conflict with char $ac_func(); below.  */
5720 #include <assert.h>
5721 /* Override any gcc2 internal prototype to avoid an error.  */
5722 /* We use char because int might match the return type of a gcc2
5723     builtin and then its argument prototype would still apply.  */
5724 char $ac_func();
5725
5726 int main() {
5727
5728 /* The GNU C library defines this for functions which it implements
5729     to always fail with ENOSYS.  Some functions are actually named
5730     something starting with __ and the normal name is an alias.  */
5731 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5732 choke me
5733 #else
5734 $ac_func();
5735 #endif
5736
5737 ; return 0; }
5738 EOF
5739 if { (eval echo configure:5740: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5740   rm -rf conftest*
5741   eval "ac_cv_func_$ac_func=yes"
5742 else
5743   echo "configure: failed program was:" >&5
5744   cat conftest.$ac_ext >&5
5745   rm -rf conftest*
5746   eval "ac_cv_func_$ac_func=no"
5747 fi
5748 rm -f conftest*
5749 fi
5750
5751 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5752   echo "$ac_t""yes" 1>&6
5753     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5754   cat >> confdefs.h <<EOF
5755 #define $ac_tr_func 1
5756 EOF
5757
5758 else
5759   echo "$ac_t""no" 1>&6
5760 fi
5761 done
5762
5763   fi
5764
5765
5766   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5767 echo "configure:5768: checking for asinf declaration" >&5
5768   if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
5769   echo $ac_n "(cached) $ac_c" 1>&6
5770 else
5771
5772
5773     ac_ext=C
5774 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5775 ac_cpp='$CXXCPP $CPPFLAGS'
5776 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5777 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5778 cross_compiling=$ac_cv_prog_cxx_cross
5779
5780     cat > conftest.$ac_ext <<EOF
5781 #line 5782 "configure"
5782 #include "confdefs.h"
5783 #include <math.h>
5784 int main() {
5785  asinf(0);
5786 ; return 0; }
5787 EOF
5788 if { (eval echo configure:5789: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5789   rm -rf conftest*
5790   glibcpp_cv_func_asinf_use=yes
5791 else
5792   echo "configure: failed program was:" >&5
5793   cat conftest.$ac_ext >&5
5794   rm -rf conftest*
5795   glibcpp_cv_func_asinf_use=no
5796 fi
5797 rm -f conftest*
5798     ac_ext=c
5799 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5800 ac_cpp='$CPP $CPPFLAGS'
5801 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5802 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5803 cross_compiling=$ac_cv_prog_cc_cross
5804
5805
5806 fi
5807
5808   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
5809   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
5810     for ac_func in asinf
5811 do
5812 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5813 echo "configure:5814: checking for $ac_func" >&5
5814 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5815   echo $ac_n "(cached) $ac_c" 1>&6
5816 else
5817   cat > conftest.$ac_ext <<EOF
5818 #line 5819 "configure"
5819 #include "confdefs.h"
5820 /* System header to define __stub macros and hopefully few prototypes,
5821     which can conflict with char $ac_func(); below.  */
5822 #include <assert.h>
5823 /* Override any gcc2 internal prototype to avoid an error.  */
5824 /* We use char because int might match the return type of a gcc2
5825     builtin and then its argument prototype would still apply.  */
5826 char $ac_func();
5827
5828 int main() {
5829
5830 /* The GNU C library defines this for functions which it implements
5831     to always fail with ENOSYS.  Some functions are actually named
5832     something starting with __ and the normal name is an alias.  */
5833 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5834 choke me
5835 #else
5836 $ac_func();
5837 #endif
5838
5839 ; return 0; }
5840 EOF
5841 if { (eval echo configure:5842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5842   rm -rf conftest*
5843   eval "ac_cv_func_$ac_func=yes"
5844 else
5845   echo "configure: failed program was:" >&5
5846   cat conftest.$ac_ext >&5
5847   rm -rf conftest*
5848   eval "ac_cv_func_$ac_func=no"
5849 fi
5850 rm -f conftest*
5851 fi
5852
5853 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5854   echo "$ac_t""yes" 1>&6
5855     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5856   cat >> confdefs.h <<EOF
5857 #define $ac_tr_func 1
5858 EOF
5859
5860 else
5861   echo "$ac_t""no" 1>&6
5862 fi
5863 done
5864
5865   fi
5866
5867
5868   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5869 echo "configure:5870: checking for atanf declaration" >&5
5870   if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
5871   echo $ac_n "(cached) $ac_c" 1>&6
5872 else
5873
5874
5875     ac_ext=C
5876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5877 ac_cpp='$CXXCPP $CPPFLAGS'
5878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5880 cross_compiling=$ac_cv_prog_cxx_cross
5881
5882     cat > conftest.$ac_ext <<EOF
5883 #line 5884 "configure"
5884 #include "confdefs.h"
5885 #include <math.h>
5886 int main() {
5887  atanf(0);
5888 ; return 0; }
5889 EOF
5890 if { (eval echo configure:5891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5891   rm -rf conftest*
5892   glibcpp_cv_func_atanf_use=yes
5893 else
5894   echo "configure: failed program was:" >&5
5895   cat conftest.$ac_ext >&5
5896   rm -rf conftest*
5897   glibcpp_cv_func_atanf_use=no
5898 fi
5899 rm -f conftest*
5900     ac_ext=c
5901 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5902 ac_cpp='$CPP $CPPFLAGS'
5903 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5904 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5905 cross_compiling=$ac_cv_prog_cc_cross
5906
5907
5908 fi
5909
5910   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
5911   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
5912     for ac_func in atanf
5913 do
5914 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5915 echo "configure:5916: checking for $ac_func" >&5
5916 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5917   echo $ac_n "(cached) $ac_c" 1>&6
5918 else
5919   cat > conftest.$ac_ext <<EOF
5920 #line 5921 "configure"
5921 #include "confdefs.h"
5922 /* System header to define __stub macros and hopefully few prototypes,
5923     which can conflict with char $ac_func(); below.  */
5924 #include <assert.h>
5925 /* Override any gcc2 internal prototype to avoid an error.  */
5926 /* We use char because int might match the return type of a gcc2
5927     builtin and then its argument prototype would still apply.  */
5928 char $ac_func();
5929
5930 int main() {
5931
5932 /* The GNU C library defines this for functions which it implements
5933     to always fail with ENOSYS.  Some functions are actually named
5934     something starting with __ and the normal name is an alias.  */
5935 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5936 choke me
5937 #else
5938 $ac_func();
5939 #endif
5940
5941 ; return 0; }
5942 EOF
5943 if { (eval echo configure:5944: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5944   rm -rf conftest*
5945   eval "ac_cv_func_$ac_func=yes"
5946 else
5947   echo "configure: failed program was:" >&5
5948   cat conftest.$ac_ext >&5
5949   rm -rf conftest*
5950   eval "ac_cv_func_$ac_func=no"
5951 fi
5952 rm -f conftest*
5953 fi
5954
5955 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5956   echo "$ac_t""yes" 1>&6
5957     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5958   cat >> confdefs.h <<EOF
5959 #define $ac_tr_func 1
5960 EOF
5961
5962 else
5963   echo "$ac_t""no" 1>&6
5964 fi
5965 done
5966
5967   fi
5968
5969
5970   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
5971 echo "configure:5972: checking for atan2f declaration" >&5
5972   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
5973   echo $ac_n "(cached) $ac_c" 1>&6
5974 else
5975
5976
5977     ac_ext=C
5978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5979 ac_cpp='$CXXCPP $CPPFLAGS'
5980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5982 cross_compiling=$ac_cv_prog_cxx_cross
5983
5984     cat > conftest.$ac_ext <<EOF
5985 #line 5986 "configure"
5986 #include "confdefs.h"
5987 #include <math.h>
5988 int main() {
5989  atan2f(0, 0);
5990 ; return 0; }
5991 EOF
5992 if { (eval echo configure:5993: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5993   rm -rf conftest*
5994   glibcpp_cv_func_atan2f_use=yes
5995 else
5996   echo "configure: failed program was:" >&5
5997   cat conftest.$ac_ext >&5
5998   rm -rf conftest*
5999   glibcpp_cv_func_atan2f_use=no
6000 fi
6001 rm -f conftest*
6002     ac_ext=c
6003 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6004 ac_cpp='$CPP $CPPFLAGS'
6005 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6006 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6007 cross_compiling=$ac_cv_prog_cc_cross
6008
6009
6010 fi
6011
6012   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
6013   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
6014     for ac_func in atan2f
6015 do
6016 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6017 echo "configure:6018: checking for $ac_func" >&5
6018 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6019   echo $ac_n "(cached) $ac_c" 1>&6
6020 else
6021   cat > conftest.$ac_ext <<EOF
6022 #line 6023 "configure"
6023 #include "confdefs.h"
6024 /* System header to define __stub macros and hopefully few prototypes,
6025     which can conflict with char $ac_func(); below.  */
6026 #include <assert.h>
6027 /* Override any gcc2 internal prototype to avoid an error.  */
6028 /* We use char because int might match the return type of a gcc2
6029     builtin and then its argument prototype would still apply.  */
6030 char $ac_func();
6031
6032 int main() {
6033
6034 /* The GNU C library defines this for functions which it implements
6035     to always fail with ENOSYS.  Some functions are actually named
6036     something starting with __ and the normal name is an alias.  */
6037 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6038 choke me
6039 #else
6040 $ac_func();
6041 #endif
6042
6043 ; return 0; }
6044 EOF
6045 if { (eval echo configure:6046: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6046   rm -rf conftest*
6047   eval "ac_cv_func_$ac_func=yes"
6048 else
6049   echo "configure: failed program was:" >&5
6050   cat conftest.$ac_ext >&5
6051   rm -rf conftest*
6052   eval "ac_cv_func_$ac_func=no"
6053 fi
6054 rm -f conftest*
6055 fi
6056
6057 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6058   echo "$ac_t""yes" 1>&6
6059     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6060   cat >> confdefs.h <<EOF
6061 #define $ac_tr_func 1
6062 EOF
6063
6064 else
6065   echo "$ac_t""no" 1>&6
6066 fi
6067 done
6068
6069   fi
6070
6071
6072   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6073 echo "configure:6074: checking for ceilf declaration" >&5
6074   if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
6075   echo $ac_n "(cached) $ac_c" 1>&6
6076 else
6077
6078
6079     ac_ext=C
6080 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6081 ac_cpp='$CXXCPP $CPPFLAGS'
6082 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6083 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6084 cross_compiling=$ac_cv_prog_cxx_cross
6085
6086     cat > conftest.$ac_ext <<EOF
6087 #line 6088 "configure"
6088 #include "confdefs.h"
6089 #include <math.h>
6090 int main() {
6091  ceilf(0);
6092 ; return 0; }
6093 EOF
6094 if { (eval echo configure:6095: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6095   rm -rf conftest*
6096   glibcpp_cv_func_ceilf_use=yes
6097 else
6098   echo "configure: failed program was:" >&5
6099   cat conftest.$ac_ext >&5
6100   rm -rf conftest*
6101   glibcpp_cv_func_ceilf_use=no
6102 fi
6103 rm -f conftest*
6104     ac_ext=c
6105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6106 ac_cpp='$CPP $CPPFLAGS'
6107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6109 cross_compiling=$ac_cv_prog_cc_cross
6110
6111
6112 fi
6113
6114   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
6115   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
6116     for ac_func in ceilf
6117 do
6118 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6119 echo "configure:6120: checking for $ac_func" >&5
6120 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6121   echo $ac_n "(cached) $ac_c" 1>&6
6122 else
6123   cat > conftest.$ac_ext <<EOF
6124 #line 6125 "configure"
6125 #include "confdefs.h"
6126 /* System header to define __stub macros and hopefully few prototypes,
6127     which can conflict with char $ac_func(); below.  */
6128 #include <assert.h>
6129 /* Override any gcc2 internal prototype to avoid an error.  */
6130 /* We use char because int might match the return type of a gcc2
6131     builtin and then its argument prototype would still apply.  */
6132 char $ac_func();
6133
6134 int main() {
6135
6136 /* The GNU C library defines this for functions which it implements
6137     to always fail with ENOSYS.  Some functions are actually named
6138     something starting with __ and the normal name is an alias.  */
6139 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6140 choke me
6141 #else
6142 $ac_func();
6143 #endif
6144
6145 ; return 0; }
6146 EOF
6147 if { (eval echo configure:6148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6148   rm -rf conftest*
6149   eval "ac_cv_func_$ac_func=yes"
6150 else
6151   echo "configure: failed program was:" >&5
6152   cat conftest.$ac_ext >&5
6153   rm -rf conftest*
6154   eval "ac_cv_func_$ac_func=no"
6155 fi
6156 rm -f conftest*
6157 fi
6158
6159 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6160   echo "$ac_t""yes" 1>&6
6161     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6162   cat >> confdefs.h <<EOF
6163 #define $ac_tr_func 1
6164 EOF
6165
6166 else
6167   echo "$ac_t""no" 1>&6
6168 fi
6169 done
6170
6171   fi
6172
6173
6174   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6175 echo "configure:6176: checking for cosf declaration" >&5
6176   if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
6177   echo $ac_n "(cached) $ac_c" 1>&6
6178 else
6179
6180
6181     ac_ext=C
6182 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6183 ac_cpp='$CXXCPP $CPPFLAGS'
6184 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6185 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6186 cross_compiling=$ac_cv_prog_cxx_cross
6187
6188     cat > conftest.$ac_ext <<EOF
6189 #line 6190 "configure"
6190 #include "confdefs.h"
6191 #include <math.h>
6192 int main() {
6193  cosf(0);
6194 ; return 0; }
6195 EOF
6196 if { (eval echo configure:6197: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6197   rm -rf conftest*
6198   glibcpp_cv_func_cosf_use=yes
6199 else
6200   echo "configure: failed program was:" >&5
6201   cat conftest.$ac_ext >&5
6202   rm -rf conftest*
6203   glibcpp_cv_func_cosf_use=no
6204 fi
6205 rm -f conftest*
6206     ac_ext=c
6207 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6208 ac_cpp='$CPP $CPPFLAGS'
6209 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6210 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6211 cross_compiling=$ac_cv_prog_cc_cross
6212
6213
6214 fi
6215
6216   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
6217   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
6218     for ac_func in cosf
6219 do
6220 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6221 echo "configure:6222: checking for $ac_func" >&5
6222 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6223   echo $ac_n "(cached) $ac_c" 1>&6
6224 else
6225   cat > conftest.$ac_ext <<EOF
6226 #line 6227 "configure"
6227 #include "confdefs.h"
6228 /* System header to define __stub macros and hopefully few prototypes,
6229     which can conflict with char $ac_func(); below.  */
6230 #include <assert.h>
6231 /* Override any gcc2 internal prototype to avoid an error.  */
6232 /* We use char because int might match the return type of a gcc2
6233     builtin and then its argument prototype would still apply.  */
6234 char $ac_func();
6235
6236 int main() {
6237
6238 /* The GNU C library defines this for functions which it implements
6239     to always fail with ENOSYS.  Some functions are actually named
6240     something starting with __ and the normal name is an alias.  */
6241 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6242 choke me
6243 #else
6244 $ac_func();
6245 #endif
6246
6247 ; return 0; }
6248 EOF
6249 if { (eval echo configure:6250: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6250   rm -rf conftest*
6251   eval "ac_cv_func_$ac_func=yes"
6252 else
6253   echo "configure: failed program was:" >&5
6254   cat conftest.$ac_ext >&5
6255   rm -rf conftest*
6256   eval "ac_cv_func_$ac_func=no"
6257 fi
6258 rm -f conftest*
6259 fi
6260
6261 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6262   echo "$ac_t""yes" 1>&6
6263     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6264   cat >> confdefs.h <<EOF
6265 #define $ac_tr_func 1
6266 EOF
6267
6268 else
6269   echo "$ac_t""no" 1>&6
6270 fi
6271 done
6272
6273   fi
6274
6275
6276   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6277 echo "configure:6278: checking for coshf declaration" >&5
6278   if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
6279   echo $ac_n "(cached) $ac_c" 1>&6
6280 else
6281
6282
6283     ac_ext=C
6284 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6285 ac_cpp='$CXXCPP $CPPFLAGS'
6286 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6287 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6288 cross_compiling=$ac_cv_prog_cxx_cross
6289
6290     cat > conftest.$ac_ext <<EOF
6291 #line 6292 "configure"
6292 #include "confdefs.h"
6293 #include <math.h>
6294 int main() {
6295  coshf(0);
6296 ; return 0; }
6297 EOF
6298 if { (eval echo configure:6299: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6299   rm -rf conftest*
6300   glibcpp_cv_func_coshf_use=yes
6301 else
6302   echo "configure: failed program was:" >&5
6303   cat conftest.$ac_ext >&5
6304   rm -rf conftest*
6305   glibcpp_cv_func_coshf_use=no
6306 fi
6307 rm -f conftest*
6308     ac_ext=c
6309 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6310 ac_cpp='$CPP $CPPFLAGS'
6311 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6312 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6313 cross_compiling=$ac_cv_prog_cc_cross
6314
6315
6316 fi
6317
6318   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
6319   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
6320     for ac_func in coshf
6321 do
6322 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6323 echo "configure:6324: checking for $ac_func" >&5
6324 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6325   echo $ac_n "(cached) $ac_c" 1>&6
6326 else
6327   cat > conftest.$ac_ext <<EOF
6328 #line 6329 "configure"
6329 #include "confdefs.h"
6330 /* System header to define __stub macros and hopefully few prototypes,
6331     which can conflict with char $ac_func(); below.  */
6332 #include <assert.h>
6333 /* Override any gcc2 internal prototype to avoid an error.  */
6334 /* We use char because int might match the return type of a gcc2
6335     builtin and then its argument prototype would still apply.  */
6336 char $ac_func();
6337
6338 int main() {
6339
6340 /* The GNU C library defines this for functions which it implements
6341     to always fail with ENOSYS.  Some functions are actually named
6342     something starting with __ and the normal name is an alias.  */
6343 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6344 choke me
6345 #else
6346 $ac_func();
6347 #endif
6348
6349 ; return 0; }
6350 EOF
6351 if { (eval echo configure:6352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6352   rm -rf conftest*
6353   eval "ac_cv_func_$ac_func=yes"
6354 else
6355   echo "configure: failed program was:" >&5
6356   cat conftest.$ac_ext >&5
6357   rm -rf conftest*
6358   eval "ac_cv_func_$ac_func=no"
6359 fi
6360 rm -f conftest*
6361 fi
6362
6363 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6364   echo "$ac_t""yes" 1>&6
6365     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6366   cat >> confdefs.h <<EOF
6367 #define $ac_tr_func 1
6368 EOF
6369
6370 else
6371   echo "$ac_t""no" 1>&6
6372 fi
6373 done
6374
6375   fi
6376
6377
6378   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6379 echo "configure:6380: checking for expf declaration" >&5
6380   if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
6381   echo $ac_n "(cached) $ac_c" 1>&6
6382 else
6383
6384
6385     ac_ext=C
6386 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6387 ac_cpp='$CXXCPP $CPPFLAGS'
6388 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6389 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6390 cross_compiling=$ac_cv_prog_cxx_cross
6391
6392     cat > conftest.$ac_ext <<EOF
6393 #line 6394 "configure"
6394 #include "confdefs.h"
6395 #include <math.h>
6396 int main() {
6397  expf(0);
6398 ; return 0; }
6399 EOF
6400 if { (eval echo configure:6401: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6401   rm -rf conftest*
6402   glibcpp_cv_func_expf_use=yes
6403 else
6404   echo "configure: failed program was:" >&5
6405   cat conftest.$ac_ext >&5
6406   rm -rf conftest*
6407   glibcpp_cv_func_expf_use=no
6408 fi
6409 rm -f conftest*
6410     ac_ext=c
6411 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6412 ac_cpp='$CPP $CPPFLAGS'
6413 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6414 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6415 cross_compiling=$ac_cv_prog_cc_cross
6416
6417
6418 fi
6419
6420   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
6421   if test x$glibcpp_cv_func_expf_use = x"yes"; then
6422     for ac_func in expf
6423 do
6424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6425 echo "configure:6426: checking for $ac_func" >&5
6426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6427   echo $ac_n "(cached) $ac_c" 1>&6
6428 else
6429   cat > conftest.$ac_ext <<EOF
6430 #line 6431 "configure"
6431 #include "confdefs.h"
6432 /* System header to define __stub macros and hopefully few prototypes,
6433     which can conflict with char $ac_func(); below.  */
6434 #include <assert.h>
6435 /* Override any gcc2 internal prototype to avoid an error.  */
6436 /* We use char because int might match the return type of a gcc2
6437     builtin and then its argument prototype would still apply.  */
6438 char $ac_func();
6439
6440 int main() {
6441
6442 /* The GNU C library defines this for functions which it implements
6443     to always fail with ENOSYS.  Some functions are actually named
6444     something starting with __ and the normal name is an alias.  */
6445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6446 choke me
6447 #else
6448 $ac_func();
6449 #endif
6450
6451 ; return 0; }
6452 EOF
6453 if { (eval echo configure:6454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6454   rm -rf conftest*
6455   eval "ac_cv_func_$ac_func=yes"
6456 else
6457   echo "configure: failed program was:" >&5
6458   cat conftest.$ac_ext >&5
6459   rm -rf conftest*
6460   eval "ac_cv_func_$ac_func=no"
6461 fi
6462 rm -f conftest*
6463 fi
6464
6465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6466   echo "$ac_t""yes" 1>&6
6467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6468   cat >> confdefs.h <<EOF
6469 #define $ac_tr_func 1
6470 EOF
6471
6472 else
6473   echo "$ac_t""no" 1>&6
6474 fi
6475 done
6476
6477   fi
6478
6479
6480   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6481 echo "configure:6482: checking for fabsf declaration" >&5
6482   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
6483   echo $ac_n "(cached) $ac_c" 1>&6
6484 else
6485
6486
6487     ac_ext=C
6488 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6489 ac_cpp='$CXXCPP $CPPFLAGS'
6490 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6491 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6492 cross_compiling=$ac_cv_prog_cxx_cross
6493
6494     cat > conftest.$ac_ext <<EOF
6495 #line 6496 "configure"
6496 #include "confdefs.h"
6497 #include <math.h>
6498 int main() {
6499  fabsf(0);
6500 ; return 0; }
6501 EOF
6502 if { (eval echo configure:6503: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6503   rm -rf conftest*
6504   glibcpp_cv_func_fabsf_use=yes
6505 else
6506   echo "configure: failed program was:" >&5
6507   cat conftest.$ac_ext >&5
6508   rm -rf conftest*
6509   glibcpp_cv_func_fabsf_use=no
6510 fi
6511 rm -f conftest*
6512     ac_ext=c
6513 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6514 ac_cpp='$CPP $CPPFLAGS'
6515 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6516 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6517 cross_compiling=$ac_cv_prog_cc_cross
6518
6519
6520 fi
6521
6522   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
6523   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
6524     for ac_func in fabsf
6525 do
6526 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6527 echo "configure:6528: checking for $ac_func" >&5
6528 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6529   echo $ac_n "(cached) $ac_c" 1>&6
6530 else
6531   cat > conftest.$ac_ext <<EOF
6532 #line 6533 "configure"
6533 #include "confdefs.h"
6534 /* System header to define __stub macros and hopefully few prototypes,
6535     which can conflict with char $ac_func(); below.  */
6536 #include <assert.h>
6537 /* Override any gcc2 internal prototype to avoid an error.  */
6538 /* We use char because int might match the return type of a gcc2
6539     builtin and then its argument prototype would still apply.  */
6540 char $ac_func();
6541
6542 int main() {
6543
6544 /* The GNU C library defines this for functions which it implements
6545     to always fail with ENOSYS.  Some functions are actually named
6546     something starting with __ and the normal name is an alias.  */
6547 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6548 choke me
6549 #else
6550 $ac_func();
6551 #endif
6552
6553 ; return 0; }
6554 EOF
6555 if { (eval echo configure:6556: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6556   rm -rf conftest*
6557   eval "ac_cv_func_$ac_func=yes"
6558 else
6559   echo "configure: failed program was:" >&5
6560   cat conftest.$ac_ext >&5
6561   rm -rf conftest*
6562   eval "ac_cv_func_$ac_func=no"
6563 fi
6564 rm -f conftest*
6565 fi
6566
6567 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6568   echo "$ac_t""yes" 1>&6
6569     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6570   cat >> confdefs.h <<EOF
6571 #define $ac_tr_func 1
6572 EOF
6573
6574 else
6575   echo "$ac_t""no" 1>&6
6576 fi
6577 done
6578
6579   fi
6580
6581
6582   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6583 echo "configure:6584: checking for floorf declaration" >&5
6584   if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
6585   echo $ac_n "(cached) $ac_c" 1>&6
6586 else
6587
6588
6589     ac_ext=C
6590 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6591 ac_cpp='$CXXCPP $CPPFLAGS'
6592 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6593 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6594 cross_compiling=$ac_cv_prog_cxx_cross
6595
6596     cat > conftest.$ac_ext <<EOF
6597 #line 6598 "configure"
6598 #include "confdefs.h"
6599 #include <math.h>
6600 int main() {
6601  floorf(0);
6602 ; return 0; }
6603 EOF
6604 if { (eval echo configure:6605: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6605   rm -rf conftest*
6606   glibcpp_cv_func_floorf_use=yes
6607 else
6608   echo "configure: failed program was:" >&5
6609   cat conftest.$ac_ext >&5
6610   rm -rf conftest*
6611   glibcpp_cv_func_floorf_use=no
6612 fi
6613 rm -f conftest*
6614     ac_ext=c
6615 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6616 ac_cpp='$CPP $CPPFLAGS'
6617 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6618 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6619 cross_compiling=$ac_cv_prog_cc_cross
6620
6621
6622 fi
6623
6624   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
6625   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
6626     for ac_func in floorf
6627 do
6628 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6629 echo "configure:6630: checking for $ac_func" >&5
6630 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6631   echo $ac_n "(cached) $ac_c" 1>&6
6632 else
6633   cat > conftest.$ac_ext <<EOF
6634 #line 6635 "configure"
6635 #include "confdefs.h"
6636 /* System header to define __stub macros and hopefully few prototypes,
6637     which can conflict with char $ac_func(); below.  */
6638 #include <assert.h>
6639 /* Override any gcc2 internal prototype to avoid an error.  */
6640 /* We use char because int might match the return type of a gcc2
6641     builtin and then its argument prototype would still apply.  */
6642 char $ac_func();
6643
6644 int main() {
6645
6646 /* The GNU C library defines this for functions which it implements
6647     to always fail with ENOSYS.  Some functions are actually named
6648     something starting with __ and the normal name is an alias.  */
6649 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6650 choke me
6651 #else
6652 $ac_func();
6653 #endif
6654
6655 ; return 0; }
6656 EOF
6657 if { (eval echo configure:6658: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6658   rm -rf conftest*
6659   eval "ac_cv_func_$ac_func=yes"
6660 else
6661   echo "configure: failed program was:" >&5
6662   cat conftest.$ac_ext >&5
6663   rm -rf conftest*
6664   eval "ac_cv_func_$ac_func=no"
6665 fi
6666 rm -f conftest*
6667 fi
6668
6669 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6670   echo "$ac_t""yes" 1>&6
6671     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6672   cat >> confdefs.h <<EOF
6673 #define $ac_tr_func 1
6674 EOF
6675
6676 else
6677   echo "$ac_t""no" 1>&6
6678 fi
6679 done
6680
6681   fi
6682
6683
6684   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6685 echo "configure:6686: checking for fmodf declaration" >&5
6686   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
6687   echo $ac_n "(cached) $ac_c" 1>&6
6688 else
6689
6690
6691     ac_ext=C
6692 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6693 ac_cpp='$CXXCPP $CPPFLAGS'
6694 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6695 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6696 cross_compiling=$ac_cv_prog_cxx_cross
6697
6698     cat > conftest.$ac_ext <<EOF
6699 #line 6700 "configure"
6700 #include "confdefs.h"
6701 #include <math.h>
6702 int main() {
6703  fmodf(0, 0);
6704 ; return 0; }
6705 EOF
6706 if { (eval echo configure:6707: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6707   rm -rf conftest*
6708   glibcpp_cv_func_fmodf_use=yes
6709 else
6710   echo "configure: failed program was:" >&5
6711   cat conftest.$ac_ext >&5
6712   rm -rf conftest*
6713   glibcpp_cv_func_fmodf_use=no
6714 fi
6715 rm -f conftest*
6716     ac_ext=c
6717 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6718 ac_cpp='$CPP $CPPFLAGS'
6719 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6720 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6721 cross_compiling=$ac_cv_prog_cc_cross
6722
6723
6724 fi
6725
6726   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
6727   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
6728     for ac_func in fmodf
6729 do
6730 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6731 echo "configure:6732: checking for $ac_func" >&5
6732 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6733   echo $ac_n "(cached) $ac_c" 1>&6
6734 else
6735   cat > conftest.$ac_ext <<EOF
6736 #line 6737 "configure"
6737 #include "confdefs.h"
6738 /* System header to define __stub macros and hopefully few prototypes,
6739     which can conflict with char $ac_func(); below.  */
6740 #include <assert.h>
6741 /* Override any gcc2 internal prototype to avoid an error.  */
6742 /* We use char because int might match the return type of a gcc2
6743     builtin and then its argument prototype would still apply.  */
6744 char $ac_func();
6745
6746 int main() {
6747
6748 /* The GNU C library defines this for functions which it implements
6749     to always fail with ENOSYS.  Some functions are actually named
6750     something starting with __ and the normal name is an alias.  */
6751 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6752 choke me
6753 #else
6754 $ac_func();
6755 #endif
6756
6757 ; return 0; }
6758 EOF
6759 if { (eval echo configure:6760: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6760   rm -rf conftest*
6761   eval "ac_cv_func_$ac_func=yes"
6762 else
6763   echo "configure: failed program was:" >&5
6764   cat conftest.$ac_ext >&5
6765   rm -rf conftest*
6766   eval "ac_cv_func_$ac_func=no"
6767 fi
6768 rm -f conftest*
6769 fi
6770
6771 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6772   echo "$ac_t""yes" 1>&6
6773     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6774   cat >> confdefs.h <<EOF
6775 #define $ac_tr_func 1
6776 EOF
6777
6778 else
6779   echo "$ac_t""no" 1>&6
6780 fi
6781 done
6782
6783   fi
6784
6785
6786   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6787 echo "configure:6788: checking for frexpf declaration" >&5
6788   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
6789   echo $ac_n "(cached) $ac_c" 1>&6
6790 else
6791
6792
6793     ac_ext=C
6794 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6795 ac_cpp='$CXXCPP $CPPFLAGS'
6796 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6797 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6798 cross_compiling=$ac_cv_prog_cxx_cross
6799
6800     cat > conftest.$ac_ext <<EOF
6801 #line 6802 "configure"
6802 #include "confdefs.h"
6803 #include <math.h>
6804 int main() {
6805  frexpf(0, 0);
6806 ; return 0; }
6807 EOF
6808 if { (eval echo configure:6809: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6809   rm -rf conftest*
6810   glibcpp_cv_func_frexpf_use=yes
6811 else
6812   echo "configure: failed program was:" >&5
6813   cat conftest.$ac_ext >&5
6814   rm -rf conftest*
6815   glibcpp_cv_func_frexpf_use=no
6816 fi
6817 rm -f conftest*
6818     ac_ext=c
6819 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6820 ac_cpp='$CPP $CPPFLAGS'
6821 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6822 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6823 cross_compiling=$ac_cv_prog_cc_cross
6824
6825
6826 fi
6827
6828   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
6829   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
6830     for ac_func in frexpf
6831 do
6832 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6833 echo "configure:6834: checking for $ac_func" >&5
6834 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6835   echo $ac_n "(cached) $ac_c" 1>&6
6836 else
6837   cat > conftest.$ac_ext <<EOF
6838 #line 6839 "configure"
6839 #include "confdefs.h"
6840 /* System header to define __stub macros and hopefully few prototypes,
6841     which can conflict with char $ac_func(); below.  */
6842 #include <assert.h>
6843 /* Override any gcc2 internal prototype to avoid an error.  */
6844 /* We use char because int might match the return type of a gcc2
6845     builtin and then its argument prototype would still apply.  */
6846 char $ac_func();
6847
6848 int main() {
6849
6850 /* The GNU C library defines this for functions which it implements
6851     to always fail with ENOSYS.  Some functions are actually named
6852     something starting with __ and the normal name is an alias.  */
6853 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6854 choke me
6855 #else
6856 $ac_func();
6857 #endif
6858
6859 ; return 0; }
6860 EOF
6861 if { (eval echo configure:6862: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6862   rm -rf conftest*
6863   eval "ac_cv_func_$ac_func=yes"
6864 else
6865   echo "configure: failed program was:" >&5
6866   cat conftest.$ac_ext >&5
6867   rm -rf conftest*
6868   eval "ac_cv_func_$ac_func=no"
6869 fi
6870 rm -f conftest*
6871 fi
6872
6873 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6874   echo "$ac_t""yes" 1>&6
6875     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6876   cat >> confdefs.h <<EOF
6877 #define $ac_tr_func 1
6878 EOF
6879
6880 else
6881   echo "$ac_t""no" 1>&6
6882 fi
6883 done
6884
6885   fi
6886
6887
6888   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6889 echo "configure:6890: checking for ldexpf declaration" >&5
6890   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
6891   echo $ac_n "(cached) $ac_c" 1>&6
6892 else
6893
6894
6895     ac_ext=C
6896 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6897 ac_cpp='$CXXCPP $CPPFLAGS'
6898 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6899 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6900 cross_compiling=$ac_cv_prog_cxx_cross
6901
6902     cat > conftest.$ac_ext <<EOF
6903 #line 6904 "configure"
6904 #include "confdefs.h"
6905 #include <math.h>
6906 int main() {
6907  ldexpf(0, 0);
6908 ; return 0; }
6909 EOF
6910 if { (eval echo configure:6911: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6911   rm -rf conftest*
6912   glibcpp_cv_func_ldexpf_use=yes
6913 else
6914   echo "configure: failed program was:" >&5
6915   cat conftest.$ac_ext >&5
6916   rm -rf conftest*
6917   glibcpp_cv_func_ldexpf_use=no
6918 fi
6919 rm -f conftest*
6920     ac_ext=c
6921 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6922 ac_cpp='$CPP $CPPFLAGS'
6923 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6924 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6925 cross_compiling=$ac_cv_prog_cc_cross
6926
6927
6928 fi
6929
6930   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
6931   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
6932     for ac_func in ldexpf
6933 do
6934 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6935 echo "configure:6936: checking for $ac_func" >&5
6936 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6937   echo $ac_n "(cached) $ac_c" 1>&6
6938 else
6939   cat > conftest.$ac_ext <<EOF
6940 #line 6941 "configure"
6941 #include "confdefs.h"
6942 /* System header to define __stub macros and hopefully few prototypes,
6943     which can conflict with char $ac_func(); below.  */
6944 #include <assert.h>
6945 /* Override any gcc2 internal prototype to avoid an error.  */
6946 /* We use char because int might match the return type of a gcc2
6947     builtin and then its argument prototype would still apply.  */
6948 char $ac_func();
6949
6950 int main() {
6951
6952 /* The GNU C library defines this for functions which it implements
6953     to always fail with ENOSYS.  Some functions are actually named
6954     something starting with __ and the normal name is an alias.  */
6955 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6956 choke me
6957 #else
6958 $ac_func();
6959 #endif
6960
6961 ; return 0; }
6962 EOF
6963 if { (eval echo configure:6964: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6964   rm -rf conftest*
6965   eval "ac_cv_func_$ac_func=yes"
6966 else
6967   echo "configure: failed program was:" >&5
6968   cat conftest.$ac_ext >&5
6969   rm -rf conftest*
6970   eval "ac_cv_func_$ac_func=no"
6971 fi
6972 rm -f conftest*
6973 fi
6974
6975 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6976   echo "$ac_t""yes" 1>&6
6977     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6978   cat >> confdefs.h <<EOF
6979 #define $ac_tr_func 1
6980 EOF
6981
6982 else
6983   echo "$ac_t""no" 1>&6
6984 fi
6985 done
6986
6987   fi
6988
6989
6990   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6991 echo "configure:6992: checking for logf declaration" >&5
6992   if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
6993   echo $ac_n "(cached) $ac_c" 1>&6
6994 else
6995
6996
6997     ac_ext=C
6998 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6999 ac_cpp='$CXXCPP $CPPFLAGS'
7000 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7001 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7002 cross_compiling=$ac_cv_prog_cxx_cross
7003
7004     cat > conftest.$ac_ext <<EOF
7005 #line 7006 "configure"
7006 #include "confdefs.h"
7007 #include <math.h>
7008 int main() {
7009  logf(0);
7010 ; return 0; }
7011 EOF
7012 if { (eval echo configure:7013: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7013   rm -rf conftest*
7014   glibcpp_cv_func_logf_use=yes
7015 else
7016   echo "configure: failed program was:" >&5
7017   cat conftest.$ac_ext >&5
7018   rm -rf conftest*
7019   glibcpp_cv_func_logf_use=no
7020 fi
7021 rm -f conftest*
7022     ac_ext=c
7023 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7024 ac_cpp='$CPP $CPPFLAGS'
7025 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7026 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7027 cross_compiling=$ac_cv_prog_cc_cross
7028
7029
7030 fi
7031
7032   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
7033   if test x$glibcpp_cv_func_logf_use = x"yes"; then
7034     for ac_func in logf
7035 do
7036 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7037 echo "configure:7038: checking for $ac_func" >&5
7038 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7039   echo $ac_n "(cached) $ac_c" 1>&6
7040 else
7041   cat > conftest.$ac_ext <<EOF
7042 #line 7043 "configure"
7043 #include "confdefs.h"
7044 /* System header to define __stub macros and hopefully few prototypes,
7045     which can conflict with char $ac_func(); below.  */
7046 #include <assert.h>
7047 /* Override any gcc2 internal prototype to avoid an error.  */
7048 /* We use char because int might match the return type of a gcc2
7049     builtin and then its argument prototype would still apply.  */
7050 char $ac_func();
7051
7052 int main() {
7053
7054 /* The GNU C library defines this for functions which it implements
7055     to always fail with ENOSYS.  Some functions are actually named
7056     something starting with __ and the normal name is an alias.  */
7057 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7058 choke me
7059 #else
7060 $ac_func();
7061 #endif
7062
7063 ; return 0; }
7064 EOF
7065 if { (eval echo configure:7066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7066   rm -rf conftest*
7067   eval "ac_cv_func_$ac_func=yes"
7068 else
7069   echo "configure: failed program was:" >&5
7070   cat conftest.$ac_ext >&5
7071   rm -rf conftest*
7072   eval "ac_cv_func_$ac_func=no"
7073 fi
7074 rm -f conftest*
7075 fi
7076
7077 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7078   echo "$ac_t""yes" 1>&6
7079     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7080   cat >> confdefs.h <<EOF
7081 #define $ac_tr_func 1
7082 EOF
7083
7084 else
7085   echo "$ac_t""no" 1>&6
7086 fi
7087 done
7088
7089   fi
7090
7091
7092   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7093 echo "configure:7094: checking for log10f declaration" >&5
7094   if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
7095   echo $ac_n "(cached) $ac_c" 1>&6
7096 else
7097
7098
7099     ac_ext=C
7100 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7101 ac_cpp='$CXXCPP $CPPFLAGS'
7102 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7103 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7104 cross_compiling=$ac_cv_prog_cxx_cross
7105
7106     cat > conftest.$ac_ext <<EOF
7107 #line 7108 "configure"
7108 #include "confdefs.h"
7109 #include <math.h>
7110 int main() {
7111  log10f(0);
7112 ; return 0; }
7113 EOF
7114 if { (eval echo configure:7115: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7115   rm -rf conftest*
7116   glibcpp_cv_func_log10f_use=yes
7117 else
7118   echo "configure: failed program was:" >&5
7119   cat conftest.$ac_ext >&5
7120   rm -rf conftest*
7121   glibcpp_cv_func_log10f_use=no
7122 fi
7123 rm -f conftest*
7124     ac_ext=c
7125 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7126 ac_cpp='$CPP $CPPFLAGS'
7127 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7128 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7129 cross_compiling=$ac_cv_prog_cc_cross
7130
7131
7132 fi
7133
7134   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
7135   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
7136     for ac_func in log10f
7137 do
7138 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7139 echo "configure:7140: checking for $ac_func" >&5
7140 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7141   echo $ac_n "(cached) $ac_c" 1>&6
7142 else
7143   cat > conftest.$ac_ext <<EOF
7144 #line 7145 "configure"
7145 #include "confdefs.h"
7146 /* System header to define __stub macros and hopefully few prototypes,
7147     which can conflict with char $ac_func(); below.  */
7148 #include <assert.h>
7149 /* Override any gcc2 internal prototype to avoid an error.  */
7150 /* We use char because int might match the return type of a gcc2
7151     builtin and then its argument prototype would still apply.  */
7152 char $ac_func();
7153
7154 int main() {
7155
7156 /* The GNU C library defines this for functions which it implements
7157     to always fail with ENOSYS.  Some functions are actually named
7158     something starting with __ and the normal name is an alias.  */
7159 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7160 choke me
7161 #else
7162 $ac_func();
7163 #endif
7164
7165 ; return 0; }
7166 EOF
7167 if { (eval echo configure:7168: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7168   rm -rf conftest*
7169   eval "ac_cv_func_$ac_func=yes"
7170 else
7171   echo "configure: failed program was:" >&5
7172   cat conftest.$ac_ext >&5
7173   rm -rf conftest*
7174   eval "ac_cv_func_$ac_func=no"
7175 fi
7176 rm -f conftest*
7177 fi
7178
7179 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7180   echo "$ac_t""yes" 1>&6
7181     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7182   cat >> confdefs.h <<EOF
7183 #define $ac_tr_func 1
7184 EOF
7185
7186 else
7187   echo "$ac_t""no" 1>&6
7188 fi
7189 done
7190
7191   fi
7192
7193
7194   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7195 echo "configure:7196: checking for modff declaration" >&5
7196   if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
7197   echo $ac_n "(cached) $ac_c" 1>&6
7198 else
7199
7200
7201     ac_ext=C
7202 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7203 ac_cpp='$CXXCPP $CPPFLAGS'
7204 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7205 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7206 cross_compiling=$ac_cv_prog_cxx_cross
7207
7208     cat > conftest.$ac_ext <<EOF
7209 #line 7210 "configure"
7210 #include "confdefs.h"
7211 #include <math.h>
7212 int main() {
7213  modff(0, 0);
7214 ; return 0; }
7215 EOF
7216 if { (eval echo configure:7217: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7217   rm -rf conftest*
7218   glibcpp_cv_func_modff_use=yes
7219 else
7220   echo "configure: failed program was:" >&5
7221   cat conftest.$ac_ext >&5
7222   rm -rf conftest*
7223   glibcpp_cv_func_modff_use=no
7224 fi
7225 rm -f conftest*
7226     ac_ext=c
7227 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7228 ac_cpp='$CPP $CPPFLAGS'
7229 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7230 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7231 cross_compiling=$ac_cv_prog_cc_cross
7232
7233
7234 fi
7235
7236   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
7237   if test x$glibcpp_cv_func_modff_use = x"yes"; then
7238     for ac_func in modff
7239 do
7240 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7241 echo "configure:7242: checking for $ac_func" >&5
7242 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7243   echo $ac_n "(cached) $ac_c" 1>&6
7244 else
7245   cat > conftest.$ac_ext <<EOF
7246 #line 7247 "configure"
7247 #include "confdefs.h"
7248 /* System header to define __stub macros and hopefully few prototypes,
7249     which can conflict with char $ac_func(); below.  */
7250 #include <assert.h>
7251 /* Override any gcc2 internal prototype to avoid an error.  */
7252 /* We use char because int might match the return type of a gcc2
7253     builtin and then its argument prototype would still apply.  */
7254 char $ac_func();
7255
7256 int main() {
7257
7258 /* The GNU C library defines this for functions which it implements
7259     to always fail with ENOSYS.  Some functions are actually named
7260     something starting with __ and the normal name is an alias.  */
7261 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7262 choke me
7263 #else
7264 $ac_func();
7265 #endif
7266
7267 ; return 0; }
7268 EOF
7269 if { (eval echo configure:7270: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7270   rm -rf conftest*
7271   eval "ac_cv_func_$ac_func=yes"
7272 else
7273   echo "configure: failed program was:" >&5
7274   cat conftest.$ac_ext >&5
7275   rm -rf conftest*
7276   eval "ac_cv_func_$ac_func=no"
7277 fi
7278 rm -f conftest*
7279 fi
7280
7281 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7282   echo "$ac_t""yes" 1>&6
7283     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7284   cat >> confdefs.h <<EOF
7285 #define $ac_tr_func 1
7286 EOF
7287
7288 else
7289   echo "$ac_t""no" 1>&6
7290 fi
7291 done
7292
7293   fi
7294
7295
7296   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
7297 echo "configure:7298: checking for powf declaration" >&5
7298   if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
7299   echo $ac_n "(cached) $ac_c" 1>&6
7300 else
7301
7302
7303     ac_ext=C
7304 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7305 ac_cpp='$CXXCPP $CPPFLAGS'
7306 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7307 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7308 cross_compiling=$ac_cv_prog_cxx_cross
7309
7310     cat > conftest.$ac_ext <<EOF
7311 #line 7312 "configure"
7312 #include "confdefs.h"
7313 #include <math.h>
7314 int main() {
7315  powf(0, 0);
7316 ; return 0; }
7317 EOF
7318 if { (eval echo configure:7319: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7319   rm -rf conftest*
7320   glibcpp_cv_func_powf_use=yes
7321 else
7322   echo "configure: failed program was:" >&5
7323   cat conftest.$ac_ext >&5
7324   rm -rf conftest*
7325   glibcpp_cv_func_powf_use=no
7326 fi
7327 rm -f conftest*
7328     ac_ext=c
7329 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7330 ac_cpp='$CPP $CPPFLAGS'
7331 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7332 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7333 cross_compiling=$ac_cv_prog_cc_cross
7334
7335
7336 fi
7337
7338   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
7339   if test x$glibcpp_cv_func_powf_use = x"yes"; then
7340     for ac_func in powf
7341 do
7342 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7343 echo "configure:7344: checking for $ac_func" >&5
7344 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7345   echo $ac_n "(cached) $ac_c" 1>&6
7346 else
7347   cat > conftest.$ac_ext <<EOF
7348 #line 7349 "configure"
7349 #include "confdefs.h"
7350 /* System header to define __stub macros and hopefully few prototypes,
7351     which can conflict with char $ac_func(); below.  */
7352 #include <assert.h>
7353 /* Override any gcc2 internal prototype to avoid an error.  */
7354 /* We use char because int might match the return type of a gcc2
7355     builtin and then its argument prototype would still apply.  */
7356 char $ac_func();
7357
7358 int main() {
7359
7360 /* The GNU C library defines this for functions which it implements
7361     to always fail with ENOSYS.  Some functions are actually named
7362     something starting with __ and the normal name is an alias.  */
7363 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7364 choke me
7365 #else
7366 $ac_func();
7367 #endif
7368
7369 ; return 0; }
7370 EOF
7371 if { (eval echo configure:7372: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7372   rm -rf conftest*
7373   eval "ac_cv_func_$ac_func=yes"
7374 else
7375   echo "configure: failed program was:" >&5
7376   cat conftest.$ac_ext >&5
7377   rm -rf conftest*
7378   eval "ac_cv_func_$ac_func=no"
7379 fi
7380 rm -f conftest*
7381 fi
7382
7383 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7384   echo "$ac_t""yes" 1>&6
7385     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7386   cat >> confdefs.h <<EOF
7387 #define $ac_tr_func 1
7388 EOF
7389
7390 else
7391   echo "$ac_t""no" 1>&6
7392 fi
7393 done
7394
7395   fi
7396
7397
7398   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
7399 echo "configure:7400: checking for sinf declaration" >&5
7400   if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
7401   echo $ac_n "(cached) $ac_c" 1>&6
7402 else
7403
7404
7405     ac_ext=C
7406 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7407 ac_cpp='$CXXCPP $CPPFLAGS'
7408 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7409 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7410 cross_compiling=$ac_cv_prog_cxx_cross
7411
7412     cat > conftest.$ac_ext <<EOF
7413 #line 7414 "configure"
7414 #include "confdefs.h"
7415 #include <math.h>
7416 int main() {
7417  sinf(0);
7418 ; return 0; }
7419 EOF
7420 if { (eval echo configure:7421: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7421   rm -rf conftest*
7422   glibcpp_cv_func_sinf_use=yes
7423 else
7424   echo "configure: failed program was:" >&5
7425   cat conftest.$ac_ext >&5
7426   rm -rf conftest*
7427   glibcpp_cv_func_sinf_use=no
7428 fi
7429 rm -f conftest*
7430     ac_ext=c
7431 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7432 ac_cpp='$CPP $CPPFLAGS'
7433 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7434 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7435 cross_compiling=$ac_cv_prog_cc_cross
7436
7437
7438 fi
7439
7440   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
7441   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
7442     for ac_func in sinf
7443 do
7444 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7445 echo "configure:7446: checking for $ac_func" >&5
7446 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7447   echo $ac_n "(cached) $ac_c" 1>&6
7448 else
7449   cat > conftest.$ac_ext <<EOF
7450 #line 7451 "configure"
7451 #include "confdefs.h"
7452 /* System header to define __stub macros and hopefully few prototypes,
7453     which can conflict with char $ac_func(); below.  */
7454 #include <assert.h>
7455 /* Override any gcc2 internal prototype to avoid an error.  */
7456 /* We use char because int might match the return type of a gcc2
7457     builtin and then its argument prototype would still apply.  */
7458 char $ac_func();
7459
7460 int main() {
7461
7462 /* The GNU C library defines this for functions which it implements
7463     to always fail with ENOSYS.  Some functions are actually named
7464     something starting with __ and the normal name is an alias.  */
7465 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7466 choke me
7467 #else
7468 $ac_func();
7469 #endif
7470
7471 ; return 0; }
7472 EOF
7473 if { (eval echo configure:7474: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7474   rm -rf conftest*
7475   eval "ac_cv_func_$ac_func=yes"
7476 else
7477   echo "configure: failed program was:" >&5
7478   cat conftest.$ac_ext >&5
7479   rm -rf conftest*
7480   eval "ac_cv_func_$ac_func=no"
7481 fi
7482 rm -f conftest*
7483 fi
7484
7485 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7486   echo "$ac_t""yes" 1>&6
7487     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7488   cat >> confdefs.h <<EOF
7489 #define $ac_tr_func 1
7490 EOF
7491
7492 else
7493   echo "$ac_t""no" 1>&6
7494 fi
7495 done
7496
7497   fi
7498
7499
7500   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
7501 echo "configure:7502: checking for sinhf declaration" >&5
7502   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
7503   echo $ac_n "(cached) $ac_c" 1>&6
7504 else
7505
7506
7507     ac_ext=C
7508 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7509 ac_cpp='$CXXCPP $CPPFLAGS'
7510 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7511 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7512 cross_compiling=$ac_cv_prog_cxx_cross
7513
7514     cat > conftest.$ac_ext <<EOF
7515 #line 7516 "configure"
7516 #include "confdefs.h"
7517 #include <math.h>
7518 int main() {
7519  sinhf(0);
7520 ; return 0; }
7521 EOF
7522 if { (eval echo configure:7523: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7523   rm -rf conftest*
7524   glibcpp_cv_func_sinhf_use=yes
7525 else
7526   echo "configure: failed program was:" >&5
7527   cat conftest.$ac_ext >&5
7528   rm -rf conftest*
7529   glibcpp_cv_func_sinhf_use=no
7530 fi
7531 rm -f conftest*
7532     ac_ext=c
7533 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7534 ac_cpp='$CPP $CPPFLAGS'
7535 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7536 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7537 cross_compiling=$ac_cv_prog_cc_cross
7538
7539
7540 fi
7541
7542   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
7543   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
7544     for ac_func in sinhf
7545 do
7546 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7547 echo "configure:7548: checking for $ac_func" >&5
7548 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7549   echo $ac_n "(cached) $ac_c" 1>&6
7550 else
7551   cat > conftest.$ac_ext <<EOF
7552 #line 7553 "configure"
7553 #include "confdefs.h"
7554 /* System header to define __stub macros and hopefully few prototypes,
7555     which can conflict with char $ac_func(); below.  */
7556 #include <assert.h>
7557 /* Override any gcc2 internal prototype to avoid an error.  */
7558 /* We use char because int might match the return type of a gcc2
7559     builtin and then its argument prototype would still apply.  */
7560 char $ac_func();
7561
7562 int main() {
7563
7564 /* The GNU C library defines this for functions which it implements
7565     to always fail with ENOSYS.  Some functions are actually named
7566     something starting with __ and the normal name is an alias.  */
7567 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7568 choke me
7569 #else
7570 $ac_func();
7571 #endif
7572
7573 ; return 0; }
7574 EOF
7575 if { (eval echo configure:7576: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7576   rm -rf conftest*
7577   eval "ac_cv_func_$ac_func=yes"
7578 else
7579   echo "configure: failed program was:" >&5
7580   cat conftest.$ac_ext >&5
7581   rm -rf conftest*
7582   eval "ac_cv_func_$ac_func=no"
7583 fi
7584 rm -f conftest*
7585 fi
7586
7587 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7588   echo "$ac_t""yes" 1>&6
7589     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7590   cat >> confdefs.h <<EOF
7591 #define $ac_tr_func 1
7592 EOF
7593
7594 else
7595   echo "$ac_t""no" 1>&6
7596 fi
7597 done
7598
7599   fi
7600
7601
7602   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
7603 echo "configure:7604: checking for sqrtf declaration" >&5
7604   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
7605   echo $ac_n "(cached) $ac_c" 1>&6
7606 else
7607
7608
7609     ac_ext=C
7610 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7611 ac_cpp='$CXXCPP $CPPFLAGS'
7612 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7613 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7614 cross_compiling=$ac_cv_prog_cxx_cross
7615
7616     cat > conftest.$ac_ext <<EOF
7617 #line 7618 "configure"
7618 #include "confdefs.h"
7619 #include <math.h>
7620 int main() {
7621  sqrtf(0);
7622 ; return 0; }
7623 EOF
7624 if { (eval echo configure:7625: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7625   rm -rf conftest*
7626   glibcpp_cv_func_sqrtf_use=yes
7627 else
7628   echo "configure: failed program was:" >&5
7629   cat conftest.$ac_ext >&5
7630   rm -rf conftest*
7631   glibcpp_cv_func_sqrtf_use=no
7632 fi
7633 rm -f conftest*
7634     ac_ext=c
7635 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7636 ac_cpp='$CPP $CPPFLAGS'
7637 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7638 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7639 cross_compiling=$ac_cv_prog_cc_cross
7640
7641
7642 fi
7643
7644   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
7645   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
7646     for ac_func in sqrtf
7647 do
7648 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7649 echo "configure:7650: checking for $ac_func" >&5
7650 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7651   echo $ac_n "(cached) $ac_c" 1>&6
7652 else
7653   cat > conftest.$ac_ext <<EOF
7654 #line 7655 "configure"
7655 #include "confdefs.h"
7656 /* System header to define __stub macros and hopefully few prototypes,
7657     which can conflict with char $ac_func(); below.  */
7658 #include <assert.h>
7659 /* Override any gcc2 internal prototype to avoid an error.  */
7660 /* We use char because int might match the return type of a gcc2
7661     builtin and then its argument prototype would still apply.  */
7662 char $ac_func();
7663
7664 int main() {
7665
7666 /* The GNU C library defines this for functions which it implements
7667     to always fail with ENOSYS.  Some functions are actually named
7668     something starting with __ and the normal name is an alias.  */
7669 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7670 choke me
7671 #else
7672 $ac_func();
7673 #endif
7674
7675 ; return 0; }
7676 EOF
7677 if { (eval echo configure:7678: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7678   rm -rf conftest*
7679   eval "ac_cv_func_$ac_func=yes"
7680 else
7681   echo "configure: failed program was:" >&5
7682   cat conftest.$ac_ext >&5
7683   rm -rf conftest*
7684   eval "ac_cv_func_$ac_func=no"
7685 fi
7686 rm -f conftest*
7687 fi
7688
7689 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7690   echo "$ac_t""yes" 1>&6
7691     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7692   cat >> confdefs.h <<EOF
7693 #define $ac_tr_func 1
7694 EOF
7695
7696 else
7697   echo "$ac_t""no" 1>&6
7698 fi
7699 done
7700
7701   fi
7702
7703
7704   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
7705 echo "configure:7706: checking for tanf declaration" >&5
7706   if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
7707   echo $ac_n "(cached) $ac_c" 1>&6
7708 else
7709
7710
7711     ac_ext=C
7712 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7713 ac_cpp='$CXXCPP $CPPFLAGS'
7714 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7715 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7716 cross_compiling=$ac_cv_prog_cxx_cross
7717
7718     cat > conftest.$ac_ext <<EOF
7719 #line 7720 "configure"
7720 #include "confdefs.h"
7721 #include <math.h>
7722 int main() {
7723  tanf(0);
7724 ; return 0; }
7725 EOF
7726 if { (eval echo configure:7727: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7727   rm -rf conftest*
7728   glibcpp_cv_func_tanf_use=yes
7729 else
7730   echo "configure: failed program was:" >&5
7731   cat conftest.$ac_ext >&5
7732   rm -rf conftest*
7733   glibcpp_cv_func_tanf_use=no
7734 fi
7735 rm -f conftest*
7736     ac_ext=c
7737 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7738 ac_cpp='$CPP $CPPFLAGS'
7739 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7740 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7741 cross_compiling=$ac_cv_prog_cc_cross
7742
7743
7744 fi
7745
7746   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
7747   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
7748     for ac_func in tanf
7749 do
7750 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7751 echo "configure:7752: checking for $ac_func" >&5
7752 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7753   echo $ac_n "(cached) $ac_c" 1>&6
7754 else
7755   cat > conftest.$ac_ext <<EOF
7756 #line 7757 "configure"
7757 #include "confdefs.h"
7758 /* System header to define __stub macros and hopefully few prototypes,
7759     which can conflict with char $ac_func(); below.  */
7760 #include <assert.h>
7761 /* Override any gcc2 internal prototype to avoid an error.  */
7762 /* We use char because int might match the return type of a gcc2
7763     builtin and then its argument prototype would still apply.  */
7764 char $ac_func();
7765
7766 int main() {
7767
7768 /* The GNU C library defines this for functions which it implements
7769     to always fail with ENOSYS.  Some functions are actually named
7770     something starting with __ and the normal name is an alias.  */
7771 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7772 choke me
7773 #else
7774 $ac_func();
7775 #endif
7776
7777 ; return 0; }
7778 EOF
7779 if { (eval echo configure:7780: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7780   rm -rf conftest*
7781   eval "ac_cv_func_$ac_func=yes"
7782 else
7783   echo "configure: failed program was:" >&5
7784   cat conftest.$ac_ext >&5
7785   rm -rf conftest*
7786   eval "ac_cv_func_$ac_func=no"
7787 fi
7788 rm -f conftest*
7789 fi
7790
7791 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7792   echo "$ac_t""yes" 1>&6
7793     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7794   cat >> confdefs.h <<EOF
7795 #define $ac_tr_func 1
7796 EOF
7797
7798 else
7799   echo "$ac_t""no" 1>&6
7800 fi
7801 done
7802
7803   fi
7804
7805
7806   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
7807 echo "configure:7808: checking for tanhf declaration" >&5
7808   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
7809   echo $ac_n "(cached) $ac_c" 1>&6
7810 else
7811
7812
7813     ac_ext=C
7814 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7815 ac_cpp='$CXXCPP $CPPFLAGS'
7816 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7817 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7818 cross_compiling=$ac_cv_prog_cxx_cross
7819
7820     cat > conftest.$ac_ext <<EOF
7821 #line 7822 "configure"
7822 #include "confdefs.h"
7823 #include <math.h>
7824 int main() {
7825  tanhf(0);
7826 ; return 0; }
7827 EOF
7828 if { (eval echo configure:7829: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7829   rm -rf conftest*
7830   glibcpp_cv_func_tanhf_use=yes
7831 else
7832   echo "configure: failed program was:" >&5
7833   cat conftest.$ac_ext >&5
7834   rm -rf conftest*
7835   glibcpp_cv_func_tanhf_use=no
7836 fi
7837 rm -f conftest*
7838     ac_ext=c
7839 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7840 ac_cpp='$CPP $CPPFLAGS'
7841 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7842 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7843 cross_compiling=$ac_cv_prog_cc_cross
7844
7845
7846 fi
7847
7848   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
7849   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
7850     for ac_func in tanhf
7851 do
7852 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7853 echo "configure:7854: checking for $ac_func" >&5
7854 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7855   echo $ac_n "(cached) $ac_c" 1>&6
7856 else
7857   cat > conftest.$ac_ext <<EOF
7858 #line 7859 "configure"
7859 #include "confdefs.h"
7860 /* System header to define __stub macros and hopefully few prototypes,
7861     which can conflict with char $ac_func(); below.  */
7862 #include <assert.h>
7863 /* Override any gcc2 internal prototype to avoid an error.  */
7864 /* We use char because int might match the return type of a gcc2
7865     builtin and then its argument prototype would still apply.  */
7866 char $ac_func();
7867
7868 int main() {
7869
7870 /* The GNU C library defines this for functions which it implements
7871     to always fail with ENOSYS.  Some functions are actually named
7872     something starting with __ and the normal name is an alias.  */
7873 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7874 choke me
7875 #else
7876 $ac_func();
7877 #endif
7878
7879 ; return 0; }
7880 EOF
7881 if { (eval echo configure:7882: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7882   rm -rf conftest*
7883   eval "ac_cv_func_$ac_func=yes"
7884 else
7885   echo "configure: failed program was:" >&5
7886   cat conftest.$ac_ext >&5
7887   rm -rf conftest*
7888   eval "ac_cv_func_$ac_func=no"
7889 fi
7890 rm -f conftest*
7891 fi
7892
7893 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7894   echo "$ac_t""yes" 1>&6
7895     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7896   cat >> confdefs.h <<EOF
7897 #define $ac_tr_func 1
7898 EOF
7899
7900 else
7901   echo "$ac_t""no" 1>&6
7902 fi
7903 done
7904
7905   fi
7906
7907
7908   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7909 echo "configure:7910: checking for sincosf declaration" >&5
7910   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
7911   echo $ac_n "(cached) $ac_c" 1>&6
7912 else
7913
7914
7915     ac_ext=C
7916 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7917 ac_cpp='$CXXCPP $CPPFLAGS'
7918 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7919 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7920 cross_compiling=$ac_cv_prog_cxx_cross
7921
7922     cat > conftest.$ac_ext <<EOF
7923 #line 7924 "configure"
7924 #include "confdefs.h"
7925 #include <math.h>
7926 int main() {
7927  sincosf(0, 0, 0);
7928 ; return 0; }
7929 EOF
7930 if { (eval echo configure:7931: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7931   rm -rf conftest*
7932   glibcpp_cv_func_sincosf_use=yes
7933 else
7934   echo "configure: failed program was:" >&5
7935   cat conftest.$ac_ext >&5
7936   rm -rf conftest*
7937   glibcpp_cv_func_sincosf_use=no
7938 fi
7939 rm -f conftest*
7940     ac_ext=c
7941 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7942 ac_cpp='$CPP $CPPFLAGS'
7943 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7944 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7945 cross_compiling=$ac_cv_prog_cc_cross
7946
7947
7948 fi
7949
7950   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
7951   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
7952     for ac_func in sincosf
7953 do
7954 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7955 echo "configure:7956: checking for $ac_func" >&5
7956 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7957   echo $ac_n "(cached) $ac_c" 1>&6
7958 else
7959   cat > conftest.$ac_ext <<EOF
7960 #line 7961 "configure"
7961 #include "confdefs.h"
7962 /* System header to define __stub macros and hopefully few prototypes,
7963     which can conflict with char $ac_func(); below.  */
7964 #include <assert.h>
7965 /* Override any gcc2 internal prototype to avoid an error.  */
7966 /* We use char because int might match the return type of a gcc2
7967     builtin and then its argument prototype would still apply.  */
7968 char $ac_func();
7969
7970 int main() {
7971
7972 /* The GNU C library defines this for functions which it implements
7973     to always fail with ENOSYS.  Some functions are actually named
7974     something starting with __ and the normal name is an alias.  */
7975 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7976 choke me
7977 #else
7978 $ac_func();
7979 #endif
7980
7981 ; return 0; }
7982 EOF
7983 if { (eval echo configure:7984: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7984   rm -rf conftest*
7985   eval "ac_cv_func_$ac_func=yes"
7986 else
7987   echo "configure: failed program was:" >&5
7988   cat conftest.$ac_ext >&5
7989   rm -rf conftest*
7990   eval "ac_cv_func_$ac_func=no"
7991 fi
7992 rm -f conftest*
7993 fi
7994
7995 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7996   echo "$ac_t""yes" 1>&6
7997     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7998   cat >> confdefs.h <<EOF
7999 #define $ac_tr_func 1
8000 EOF
8001
8002 else
8003   echo "$ac_t""no" 1>&6
8004 fi
8005 done
8006
8007   fi
8008
8009
8010   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
8011 echo "configure:8012: checking for finitef declaration" >&5
8012   if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
8013   echo $ac_n "(cached) $ac_c" 1>&6
8014 else
8015
8016
8017     ac_ext=C
8018 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8019 ac_cpp='$CXXCPP $CPPFLAGS'
8020 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8021 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8022 cross_compiling=$ac_cv_prog_cxx_cross
8023
8024     cat > conftest.$ac_ext <<EOF
8025 #line 8026 "configure"
8026 #include "confdefs.h"
8027 #include <math.h>
8028 int main() {
8029  finitef(0);
8030 ; return 0; }
8031 EOF
8032 if { (eval echo configure:8033: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8033   rm -rf conftest*
8034   glibcpp_cv_func_finitef_use=yes
8035 else
8036   echo "configure: failed program was:" >&5
8037   cat conftest.$ac_ext >&5
8038   rm -rf conftest*
8039   glibcpp_cv_func_finitef_use=no
8040 fi
8041 rm -f conftest*
8042     ac_ext=c
8043 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8044 ac_cpp='$CPP $CPPFLAGS'
8045 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8046 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8047 cross_compiling=$ac_cv_prog_cc_cross
8048
8049
8050 fi
8051
8052   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
8053   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
8054     for ac_func in finitef
8055 do
8056 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8057 echo "configure:8058: checking for $ac_func" >&5
8058 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8059   echo $ac_n "(cached) $ac_c" 1>&6
8060 else
8061   cat > conftest.$ac_ext <<EOF
8062 #line 8063 "configure"
8063 #include "confdefs.h"
8064 /* System header to define __stub macros and hopefully few prototypes,
8065     which can conflict with char $ac_func(); below.  */
8066 #include <assert.h>
8067 /* Override any gcc2 internal prototype to avoid an error.  */
8068 /* We use char because int might match the return type of a gcc2
8069     builtin and then its argument prototype would still apply.  */
8070 char $ac_func();
8071
8072 int main() {
8073
8074 /* The GNU C library defines this for functions which it implements
8075     to always fail with ENOSYS.  Some functions are actually named
8076     something starting with __ and the normal name is an alias.  */
8077 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8078 choke me
8079 #else
8080 $ac_func();
8081 #endif
8082
8083 ; return 0; }
8084 EOF
8085 if { (eval echo configure:8086: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8086   rm -rf conftest*
8087   eval "ac_cv_func_$ac_func=yes"
8088 else
8089   echo "configure: failed program was:" >&5
8090   cat conftest.$ac_ext >&5
8091   rm -rf conftest*
8092   eval "ac_cv_func_$ac_func=no"
8093 fi
8094 rm -f conftest*
8095 fi
8096
8097 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8098   echo "$ac_t""yes" 1>&6
8099     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8100   cat >> confdefs.h <<EOF
8101 #define $ac_tr_func 1
8102 EOF
8103
8104 else
8105   echo "$ac_t""no" 1>&6
8106 fi
8107 done
8108
8109   fi
8110
8111
8112
8113   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8114 echo "configure:8115: checking for isnanl declaration" >&5
8115   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
8116   echo $ac_n "(cached) $ac_c" 1>&6
8117 else
8118
8119
8120     ac_ext=C
8121 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8122 ac_cpp='$CXXCPP $CPPFLAGS'
8123 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8124 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8125 cross_compiling=$ac_cv_prog_cxx_cross
8126
8127     cat > conftest.$ac_ext <<EOF
8128 #line 8129 "configure"
8129 #include "confdefs.h"
8130 #include <math.h>
8131 int main() {
8132  isnanl(0);
8133 ; return 0; }
8134 EOF
8135 if { (eval echo configure:8136: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8136   rm -rf conftest*
8137   glibcpp_cv_func_isnanl_use=yes
8138 else
8139   echo "configure: failed program was:" >&5
8140   cat conftest.$ac_ext >&5
8141   rm -rf conftest*
8142   glibcpp_cv_func_isnanl_use=no
8143 fi
8144 rm -f conftest*
8145     ac_ext=c
8146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8147 ac_cpp='$CPP $CPPFLAGS'
8148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8150 cross_compiling=$ac_cv_prog_cc_cross
8151
8152
8153 fi
8154
8155   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
8156   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
8157     for ac_func in isnanl
8158 do
8159 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8160 echo "configure:8161: checking for $ac_func" >&5
8161 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8162   echo $ac_n "(cached) $ac_c" 1>&6
8163 else
8164   cat > conftest.$ac_ext <<EOF
8165 #line 8166 "configure"
8166 #include "confdefs.h"
8167 /* System header to define __stub macros and hopefully few prototypes,
8168     which can conflict with char $ac_func(); below.  */
8169 #include <assert.h>
8170 /* Override any gcc2 internal prototype to avoid an error.  */
8171 /* We use char because int might match the return type of a gcc2
8172     builtin and then its argument prototype would still apply.  */
8173 char $ac_func();
8174
8175 int main() {
8176
8177 /* The GNU C library defines this for functions which it implements
8178     to always fail with ENOSYS.  Some functions are actually named
8179     something starting with __ and the normal name is an alias.  */
8180 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8181 choke me
8182 #else
8183 $ac_func();
8184 #endif
8185
8186 ; return 0; }
8187 EOF
8188 if { (eval echo configure:8189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8189   rm -rf conftest*
8190   eval "ac_cv_func_$ac_func=yes"
8191 else
8192   echo "configure: failed program was:" >&5
8193   cat conftest.$ac_ext >&5
8194   rm -rf conftest*
8195   eval "ac_cv_func_$ac_func=no"
8196 fi
8197 rm -f conftest*
8198 fi
8199
8200 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8201   echo "$ac_t""yes" 1>&6
8202     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8203   cat >> confdefs.h <<EOF
8204 #define $ac_tr_func 1
8205 EOF
8206
8207 else
8208   echo "$ac_t""no" 1>&6
8209 fi
8210 done
8211
8212   fi
8213
8214
8215   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8216 echo "configure:8217: checking for isinfl declaration" >&5
8217   if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
8218   echo $ac_n "(cached) $ac_c" 1>&6
8219 else
8220
8221
8222     ac_ext=C
8223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8224 ac_cpp='$CXXCPP $CPPFLAGS'
8225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8227 cross_compiling=$ac_cv_prog_cxx_cross
8228
8229     cat > conftest.$ac_ext <<EOF
8230 #line 8231 "configure"
8231 #include "confdefs.h"
8232 #include <math.h>
8233 int main() {
8234  isinfl(0);
8235 ; return 0; }
8236 EOF
8237 if { (eval echo configure:8238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8238   rm -rf conftest*
8239   glibcpp_cv_func_isinfl_use=yes
8240 else
8241   echo "configure: failed program was:" >&5
8242   cat conftest.$ac_ext >&5
8243   rm -rf conftest*
8244   glibcpp_cv_func_isinfl_use=no
8245 fi
8246 rm -f conftest*
8247     ac_ext=c
8248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8249 ac_cpp='$CPP $CPPFLAGS'
8250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8252 cross_compiling=$ac_cv_prog_cc_cross
8253
8254
8255 fi
8256
8257   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
8258   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
8259     for ac_func in isinfl
8260 do
8261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8262 echo "configure:8263: checking for $ac_func" >&5
8263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8264   echo $ac_n "(cached) $ac_c" 1>&6
8265 else
8266   cat > conftest.$ac_ext <<EOF
8267 #line 8268 "configure"
8268 #include "confdefs.h"
8269 /* System header to define __stub macros and hopefully few prototypes,
8270     which can conflict with char $ac_func(); below.  */
8271 #include <assert.h>
8272 /* Override any gcc2 internal prototype to avoid an error.  */
8273 /* We use char because int might match the return type of a gcc2
8274     builtin and then its argument prototype would still apply.  */
8275 char $ac_func();
8276
8277 int main() {
8278
8279 /* The GNU C library defines this for functions which it implements
8280     to always fail with ENOSYS.  Some functions are actually named
8281     something starting with __ and the normal name is an alias.  */
8282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8283 choke me
8284 #else
8285 $ac_func();
8286 #endif
8287
8288 ; return 0; }
8289 EOF
8290 if { (eval echo configure:8291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8291   rm -rf conftest*
8292   eval "ac_cv_func_$ac_func=yes"
8293 else
8294   echo "configure: failed program was:" >&5
8295   cat conftest.$ac_ext >&5
8296   rm -rf conftest*
8297   eval "ac_cv_func_$ac_func=no"
8298 fi
8299 rm -f conftest*
8300 fi
8301
8302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8303   echo "$ac_t""yes" 1>&6
8304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8305   cat >> confdefs.h <<EOF
8306 #define $ac_tr_func 1
8307 EOF
8308
8309 else
8310   echo "$ac_t""no" 1>&6
8311 fi
8312 done
8313
8314   fi
8315
8316
8317   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8318 echo "configure:8319: checking for copysignl declaration" >&5
8319   if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
8320   echo $ac_n "(cached) $ac_c" 1>&6
8321 else
8322
8323
8324     ac_ext=C
8325 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8326 ac_cpp='$CXXCPP $CPPFLAGS'
8327 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8328 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8329 cross_compiling=$ac_cv_prog_cxx_cross
8330
8331     cat > conftest.$ac_ext <<EOF
8332 #line 8333 "configure"
8333 #include "confdefs.h"
8334 #include <math.h>
8335 int main() {
8336  copysignl(0, 0);
8337 ; return 0; }
8338 EOF
8339 if { (eval echo configure:8340: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8340   rm -rf conftest*
8341   glibcpp_cv_func_copysignl_use=yes
8342 else
8343   echo "configure: failed program was:" >&5
8344   cat conftest.$ac_ext >&5
8345   rm -rf conftest*
8346   glibcpp_cv_func_copysignl_use=no
8347 fi
8348 rm -f conftest*
8349     ac_ext=c
8350 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8351 ac_cpp='$CPP $CPPFLAGS'
8352 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8353 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8354 cross_compiling=$ac_cv_prog_cc_cross
8355
8356
8357 fi
8358
8359   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
8360   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
8361     for ac_func in copysignl
8362 do
8363 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8364 echo "configure:8365: checking for $ac_func" >&5
8365 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8366   echo $ac_n "(cached) $ac_c" 1>&6
8367 else
8368   cat > conftest.$ac_ext <<EOF
8369 #line 8370 "configure"
8370 #include "confdefs.h"
8371 /* System header to define __stub macros and hopefully few prototypes,
8372     which can conflict with char $ac_func(); below.  */
8373 #include <assert.h>
8374 /* Override any gcc2 internal prototype to avoid an error.  */
8375 /* We use char because int might match the return type of a gcc2
8376     builtin and then its argument prototype would still apply.  */
8377 char $ac_func();
8378
8379 int main() {
8380
8381 /* The GNU C library defines this for functions which it implements
8382     to always fail with ENOSYS.  Some functions are actually named
8383     something starting with __ and the normal name is an alias.  */
8384 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8385 choke me
8386 #else
8387 $ac_func();
8388 #endif
8389
8390 ; return 0; }
8391 EOF
8392 if { (eval echo configure:8393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8393   rm -rf conftest*
8394   eval "ac_cv_func_$ac_func=yes"
8395 else
8396   echo "configure: failed program was:" >&5
8397   cat conftest.$ac_ext >&5
8398   rm -rf conftest*
8399   eval "ac_cv_func_$ac_func=no"
8400 fi
8401 rm -f conftest*
8402 fi
8403
8404 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8405   echo "$ac_t""yes" 1>&6
8406     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8407   cat >> confdefs.h <<EOF
8408 #define $ac_tr_func 1
8409 EOF
8410
8411 else
8412   echo "$ac_t""no" 1>&6
8413 fi
8414 done
8415
8416   fi
8417
8418
8419   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8420 echo "configure:8421: checking for acosl declaration" >&5
8421   if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
8422   echo $ac_n "(cached) $ac_c" 1>&6
8423 else
8424
8425
8426     ac_ext=C
8427 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8428 ac_cpp='$CXXCPP $CPPFLAGS'
8429 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8430 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8431 cross_compiling=$ac_cv_prog_cxx_cross
8432
8433     cat > conftest.$ac_ext <<EOF
8434 #line 8435 "configure"
8435 #include "confdefs.h"
8436 #include <math.h>
8437 int main() {
8438  acosl(0);
8439 ; return 0; }
8440 EOF
8441 if { (eval echo configure:8442: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8442   rm -rf conftest*
8443   glibcpp_cv_func_acosl_use=yes
8444 else
8445   echo "configure: failed program was:" >&5
8446   cat conftest.$ac_ext >&5
8447   rm -rf conftest*
8448   glibcpp_cv_func_acosl_use=no
8449 fi
8450 rm -f conftest*
8451     ac_ext=c
8452 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8453 ac_cpp='$CPP $CPPFLAGS'
8454 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8455 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8456 cross_compiling=$ac_cv_prog_cc_cross
8457
8458
8459 fi
8460
8461   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
8462   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
8463     for ac_func in acosl
8464 do
8465 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8466 echo "configure:8467: checking for $ac_func" >&5
8467 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8468   echo $ac_n "(cached) $ac_c" 1>&6
8469 else
8470   cat > conftest.$ac_ext <<EOF
8471 #line 8472 "configure"
8472 #include "confdefs.h"
8473 /* System header to define __stub macros and hopefully few prototypes,
8474     which can conflict with char $ac_func(); below.  */
8475 #include <assert.h>
8476 /* Override any gcc2 internal prototype to avoid an error.  */
8477 /* We use char because int might match the return type of a gcc2
8478     builtin and then its argument prototype would still apply.  */
8479 char $ac_func();
8480
8481 int main() {
8482
8483 /* The GNU C library defines this for functions which it implements
8484     to always fail with ENOSYS.  Some functions are actually named
8485     something starting with __ and the normal name is an alias.  */
8486 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8487 choke me
8488 #else
8489 $ac_func();
8490 #endif
8491
8492 ; return 0; }
8493 EOF
8494 if { (eval echo configure:8495: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8495   rm -rf conftest*
8496   eval "ac_cv_func_$ac_func=yes"
8497 else
8498   echo "configure: failed program was:" >&5
8499   cat conftest.$ac_ext >&5
8500   rm -rf conftest*
8501   eval "ac_cv_func_$ac_func=no"
8502 fi
8503 rm -f conftest*
8504 fi
8505
8506 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8507   echo "$ac_t""yes" 1>&6
8508     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8509   cat >> confdefs.h <<EOF
8510 #define $ac_tr_func 1
8511 EOF
8512
8513 else
8514   echo "$ac_t""no" 1>&6
8515 fi
8516 done
8517
8518   fi
8519
8520
8521   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8522 echo "configure:8523: checking for asinl declaration" >&5
8523   if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
8524   echo $ac_n "(cached) $ac_c" 1>&6
8525 else
8526
8527
8528     ac_ext=C
8529 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8530 ac_cpp='$CXXCPP $CPPFLAGS'
8531 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8532 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8533 cross_compiling=$ac_cv_prog_cxx_cross
8534
8535     cat > conftest.$ac_ext <<EOF
8536 #line 8537 "configure"
8537 #include "confdefs.h"
8538 #include <math.h>
8539 int main() {
8540  asinl(0);
8541 ; return 0; }
8542 EOF
8543 if { (eval echo configure:8544: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8544   rm -rf conftest*
8545   glibcpp_cv_func_asinl_use=yes
8546 else
8547   echo "configure: failed program was:" >&5
8548   cat conftest.$ac_ext >&5
8549   rm -rf conftest*
8550   glibcpp_cv_func_asinl_use=no
8551 fi
8552 rm -f conftest*
8553     ac_ext=c
8554 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8555 ac_cpp='$CPP $CPPFLAGS'
8556 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8557 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8558 cross_compiling=$ac_cv_prog_cc_cross
8559
8560
8561 fi
8562
8563   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
8564   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
8565     for ac_func in asinl
8566 do
8567 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8568 echo "configure:8569: checking for $ac_func" >&5
8569 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8570   echo $ac_n "(cached) $ac_c" 1>&6
8571 else
8572   cat > conftest.$ac_ext <<EOF
8573 #line 8574 "configure"
8574 #include "confdefs.h"
8575 /* System header to define __stub macros and hopefully few prototypes,
8576     which can conflict with char $ac_func(); below.  */
8577 #include <assert.h>
8578 /* Override any gcc2 internal prototype to avoid an error.  */
8579 /* We use char because int might match the return type of a gcc2
8580     builtin and then its argument prototype would still apply.  */
8581 char $ac_func();
8582
8583 int main() {
8584
8585 /* The GNU C library defines this for functions which it implements
8586     to always fail with ENOSYS.  Some functions are actually named
8587     something starting with __ and the normal name is an alias.  */
8588 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8589 choke me
8590 #else
8591 $ac_func();
8592 #endif
8593
8594 ; return 0; }
8595 EOF
8596 if { (eval echo configure:8597: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8597   rm -rf conftest*
8598   eval "ac_cv_func_$ac_func=yes"
8599 else
8600   echo "configure: failed program was:" >&5
8601   cat conftest.$ac_ext >&5
8602   rm -rf conftest*
8603   eval "ac_cv_func_$ac_func=no"
8604 fi
8605 rm -f conftest*
8606 fi
8607
8608 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8609   echo "$ac_t""yes" 1>&6
8610     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8611   cat >> confdefs.h <<EOF
8612 #define $ac_tr_func 1
8613 EOF
8614
8615 else
8616   echo "$ac_t""no" 1>&6
8617 fi
8618 done
8619
8620   fi
8621
8622
8623   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8624 echo "configure:8625: checking for atanl declaration" >&5
8625   if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
8626   echo $ac_n "(cached) $ac_c" 1>&6
8627 else
8628
8629
8630     ac_ext=C
8631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8632 ac_cpp='$CXXCPP $CPPFLAGS'
8633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8635 cross_compiling=$ac_cv_prog_cxx_cross
8636
8637     cat > conftest.$ac_ext <<EOF
8638 #line 8639 "configure"
8639 #include "confdefs.h"
8640 #include <math.h>
8641 int main() {
8642  atanl(0);
8643 ; return 0; }
8644 EOF
8645 if { (eval echo configure:8646: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8646   rm -rf conftest*
8647   glibcpp_cv_func_atanl_use=yes
8648 else
8649   echo "configure: failed program was:" >&5
8650   cat conftest.$ac_ext >&5
8651   rm -rf conftest*
8652   glibcpp_cv_func_atanl_use=no
8653 fi
8654 rm -f conftest*
8655     ac_ext=c
8656 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8657 ac_cpp='$CPP $CPPFLAGS'
8658 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8659 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8660 cross_compiling=$ac_cv_prog_cc_cross
8661
8662
8663 fi
8664
8665   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
8666   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
8667     for ac_func in atanl
8668 do
8669 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8670 echo "configure:8671: checking for $ac_func" >&5
8671 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8672   echo $ac_n "(cached) $ac_c" 1>&6
8673 else
8674   cat > conftest.$ac_ext <<EOF
8675 #line 8676 "configure"
8676 #include "confdefs.h"
8677 /* System header to define __stub macros and hopefully few prototypes,
8678     which can conflict with char $ac_func(); below.  */
8679 #include <assert.h>
8680 /* Override any gcc2 internal prototype to avoid an error.  */
8681 /* We use char because int might match the return type of a gcc2
8682     builtin and then its argument prototype would still apply.  */
8683 char $ac_func();
8684
8685 int main() {
8686
8687 /* The GNU C library defines this for functions which it implements
8688     to always fail with ENOSYS.  Some functions are actually named
8689     something starting with __ and the normal name is an alias.  */
8690 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8691 choke me
8692 #else
8693 $ac_func();
8694 #endif
8695
8696 ; return 0; }
8697 EOF
8698 if { (eval echo configure:8699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8699   rm -rf conftest*
8700   eval "ac_cv_func_$ac_func=yes"
8701 else
8702   echo "configure: failed program was:" >&5
8703   cat conftest.$ac_ext >&5
8704   rm -rf conftest*
8705   eval "ac_cv_func_$ac_func=no"
8706 fi
8707 rm -f conftest*
8708 fi
8709
8710 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8711   echo "$ac_t""yes" 1>&6
8712     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8713   cat >> confdefs.h <<EOF
8714 #define $ac_tr_func 1
8715 EOF
8716
8717 else
8718   echo "$ac_t""no" 1>&6
8719 fi
8720 done
8721
8722   fi
8723
8724
8725   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8726 echo "configure:8727: checking for atan2l declaration" >&5
8727   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
8728   echo $ac_n "(cached) $ac_c" 1>&6
8729 else
8730
8731
8732     ac_ext=C
8733 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8734 ac_cpp='$CXXCPP $CPPFLAGS'
8735 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8736 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8737 cross_compiling=$ac_cv_prog_cxx_cross
8738
8739     cat > conftest.$ac_ext <<EOF
8740 #line 8741 "configure"
8741 #include "confdefs.h"
8742 #include <math.h>
8743 int main() {
8744  atan2l(0, 0);
8745 ; return 0; }
8746 EOF
8747 if { (eval echo configure:8748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8748   rm -rf conftest*
8749   glibcpp_cv_func_atan2l_use=yes
8750 else
8751   echo "configure: failed program was:" >&5
8752   cat conftest.$ac_ext >&5
8753   rm -rf conftest*
8754   glibcpp_cv_func_atan2l_use=no
8755 fi
8756 rm -f conftest*
8757     ac_ext=c
8758 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8759 ac_cpp='$CPP $CPPFLAGS'
8760 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8761 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8762 cross_compiling=$ac_cv_prog_cc_cross
8763
8764
8765 fi
8766
8767   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
8768   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
8769     for ac_func in atan2l
8770 do
8771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8772 echo "configure:8773: checking for $ac_func" >&5
8773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8774   echo $ac_n "(cached) $ac_c" 1>&6
8775 else
8776   cat > conftest.$ac_ext <<EOF
8777 #line 8778 "configure"
8778 #include "confdefs.h"
8779 /* System header to define __stub macros and hopefully few prototypes,
8780     which can conflict with char $ac_func(); below.  */
8781 #include <assert.h>
8782 /* Override any gcc2 internal prototype to avoid an error.  */
8783 /* We use char because int might match the return type of a gcc2
8784     builtin and then its argument prototype would still apply.  */
8785 char $ac_func();
8786
8787 int main() {
8788
8789 /* The GNU C library defines this for functions which it implements
8790     to always fail with ENOSYS.  Some functions are actually named
8791     something starting with __ and the normal name is an alias.  */
8792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8793 choke me
8794 #else
8795 $ac_func();
8796 #endif
8797
8798 ; return 0; }
8799 EOF
8800 if { (eval echo configure:8801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8801   rm -rf conftest*
8802   eval "ac_cv_func_$ac_func=yes"
8803 else
8804   echo "configure: failed program was:" >&5
8805   cat conftest.$ac_ext >&5
8806   rm -rf conftest*
8807   eval "ac_cv_func_$ac_func=no"
8808 fi
8809 rm -f conftest*
8810 fi
8811
8812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8813   echo "$ac_t""yes" 1>&6
8814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8815   cat >> confdefs.h <<EOF
8816 #define $ac_tr_func 1
8817 EOF
8818
8819 else
8820   echo "$ac_t""no" 1>&6
8821 fi
8822 done
8823
8824   fi
8825
8826
8827   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8828 echo "configure:8829: checking for ceill declaration" >&5
8829   if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
8830   echo $ac_n "(cached) $ac_c" 1>&6
8831 else
8832
8833
8834     ac_ext=C
8835 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8836 ac_cpp='$CXXCPP $CPPFLAGS'
8837 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8838 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8839 cross_compiling=$ac_cv_prog_cxx_cross
8840
8841     cat > conftest.$ac_ext <<EOF
8842 #line 8843 "configure"
8843 #include "confdefs.h"
8844 #include <math.h>
8845 int main() {
8846  ceill(0);
8847 ; return 0; }
8848 EOF
8849 if { (eval echo configure:8850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8850   rm -rf conftest*
8851   glibcpp_cv_func_ceill_use=yes
8852 else
8853   echo "configure: failed program was:" >&5
8854   cat conftest.$ac_ext >&5
8855   rm -rf conftest*
8856   glibcpp_cv_func_ceill_use=no
8857 fi
8858 rm -f conftest*
8859     ac_ext=c
8860 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8861 ac_cpp='$CPP $CPPFLAGS'
8862 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8863 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8864 cross_compiling=$ac_cv_prog_cc_cross
8865
8866
8867 fi
8868
8869   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
8870   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
8871     for ac_func in ceill
8872 do
8873 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8874 echo "configure:8875: checking for $ac_func" >&5
8875 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8876   echo $ac_n "(cached) $ac_c" 1>&6
8877 else
8878   cat > conftest.$ac_ext <<EOF
8879 #line 8880 "configure"
8880 #include "confdefs.h"
8881 /* System header to define __stub macros and hopefully few prototypes,
8882     which can conflict with char $ac_func(); below.  */
8883 #include <assert.h>
8884 /* Override any gcc2 internal prototype to avoid an error.  */
8885 /* We use char because int might match the return type of a gcc2
8886     builtin and then its argument prototype would still apply.  */
8887 char $ac_func();
8888
8889 int main() {
8890
8891 /* The GNU C library defines this for functions which it implements
8892     to always fail with ENOSYS.  Some functions are actually named
8893     something starting with __ and the normal name is an alias.  */
8894 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8895 choke me
8896 #else
8897 $ac_func();
8898 #endif
8899
8900 ; return 0; }
8901 EOF
8902 if { (eval echo configure:8903: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8903   rm -rf conftest*
8904   eval "ac_cv_func_$ac_func=yes"
8905 else
8906   echo "configure: failed program was:" >&5
8907   cat conftest.$ac_ext >&5
8908   rm -rf conftest*
8909   eval "ac_cv_func_$ac_func=no"
8910 fi
8911 rm -f conftest*
8912 fi
8913
8914 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8915   echo "$ac_t""yes" 1>&6
8916     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8917   cat >> confdefs.h <<EOF
8918 #define $ac_tr_func 1
8919 EOF
8920
8921 else
8922   echo "$ac_t""no" 1>&6
8923 fi
8924 done
8925
8926   fi
8927
8928
8929   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8930 echo "configure:8931: checking for cosl declaration" >&5
8931   if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
8932   echo $ac_n "(cached) $ac_c" 1>&6
8933 else
8934
8935
8936     ac_ext=C
8937 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8938 ac_cpp='$CXXCPP $CPPFLAGS'
8939 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8940 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8941 cross_compiling=$ac_cv_prog_cxx_cross
8942
8943     cat > conftest.$ac_ext <<EOF
8944 #line 8945 "configure"
8945 #include "confdefs.h"
8946 #include <math.h>
8947 int main() {
8948  cosl(0);
8949 ; return 0; }
8950 EOF
8951 if { (eval echo configure:8952: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8952   rm -rf conftest*
8953   glibcpp_cv_func_cosl_use=yes
8954 else
8955   echo "configure: failed program was:" >&5
8956   cat conftest.$ac_ext >&5
8957   rm -rf conftest*
8958   glibcpp_cv_func_cosl_use=no
8959 fi
8960 rm -f conftest*
8961     ac_ext=c
8962 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8963 ac_cpp='$CPP $CPPFLAGS'
8964 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8965 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8966 cross_compiling=$ac_cv_prog_cc_cross
8967
8968
8969 fi
8970
8971   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
8972   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
8973     for ac_func in cosl
8974 do
8975 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8976 echo "configure:8977: checking for $ac_func" >&5
8977 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8978   echo $ac_n "(cached) $ac_c" 1>&6
8979 else
8980   cat > conftest.$ac_ext <<EOF
8981 #line 8982 "configure"
8982 #include "confdefs.h"
8983 /* System header to define __stub macros and hopefully few prototypes,
8984     which can conflict with char $ac_func(); below.  */
8985 #include <assert.h>
8986 /* Override any gcc2 internal prototype to avoid an error.  */
8987 /* We use char because int might match the return type of a gcc2
8988     builtin and then its argument prototype would still apply.  */
8989 char $ac_func();
8990
8991 int main() {
8992
8993 /* The GNU C library defines this for functions which it implements
8994     to always fail with ENOSYS.  Some functions are actually named
8995     something starting with __ and the normal name is an alias.  */
8996 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8997 choke me
8998 #else
8999 $ac_func();
9000 #endif
9001
9002 ; return 0; }
9003 EOF
9004 if { (eval echo configure:9005: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9005   rm -rf conftest*
9006   eval "ac_cv_func_$ac_func=yes"
9007 else
9008   echo "configure: failed program was:" >&5
9009   cat conftest.$ac_ext >&5
9010   rm -rf conftest*
9011   eval "ac_cv_func_$ac_func=no"
9012 fi
9013 rm -f conftest*
9014 fi
9015
9016 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9017   echo "$ac_t""yes" 1>&6
9018     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9019   cat >> confdefs.h <<EOF
9020 #define $ac_tr_func 1
9021 EOF
9022
9023 else
9024   echo "$ac_t""no" 1>&6
9025 fi
9026 done
9027
9028   fi
9029
9030
9031   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
9032 echo "configure:9033: checking for coshl declaration" >&5
9033   if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
9034   echo $ac_n "(cached) $ac_c" 1>&6
9035 else
9036
9037
9038     ac_ext=C
9039 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9040 ac_cpp='$CXXCPP $CPPFLAGS'
9041 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9042 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9043 cross_compiling=$ac_cv_prog_cxx_cross
9044
9045     cat > conftest.$ac_ext <<EOF
9046 #line 9047 "configure"
9047 #include "confdefs.h"
9048 #include <math.h>
9049 int main() {
9050  coshl(0);
9051 ; return 0; }
9052 EOF
9053 if { (eval echo configure:9054: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9054   rm -rf conftest*
9055   glibcpp_cv_func_coshl_use=yes
9056 else
9057   echo "configure: failed program was:" >&5
9058   cat conftest.$ac_ext >&5
9059   rm -rf conftest*
9060   glibcpp_cv_func_coshl_use=no
9061 fi
9062 rm -f conftest*
9063     ac_ext=c
9064 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9065 ac_cpp='$CPP $CPPFLAGS'
9066 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9067 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9068 cross_compiling=$ac_cv_prog_cc_cross
9069
9070
9071 fi
9072
9073   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
9074   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
9075     for ac_func in coshl
9076 do
9077 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9078 echo "configure:9079: checking for $ac_func" >&5
9079 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9080   echo $ac_n "(cached) $ac_c" 1>&6
9081 else
9082   cat > conftest.$ac_ext <<EOF
9083 #line 9084 "configure"
9084 #include "confdefs.h"
9085 /* System header to define __stub macros and hopefully few prototypes,
9086     which can conflict with char $ac_func(); below.  */
9087 #include <assert.h>
9088 /* Override any gcc2 internal prototype to avoid an error.  */
9089 /* We use char because int might match the return type of a gcc2
9090     builtin and then its argument prototype would still apply.  */
9091 char $ac_func();
9092
9093 int main() {
9094
9095 /* The GNU C library defines this for functions which it implements
9096     to always fail with ENOSYS.  Some functions are actually named
9097     something starting with __ and the normal name is an alias.  */
9098 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9099 choke me
9100 #else
9101 $ac_func();
9102 #endif
9103
9104 ; return 0; }
9105 EOF
9106 if { (eval echo configure:9107: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9107   rm -rf conftest*
9108   eval "ac_cv_func_$ac_func=yes"
9109 else
9110   echo "configure: failed program was:" >&5
9111   cat conftest.$ac_ext >&5
9112   rm -rf conftest*
9113   eval "ac_cv_func_$ac_func=no"
9114 fi
9115 rm -f conftest*
9116 fi
9117
9118 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9119   echo "$ac_t""yes" 1>&6
9120     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9121   cat >> confdefs.h <<EOF
9122 #define $ac_tr_func 1
9123 EOF
9124
9125 else
9126   echo "$ac_t""no" 1>&6
9127 fi
9128 done
9129
9130   fi
9131
9132
9133   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
9134 echo "configure:9135: checking for expl declaration" >&5
9135   if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
9136   echo $ac_n "(cached) $ac_c" 1>&6
9137 else
9138
9139
9140     ac_ext=C
9141 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9142 ac_cpp='$CXXCPP $CPPFLAGS'
9143 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9144 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9145 cross_compiling=$ac_cv_prog_cxx_cross
9146
9147     cat > conftest.$ac_ext <<EOF
9148 #line 9149 "configure"
9149 #include "confdefs.h"
9150 #include <math.h>
9151 int main() {
9152  expl(0);
9153 ; return 0; }
9154 EOF
9155 if { (eval echo configure:9156: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9156   rm -rf conftest*
9157   glibcpp_cv_func_expl_use=yes
9158 else
9159   echo "configure: failed program was:" >&5
9160   cat conftest.$ac_ext >&5
9161   rm -rf conftest*
9162   glibcpp_cv_func_expl_use=no
9163 fi
9164 rm -f conftest*
9165     ac_ext=c
9166 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9167 ac_cpp='$CPP $CPPFLAGS'
9168 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9169 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9170 cross_compiling=$ac_cv_prog_cc_cross
9171
9172
9173 fi
9174
9175   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
9176   if test x$glibcpp_cv_func_expl_use = x"yes"; then
9177     for ac_func in expl
9178 do
9179 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9180 echo "configure:9181: checking for $ac_func" >&5
9181 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9182   echo $ac_n "(cached) $ac_c" 1>&6
9183 else
9184   cat > conftest.$ac_ext <<EOF
9185 #line 9186 "configure"
9186 #include "confdefs.h"
9187 /* System header to define __stub macros and hopefully few prototypes,
9188     which can conflict with char $ac_func(); below.  */
9189 #include <assert.h>
9190 /* Override any gcc2 internal prototype to avoid an error.  */
9191 /* We use char because int might match the return type of a gcc2
9192     builtin and then its argument prototype would still apply.  */
9193 char $ac_func();
9194
9195 int main() {
9196
9197 /* The GNU C library defines this for functions which it implements
9198     to always fail with ENOSYS.  Some functions are actually named
9199     something starting with __ and the normal name is an alias.  */
9200 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9201 choke me
9202 #else
9203 $ac_func();
9204 #endif
9205
9206 ; return 0; }
9207 EOF
9208 if { (eval echo configure:9209: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9209   rm -rf conftest*
9210   eval "ac_cv_func_$ac_func=yes"
9211 else
9212   echo "configure: failed program was:" >&5
9213   cat conftest.$ac_ext >&5
9214   rm -rf conftest*
9215   eval "ac_cv_func_$ac_func=no"
9216 fi
9217 rm -f conftest*
9218 fi
9219
9220 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9221   echo "$ac_t""yes" 1>&6
9222     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9223   cat >> confdefs.h <<EOF
9224 #define $ac_tr_func 1
9225 EOF
9226
9227 else
9228   echo "$ac_t""no" 1>&6
9229 fi
9230 done
9231
9232   fi
9233
9234
9235   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9236 echo "configure:9237: checking for fabsl declaration" >&5
9237   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
9238   echo $ac_n "(cached) $ac_c" 1>&6
9239 else
9240
9241
9242     ac_ext=C
9243 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9244 ac_cpp='$CXXCPP $CPPFLAGS'
9245 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9246 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9247 cross_compiling=$ac_cv_prog_cxx_cross
9248
9249     cat > conftest.$ac_ext <<EOF
9250 #line 9251 "configure"
9251 #include "confdefs.h"
9252 #include <math.h>
9253 int main() {
9254  fabsl(0);
9255 ; return 0; }
9256 EOF
9257 if { (eval echo configure:9258: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9258   rm -rf conftest*
9259   glibcpp_cv_func_fabsl_use=yes
9260 else
9261   echo "configure: failed program was:" >&5
9262   cat conftest.$ac_ext >&5
9263   rm -rf conftest*
9264   glibcpp_cv_func_fabsl_use=no
9265 fi
9266 rm -f conftest*
9267     ac_ext=c
9268 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9269 ac_cpp='$CPP $CPPFLAGS'
9270 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9271 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9272 cross_compiling=$ac_cv_prog_cc_cross
9273
9274
9275 fi
9276
9277   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
9278   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
9279     for ac_func in fabsl
9280 do
9281 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9282 echo "configure:9283: checking for $ac_func" >&5
9283 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9284   echo $ac_n "(cached) $ac_c" 1>&6
9285 else
9286   cat > conftest.$ac_ext <<EOF
9287 #line 9288 "configure"
9288 #include "confdefs.h"
9289 /* System header to define __stub macros and hopefully few prototypes,
9290     which can conflict with char $ac_func(); below.  */
9291 #include <assert.h>
9292 /* Override any gcc2 internal prototype to avoid an error.  */
9293 /* We use char because int might match the return type of a gcc2
9294     builtin and then its argument prototype would still apply.  */
9295 char $ac_func();
9296
9297 int main() {
9298
9299 /* The GNU C library defines this for functions which it implements
9300     to always fail with ENOSYS.  Some functions are actually named
9301     something starting with __ and the normal name is an alias.  */
9302 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9303 choke me
9304 #else
9305 $ac_func();
9306 #endif
9307
9308 ; return 0; }
9309 EOF
9310 if { (eval echo configure:9311: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9311   rm -rf conftest*
9312   eval "ac_cv_func_$ac_func=yes"
9313 else
9314   echo "configure: failed program was:" >&5
9315   cat conftest.$ac_ext >&5
9316   rm -rf conftest*
9317   eval "ac_cv_func_$ac_func=no"
9318 fi
9319 rm -f conftest*
9320 fi
9321
9322 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9323   echo "$ac_t""yes" 1>&6
9324     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9325   cat >> confdefs.h <<EOF
9326 #define $ac_tr_func 1
9327 EOF
9328
9329 else
9330   echo "$ac_t""no" 1>&6
9331 fi
9332 done
9333
9334   fi
9335
9336
9337   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9338 echo "configure:9339: checking for floorl declaration" >&5
9339   if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
9340   echo $ac_n "(cached) $ac_c" 1>&6
9341 else
9342
9343
9344     ac_ext=C
9345 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9346 ac_cpp='$CXXCPP $CPPFLAGS'
9347 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9348 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9349 cross_compiling=$ac_cv_prog_cxx_cross
9350
9351     cat > conftest.$ac_ext <<EOF
9352 #line 9353 "configure"
9353 #include "confdefs.h"
9354 #include <math.h>
9355 int main() {
9356  floorl(0);
9357 ; return 0; }
9358 EOF
9359 if { (eval echo configure:9360: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9360   rm -rf conftest*
9361   glibcpp_cv_func_floorl_use=yes
9362 else
9363   echo "configure: failed program was:" >&5
9364   cat conftest.$ac_ext >&5
9365   rm -rf conftest*
9366   glibcpp_cv_func_floorl_use=no
9367 fi
9368 rm -f conftest*
9369     ac_ext=c
9370 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9371 ac_cpp='$CPP $CPPFLAGS'
9372 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9373 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9374 cross_compiling=$ac_cv_prog_cc_cross
9375
9376
9377 fi
9378
9379   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
9380   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
9381     for ac_func in floorl
9382 do
9383 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9384 echo "configure:9385: checking for $ac_func" >&5
9385 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9386   echo $ac_n "(cached) $ac_c" 1>&6
9387 else
9388   cat > conftest.$ac_ext <<EOF
9389 #line 9390 "configure"
9390 #include "confdefs.h"
9391 /* System header to define __stub macros and hopefully few prototypes,
9392     which can conflict with char $ac_func(); below.  */
9393 #include <assert.h>
9394 /* Override any gcc2 internal prototype to avoid an error.  */
9395 /* We use char because int might match the return type of a gcc2
9396     builtin and then its argument prototype would still apply.  */
9397 char $ac_func();
9398
9399 int main() {
9400
9401 /* The GNU C library defines this for functions which it implements
9402     to always fail with ENOSYS.  Some functions are actually named
9403     something starting with __ and the normal name is an alias.  */
9404 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9405 choke me
9406 #else
9407 $ac_func();
9408 #endif
9409
9410 ; return 0; }
9411 EOF
9412 if { (eval echo configure:9413: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9413   rm -rf conftest*
9414   eval "ac_cv_func_$ac_func=yes"
9415 else
9416   echo "configure: failed program was:" >&5
9417   cat conftest.$ac_ext >&5
9418   rm -rf conftest*
9419   eval "ac_cv_func_$ac_func=no"
9420 fi
9421 rm -f conftest*
9422 fi
9423
9424 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9425   echo "$ac_t""yes" 1>&6
9426     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9427   cat >> confdefs.h <<EOF
9428 #define $ac_tr_func 1
9429 EOF
9430
9431 else
9432   echo "$ac_t""no" 1>&6
9433 fi
9434 done
9435
9436   fi
9437
9438
9439   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9440 echo "configure:9441: checking for fmodl declaration" >&5
9441   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
9442   echo $ac_n "(cached) $ac_c" 1>&6
9443 else
9444
9445
9446     ac_ext=C
9447 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9448 ac_cpp='$CXXCPP $CPPFLAGS'
9449 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9450 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9451 cross_compiling=$ac_cv_prog_cxx_cross
9452
9453     cat > conftest.$ac_ext <<EOF
9454 #line 9455 "configure"
9455 #include "confdefs.h"
9456 #include <math.h>
9457 int main() {
9458  fmodl(0, 0);
9459 ; return 0; }
9460 EOF
9461 if { (eval echo configure:9462: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9462   rm -rf conftest*
9463   glibcpp_cv_func_fmodl_use=yes
9464 else
9465   echo "configure: failed program was:" >&5
9466   cat conftest.$ac_ext >&5
9467   rm -rf conftest*
9468   glibcpp_cv_func_fmodl_use=no
9469 fi
9470 rm -f conftest*
9471     ac_ext=c
9472 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9473 ac_cpp='$CPP $CPPFLAGS'
9474 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9475 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9476 cross_compiling=$ac_cv_prog_cc_cross
9477
9478
9479 fi
9480
9481   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
9482   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
9483     for ac_func in fmodl
9484 do
9485 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9486 echo "configure:9487: checking for $ac_func" >&5
9487 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9488   echo $ac_n "(cached) $ac_c" 1>&6
9489 else
9490   cat > conftest.$ac_ext <<EOF
9491 #line 9492 "configure"
9492 #include "confdefs.h"
9493 /* System header to define __stub macros and hopefully few prototypes,
9494     which can conflict with char $ac_func(); below.  */
9495 #include <assert.h>
9496 /* Override any gcc2 internal prototype to avoid an error.  */
9497 /* We use char because int might match the return type of a gcc2
9498     builtin and then its argument prototype would still apply.  */
9499 char $ac_func();
9500
9501 int main() {
9502
9503 /* The GNU C library defines this for functions which it implements
9504     to always fail with ENOSYS.  Some functions are actually named
9505     something starting with __ and the normal name is an alias.  */
9506 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9507 choke me
9508 #else
9509 $ac_func();
9510 #endif
9511
9512 ; return 0; }
9513 EOF
9514 if { (eval echo configure:9515: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9515   rm -rf conftest*
9516   eval "ac_cv_func_$ac_func=yes"
9517 else
9518   echo "configure: failed program was:" >&5
9519   cat conftest.$ac_ext >&5
9520   rm -rf conftest*
9521   eval "ac_cv_func_$ac_func=no"
9522 fi
9523 rm -f conftest*
9524 fi
9525
9526 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9527   echo "$ac_t""yes" 1>&6
9528     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9529   cat >> confdefs.h <<EOF
9530 #define $ac_tr_func 1
9531 EOF
9532
9533 else
9534   echo "$ac_t""no" 1>&6
9535 fi
9536 done
9537
9538   fi
9539
9540
9541   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9542 echo "configure:9543: checking for frexpl declaration" >&5
9543   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
9544   echo $ac_n "(cached) $ac_c" 1>&6
9545 else
9546
9547
9548     ac_ext=C
9549 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9550 ac_cpp='$CXXCPP $CPPFLAGS'
9551 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9552 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9553 cross_compiling=$ac_cv_prog_cxx_cross
9554
9555     cat > conftest.$ac_ext <<EOF
9556 #line 9557 "configure"
9557 #include "confdefs.h"
9558 #include <math.h>
9559 int main() {
9560  frexpl(0, 0);
9561 ; return 0; }
9562 EOF
9563 if { (eval echo configure:9564: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9564   rm -rf conftest*
9565   glibcpp_cv_func_frexpl_use=yes
9566 else
9567   echo "configure: failed program was:" >&5
9568   cat conftest.$ac_ext >&5
9569   rm -rf conftest*
9570   glibcpp_cv_func_frexpl_use=no
9571 fi
9572 rm -f conftest*
9573     ac_ext=c
9574 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9575 ac_cpp='$CPP $CPPFLAGS'
9576 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9577 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9578 cross_compiling=$ac_cv_prog_cc_cross
9579
9580
9581 fi
9582
9583   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
9584   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
9585     for ac_func in frexpl
9586 do
9587 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9588 echo "configure:9589: checking for $ac_func" >&5
9589 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9590   echo $ac_n "(cached) $ac_c" 1>&6
9591 else
9592   cat > conftest.$ac_ext <<EOF
9593 #line 9594 "configure"
9594 #include "confdefs.h"
9595 /* System header to define __stub macros and hopefully few prototypes,
9596     which can conflict with char $ac_func(); below.  */
9597 #include <assert.h>
9598 /* Override any gcc2 internal prototype to avoid an error.  */
9599 /* We use char because int might match the return type of a gcc2
9600     builtin and then its argument prototype would still apply.  */
9601 char $ac_func();
9602
9603 int main() {
9604
9605 /* The GNU C library defines this for functions which it implements
9606     to always fail with ENOSYS.  Some functions are actually named
9607     something starting with __ and the normal name is an alias.  */
9608 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9609 choke me
9610 #else
9611 $ac_func();
9612 #endif
9613
9614 ; return 0; }
9615 EOF
9616 if { (eval echo configure:9617: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9617   rm -rf conftest*
9618   eval "ac_cv_func_$ac_func=yes"
9619 else
9620   echo "configure: failed program was:" >&5
9621   cat conftest.$ac_ext >&5
9622   rm -rf conftest*
9623   eval "ac_cv_func_$ac_func=no"
9624 fi
9625 rm -f conftest*
9626 fi
9627
9628 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9629   echo "$ac_t""yes" 1>&6
9630     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9631   cat >> confdefs.h <<EOF
9632 #define $ac_tr_func 1
9633 EOF
9634
9635 else
9636   echo "$ac_t""no" 1>&6
9637 fi
9638 done
9639
9640   fi
9641
9642
9643   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9644 echo "configure:9645: checking for ldexpl declaration" >&5
9645   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
9646   echo $ac_n "(cached) $ac_c" 1>&6
9647 else
9648
9649
9650     ac_ext=C
9651 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9652 ac_cpp='$CXXCPP $CPPFLAGS'
9653 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9654 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9655 cross_compiling=$ac_cv_prog_cxx_cross
9656
9657     cat > conftest.$ac_ext <<EOF
9658 #line 9659 "configure"
9659 #include "confdefs.h"
9660 #include <math.h>
9661 int main() {
9662  ldexpl(0, 0);
9663 ; return 0; }
9664 EOF
9665 if { (eval echo configure:9666: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9666   rm -rf conftest*
9667   glibcpp_cv_func_ldexpl_use=yes
9668 else
9669   echo "configure: failed program was:" >&5
9670   cat conftest.$ac_ext >&5
9671   rm -rf conftest*
9672   glibcpp_cv_func_ldexpl_use=no
9673 fi
9674 rm -f conftest*
9675     ac_ext=c
9676 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9677 ac_cpp='$CPP $CPPFLAGS'
9678 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9679 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9680 cross_compiling=$ac_cv_prog_cc_cross
9681
9682
9683 fi
9684
9685   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
9686   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
9687     for ac_func in ldexpl
9688 do
9689 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9690 echo "configure:9691: checking for $ac_func" >&5
9691 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9692   echo $ac_n "(cached) $ac_c" 1>&6
9693 else
9694   cat > conftest.$ac_ext <<EOF
9695 #line 9696 "configure"
9696 #include "confdefs.h"
9697 /* System header to define __stub macros and hopefully few prototypes,
9698     which can conflict with char $ac_func(); below.  */
9699 #include <assert.h>
9700 /* Override any gcc2 internal prototype to avoid an error.  */
9701 /* We use char because int might match the return type of a gcc2
9702     builtin and then its argument prototype would still apply.  */
9703 char $ac_func();
9704
9705 int main() {
9706
9707 /* The GNU C library defines this for functions which it implements
9708     to always fail with ENOSYS.  Some functions are actually named
9709     something starting with __ and the normal name is an alias.  */
9710 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9711 choke me
9712 #else
9713 $ac_func();
9714 #endif
9715
9716 ; return 0; }
9717 EOF
9718 if { (eval echo configure:9719: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9719   rm -rf conftest*
9720   eval "ac_cv_func_$ac_func=yes"
9721 else
9722   echo "configure: failed program was:" >&5
9723   cat conftest.$ac_ext >&5
9724   rm -rf conftest*
9725   eval "ac_cv_func_$ac_func=no"
9726 fi
9727 rm -f conftest*
9728 fi
9729
9730 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9731   echo "$ac_t""yes" 1>&6
9732     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9733   cat >> confdefs.h <<EOF
9734 #define $ac_tr_func 1
9735 EOF
9736
9737 else
9738   echo "$ac_t""no" 1>&6
9739 fi
9740 done
9741
9742   fi
9743
9744
9745   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9746 echo "configure:9747: checking for logl declaration" >&5
9747   if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
9748   echo $ac_n "(cached) $ac_c" 1>&6
9749 else
9750
9751
9752     ac_ext=C
9753 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9754 ac_cpp='$CXXCPP $CPPFLAGS'
9755 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9756 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9757 cross_compiling=$ac_cv_prog_cxx_cross
9758
9759     cat > conftest.$ac_ext <<EOF
9760 #line 9761 "configure"
9761 #include "confdefs.h"
9762 #include <math.h>
9763 int main() {
9764  logl(0);
9765 ; return 0; }
9766 EOF
9767 if { (eval echo configure:9768: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9768   rm -rf conftest*
9769   glibcpp_cv_func_logl_use=yes
9770 else
9771   echo "configure: failed program was:" >&5
9772   cat conftest.$ac_ext >&5
9773   rm -rf conftest*
9774   glibcpp_cv_func_logl_use=no
9775 fi
9776 rm -f conftest*
9777     ac_ext=c
9778 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9779 ac_cpp='$CPP $CPPFLAGS'
9780 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9781 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9782 cross_compiling=$ac_cv_prog_cc_cross
9783
9784
9785 fi
9786
9787   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
9788   if test x$glibcpp_cv_func_logl_use = x"yes"; then
9789     for ac_func in logl
9790 do
9791 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9792 echo "configure:9793: checking for $ac_func" >&5
9793 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9794   echo $ac_n "(cached) $ac_c" 1>&6
9795 else
9796   cat > conftest.$ac_ext <<EOF
9797 #line 9798 "configure"
9798 #include "confdefs.h"
9799 /* System header to define __stub macros and hopefully few prototypes,
9800     which can conflict with char $ac_func(); below.  */
9801 #include <assert.h>
9802 /* Override any gcc2 internal prototype to avoid an error.  */
9803 /* We use char because int might match the return type of a gcc2
9804     builtin and then its argument prototype would still apply.  */
9805 char $ac_func();
9806
9807 int main() {
9808
9809 /* The GNU C library defines this for functions which it implements
9810     to always fail with ENOSYS.  Some functions are actually named
9811     something starting with __ and the normal name is an alias.  */
9812 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9813 choke me
9814 #else
9815 $ac_func();
9816 #endif
9817
9818 ; return 0; }
9819 EOF
9820 if { (eval echo configure:9821: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9821   rm -rf conftest*
9822   eval "ac_cv_func_$ac_func=yes"
9823 else
9824   echo "configure: failed program was:" >&5
9825   cat conftest.$ac_ext >&5
9826   rm -rf conftest*
9827   eval "ac_cv_func_$ac_func=no"
9828 fi
9829 rm -f conftest*
9830 fi
9831
9832 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9833   echo "$ac_t""yes" 1>&6
9834     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9835   cat >> confdefs.h <<EOF
9836 #define $ac_tr_func 1
9837 EOF
9838
9839 else
9840   echo "$ac_t""no" 1>&6
9841 fi
9842 done
9843
9844   fi
9845
9846
9847   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9848 echo "configure:9849: checking for log10l declaration" >&5
9849   if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
9850   echo $ac_n "(cached) $ac_c" 1>&6
9851 else
9852
9853
9854     ac_ext=C
9855 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9856 ac_cpp='$CXXCPP $CPPFLAGS'
9857 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9858 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9859 cross_compiling=$ac_cv_prog_cxx_cross
9860
9861     cat > conftest.$ac_ext <<EOF
9862 #line 9863 "configure"
9863 #include "confdefs.h"
9864 #include <math.h>
9865 int main() {
9866  log10l(0);
9867 ; return 0; }
9868 EOF
9869 if { (eval echo configure:9870: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9870   rm -rf conftest*
9871   glibcpp_cv_func_log10l_use=yes
9872 else
9873   echo "configure: failed program was:" >&5
9874   cat conftest.$ac_ext >&5
9875   rm -rf conftest*
9876   glibcpp_cv_func_log10l_use=no
9877 fi
9878 rm -f conftest*
9879     ac_ext=c
9880 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9881 ac_cpp='$CPP $CPPFLAGS'
9882 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9883 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9884 cross_compiling=$ac_cv_prog_cc_cross
9885
9886
9887 fi
9888
9889   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
9890   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
9891     for ac_func in log10l
9892 do
9893 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9894 echo "configure:9895: checking for $ac_func" >&5
9895 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9896   echo $ac_n "(cached) $ac_c" 1>&6
9897 else
9898   cat > conftest.$ac_ext <<EOF
9899 #line 9900 "configure"
9900 #include "confdefs.h"
9901 /* System header to define __stub macros and hopefully few prototypes,
9902     which can conflict with char $ac_func(); below.  */
9903 #include <assert.h>
9904 /* Override any gcc2 internal prototype to avoid an error.  */
9905 /* We use char because int might match the return type of a gcc2
9906     builtin and then its argument prototype would still apply.  */
9907 char $ac_func();
9908
9909 int main() {
9910
9911 /* The GNU C library defines this for functions which it implements
9912     to always fail with ENOSYS.  Some functions are actually named
9913     something starting with __ and the normal name is an alias.  */
9914 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9915 choke me
9916 #else
9917 $ac_func();
9918 #endif
9919
9920 ; return 0; }
9921 EOF
9922 if { (eval echo configure:9923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9923   rm -rf conftest*
9924   eval "ac_cv_func_$ac_func=yes"
9925 else
9926   echo "configure: failed program was:" >&5
9927   cat conftest.$ac_ext >&5
9928   rm -rf conftest*
9929   eval "ac_cv_func_$ac_func=no"
9930 fi
9931 rm -f conftest*
9932 fi
9933
9934 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9935   echo "$ac_t""yes" 1>&6
9936     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9937   cat >> confdefs.h <<EOF
9938 #define $ac_tr_func 1
9939 EOF
9940
9941 else
9942   echo "$ac_t""no" 1>&6
9943 fi
9944 done
9945
9946   fi
9947
9948
9949   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
9950 echo "configure:9951: checking for modfl declaration" >&5
9951   if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
9952   echo $ac_n "(cached) $ac_c" 1>&6
9953 else
9954
9955
9956     ac_ext=C
9957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9958 ac_cpp='$CXXCPP $CPPFLAGS'
9959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9961 cross_compiling=$ac_cv_prog_cxx_cross
9962
9963     cat > conftest.$ac_ext <<EOF
9964 #line 9965 "configure"
9965 #include "confdefs.h"
9966 #include <math.h>
9967 int main() {
9968  modfl(0, 0);
9969 ; return 0; }
9970 EOF
9971 if { (eval echo configure:9972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9972   rm -rf conftest*
9973   glibcpp_cv_func_modfl_use=yes
9974 else
9975   echo "configure: failed program was:" >&5
9976   cat conftest.$ac_ext >&5
9977   rm -rf conftest*
9978   glibcpp_cv_func_modfl_use=no
9979 fi
9980 rm -f conftest*
9981     ac_ext=c
9982 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9983 ac_cpp='$CPP $CPPFLAGS'
9984 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9985 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9986 cross_compiling=$ac_cv_prog_cc_cross
9987
9988
9989 fi
9990
9991   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
9992   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
9993     for ac_func in modfl
9994 do
9995 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9996 echo "configure:9997: checking for $ac_func" >&5
9997 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9998   echo $ac_n "(cached) $ac_c" 1>&6
9999 else
10000   cat > conftest.$ac_ext <<EOF
10001 #line 10002 "configure"
10002 #include "confdefs.h"
10003 /* System header to define __stub macros and hopefully few prototypes,
10004     which can conflict with char $ac_func(); below.  */
10005 #include <assert.h>
10006 /* Override any gcc2 internal prototype to avoid an error.  */
10007 /* We use char because int might match the return type of a gcc2
10008     builtin and then its argument prototype would still apply.  */
10009 char $ac_func();
10010
10011 int main() {
10012
10013 /* The GNU C library defines this for functions which it implements
10014     to always fail with ENOSYS.  Some functions are actually named
10015     something starting with __ and the normal name is an alias.  */
10016 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10017 choke me
10018 #else
10019 $ac_func();
10020 #endif
10021
10022 ; return 0; }
10023 EOF
10024 if { (eval echo configure:10025: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10025   rm -rf conftest*
10026   eval "ac_cv_func_$ac_func=yes"
10027 else
10028   echo "configure: failed program was:" >&5
10029   cat conftest.$ac_ext >&5
10030   rm -rf conftest*
10031   eval "ac_cv_func_$ac_func=no"
10032 fi
10033 rm -f conftest*
10034 fi
10035
10036 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10037   echo "$ac_t""yes" 1>&6
10038     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10039   cat >> confdefs.h <<EOF
10040 #define $ac_tr_func 1
10041 EOF
10042
10043 else
10044   echo "$ac_t""no" 1>&6
10045 fi
10046 done
10047
10048   fi
10049
10050
10051   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
10052 echo "configure:10053: checking for powl declaration" >&5
10053   if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
10054   echo $ac_n "(cached) $ac_c" 1>&6
10055 else
10056
10057
10058     ac_ext=C
10059 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10060 ac_cpp='$CXXCPP $CPPFLAGS'
10061 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10062 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10063 cross_compiling=$ac_cv_prog_cxx_cross
10064
10065     cat > conftest.$ac_ext <<EOF
10066 #line 10067 "configure"
10067 #include "confdefs.h"
10068 #include <math.h>
10069 int main() {
10070  powl(0, 0);
10071 ; return 0; }
10072 EOF
10073 if { (eval echo configure:10074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10074   rm -rf conftest*
10075   glibcpp_cv_func_powl_use=yes
10076 else
10077   echo "configure: failed program was:" >&5
10078   cat conftest.$ac_ext >&5
10079   rm -rf conftest*
10080   glibcpp_cv_func_powl_use=no
10081 fi
10082 rm -f conftest*
10083     ac_ext=c
10084 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10085 ac_cpp='$CPP $CPPFLAGS'
10086 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10087 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10088 cross_compiling=$ac_cv_prog_cc_cross
10089
10090
10091 fi
10092
10093   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
10094   if test x$glibcpp_cv_func_powl_use = x"yes"; then
10095     for ac_func in powl
10096 do
10097 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10098 echo "configure:10099: checking for $ac_func" >&5
10099 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10100   echo $ac_n "(cached) $ac_c" 1>&6
10101 else
10102   cat > conftest.$ac_ext <<EOF
10103 #line 10104 "configure"
10104 #include "confdefs.h"
10105 /* System header to define __stub macros and hopefully few prototypes,
10106     which can conflict with char $ac_func(); below.  */
10107 #include <assert.h>
10108 /* Override any gcc2 internal prototype to avoid an error.  */
10109 /* We use char because int might match the return type of a gcc2
10110     builtin and then its argument prototype would still apply.  */
10111 char $ac_func();
10112
10113 int main() {
10114
10115 /* The GNU C library defines this for functions which it implements
10116     to always fail with ENOSYS.  Some functions are actually named
10117     something starting with __ and the normal name is an alias.  */
10118 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10119 choke me
10120 #else
10121 $ac_func();
10122 #endif
10123
10124 ; return 0; }
10125 EOF
10126 if { (eval echo configure:10127: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10127   rm -rf conftest*
10128   eval "ac_cv_func_$ac_func=yes"
10129 else
10130   echo "configure: failed program was:" >&5
10131   cat conftest.$ac_ext >&5
10132   rm -rf conftest*
10133   eval "ac_cv_func_$ac_func=no"
10134 fi
10135 rm -f conftest*
10136 fi
10137
10138 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10139   echo "$ac_t""yes" 1>&6
10140     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10141   cat >> confdefs.h <<EOF
10142 #define $ac_tr_func 1
10143 EOF
10144
10145 else
10146   echo "$ac_t""no" 1>&6
10147 fi
10148 done
10149
10150   fi
10151
10152
10153   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
10154 echo "configure:10155: checking for sinl declaration" >&5
10155   if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
10156   echo $ac_n "(cached) $ac_c" 1>&6
10157 else
10158
10159
10160     ac_ext=C
10161 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10162 ac_cpp='$CXXCPP $CPPFLAGS'
10163 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10164 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10165 cross_compiling=$ac_cv_prog_cxx_cross
10166
10167     cat > conftest.$ac_ext <<EOF
10168 #line 10169 "configure"
10169 #include "confdefs.h"
10170 #include <math.h>
10171 int main() {
10172  sinl(0);
10173 ; return 0; }
10174 EOF
10175 if { (eval echo configure:10176: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10176   rm -rf conftest*
10177   glibcpp_cv_func_sinl_use=yes
10178 else
10179   echo "configure: failed program was:" >&5
10180   cat conftest.$ac_ext >&5
10181   rm -rf conftest*
10182   glibcpp_cv_func_sinl_use=no
10183 fi
10184 rm -f conftest*
10185     ac_ext=c
10186 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10187 ac_cpp='$CPP $CPPFLAGS'
10188 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10189 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10190 cross_compiling=$ac_cv_prog_cc_cross
10191
10192
10193 fi
10194
10195   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
10196   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
10197     for ac_func in sinl
10198 do
10199 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10200 echo "configure:10201: checking for $ac_func" >&5
10201 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10202   echo $ac_n "(cached) $ac_c" 1>&6
10203 else
10204   cat > conftest.$ac_ext <<EOF
10205 #line 10206 "configure"
10206 #include "confdefs.h"
10207 /* System header to define __stub macros and hopefully few prototypes,
10208     which can conflict with char $ac_func(); below.  */
10209 #include <assert.h>
10210 /* Override any gcc2 internal prototype to avoid an error.  */
10211 /* We use char because int might match the return type of a gcc2
10212     builtin and then its argument prototype would still apply.  */
10213 char $ac_func();
10214
10215 int main() {
10216
10217 /* The GNU C library defines this for functions which it implements
10218     to always fail with ENOSYS.  Some functions are actually named
10219     something starting with __ and the normal name is an alias.  */
10220 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10221 choke me
10222 #else
10223 $ac_func();
10224 #endif
10225
10226 ; return 0; }
10227 EOF
10228 if { (eval echo configure:10229: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10229   rm -rf conftest*
10230   eval "ac_cv_func_$ac_func=yes"
10231 else
10232   echo "configure: failed program was:" >&5
10233   cat conftest.$ac_ext >&5
10234   rm -rf conftest*
10235   eval "ac_cv_func_$ac_func=no"
10236 fi
10237 rm -f conftest*
10238 fi
10239
10240 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10241   echo "$ac_t""yes" 1>&6
10242     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10243   cat >> confdefs.h <<EOF
10244 #define $ac_tr_func 1
10245 EOF
10246
10247 else
10248   echo "$ac_t""no" 1>&6
10249 fi
10250 done
10251
10252   fi
10253
10254
10255   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
10256 echo "configure:10257: checking for sinhl declaration" >&5
10257   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
10258   echo $ac_n "(cached) $ac_c" 1>&6
10259 else
10260
10261
10262     ac_ext=C
10263 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10264 ac_cpp='$CXXCPP $CPPFLAGS'
10265 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10266 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10267 cross_compiling=$ac_cv_prog_cxx_cross
10268
10269     cat > conftest.$ac_ext <<EOF
10270 #line 10271 "configure"
10271 #include "confdefs.h"
10272 #include <math.h>
10273 int main() {
10274  sinhl(0);
10275 ; return 0; }
10276 EOF
10277 if { (eval echo configure:10278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10278   rm -rf conftest*
10279   glibcpp_cv_func_sinhl_use=yes
10280 else
10281   echo "configure: failed program was:" >&5
10282   cat conftest.$ac_ext >&5
10283   rm -rf conftest*
10284   glibcpp_cv_func_sinhl_use=no
10285 fi
10286 rm -f conftest*
10287     ac_ext=c
10288 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10289 ac_cpp='$CPP $CPPFLAGS'
10290 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10291 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10292 cross_compiling=$ac_cv_prog_cc_cross
10293
10294
10295 fi
10296
10297   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
10298   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
10299     for ac_func in sinhl
10300 do
10301 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10302 echo "configure:10303: checking for $ac_func" >&5
10303 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10304   echo $ac_n "(cached) $ac_c" 1>&6
10305 else
10306   cat > conftest.$ac_ext <<EOF
10307 #line 10308 "configure"
10308 #include "confdefs.h"
10309 /* System header to define __stub macros and hopefully few prototypes,
10310     which can conflict with char $ac_func(); below.  */
10311 #include <assert.h>
10312 /* Override any gcc2 internal prototype to avoid an error.  */
10313 /* We use char because int might match the return type of a gcc2
10314     builtin and then its argument prototype would still apply.  */
10315 char $ac_func();
10316
10317 int main() {
10318
10319 /* The GNU C library defines this for functions which it implements
10320     to always fail with ENOSYS.  Some functions are actually named
10321     something starting with __ and the normal name is an alias.  */
10322 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10323 choke me
10324 #else
10325 $ac_func();
10326 #endif
10327
10328 ; return 0; }
10329 EOF
10330 if { (eval echo configure:10331: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10331   rm -rf conftest*
10332   eval "ac_cv_func_$ac_func=yes"
10333 else
10334   echo "configure: failed program was:" >&5
10335   cat conftest.$ac_ext >&5
10336   rm -rf conftest*
10337   eval "ac_cv_func_$ac_func=no"
10338 fi
10339 rm -f conftest*
10340 fi
10341
10342 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10343   echo "$ac_t""yes" 1>&6
10344     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10345   cat >> confdefs.h <<EOF
10346 #define $ac_tr_func 1
10347 EOF
10348
10349 else
10350   echo "$ac_t""no" 1>&6
10351 fi
10352 done
10353
10354   fi
10355
10356
10357   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
10358 echo "configure:10359: checking for sqrtl declaration" >&5
10359   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
10360   echo $ac_n "(cached) $ac_c" 1>&6
10361 else
10362
10363
10364     ac_ext=C
10365 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10366 ac_cpp='$CXXCPP $CPPFLAGS'
10367 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10368 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10369 cross_compiling=$ac_cv_prog_cxx_cross
10370
10371     cat > conftest.$ac_ext <<EOF
10372 #line 10373 "configure"
10373 #include "confdefs.h"
10374 #include <math.h>
10375 int main() {
10376  sqrtl(0);
10377 ; return 0; }
10378 EOF
10379 if { (eval echo configure:10380: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10380   rm -rf conftest*
10381   glibcpp_cv_func_sqrtl_use=yes
10382 else
10383   echo "configure: failed program was:" >&5
10384   cat conftest.$ac_ext >&5
10385   rm -rf conftest*
10386   glibcpp_cv_func_sqrtl_use=no
10387 fi
10388 rm -f conftest*
10389     ac_ext=c
10390 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10391 ac_cpp='$CPP $CPPFLAGS'
10392 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10393 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10394 cross_compiling=$ac_cv_prog_cc_cross
10395
10396
10397 fi
10398
10399   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
10400   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
10401     for ac_func in sqrtl
10402 do
10403 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10404 echo "configure:10405: checking for $ac_func" >&5
10405 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10406   echo $ac_n "(cached) $ac_c" 1>&6
10407 else
10408   cat > conftest.$ac_ext <<EOF
10409 #line 10410 "configure"
10410 #include "confdefs.h"
10411 /* System header to define __stub macros and hopefully few prototypes,
10412     which can conflict with char $ac_func(); below.  */
10413 #include <assert.h>
10414 /* Override any gcc2 internal prototype to avoid an error.  */
10415 /* We use char because int might match the return type of a gcc2
10416     builtin and then its argument prototype would still apply.  */
10417 char $ac_func();
10418
10419 int main() {
10420
10421 /* The GNU C library defines this for functions which it implements
10422     to always fail with ENOSYS.  Some functions are actually named
10423     something starting with __ and the normal name is an alias.  */
10424 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10425 choke me
10426 #else
10427 $ac_func();
10428 #endif
10429
10430 ; return 0; }
10431 EOF
10432 if { (eval echo configure:10433: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10433   rm -rf conftest*
10434   eval "ac_cv_func_$ac_func=yes"
10435 else
10436   echo "configure: failed program was:" >&5
10437   cat conftest.$ac_ext >&5
10438   rm -rf conftest*
10439   eval "ac_cv_func_$ac_func=no"
10440 fi
10441 rm -f conftest*
10442 fi
10443
10444 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10445   echo "$ac_t""yes" 1>&6
10446     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10447   cat >> confdefs.h <<EOF
10448 #define $ac_tr_func 1
10449 EOF
10450
10451 else
10452   echo "$ac_t""no" 1>&6
10453 fi
10454 done
10455
10456   fi
10457
10458
10459   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
10460 echo "configure:10461: checking for tanl declaration" >&5
10461   if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
10462   echo $ac_n "(cached) $ac_c" 1>&6
10463 else
10464
10465
10466     ac_ext=C
10467 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10468 ac_cpp='$CXXCPP $CPPFLAGS'
10469 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10470 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10471 cross_compiling=$ac_cv_prog_cxx_cross
10472
10473     cat > conftest.$ac_ext <<EOF
10474 #line 10475 "configure"
10475 #include "confdefs.h"
10476 #include <math.h>
10477 int main() {
10478  tanl(0);
10479 ; return 0; }
10480 EOF
10481 if { (eval echo configure:10482: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10482   rm -rf conftest*
10483   glibcpp_cv_func_tanl_use=yes
10484 else
10485   echo "configure: failed program was:" >&5
10486   cat conftest.$ac_ext >&5
10487   rm -rf conftest*
10488   glibcpp_cv_func_tanl_use=no
10489 fi
10490 rm -f conftest*
10491     ac_ext=c
10492 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10493 ac_cpp='$CPP $CPPFLAGS'
10494 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10495 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10496 cross_compiling=$ac_cv_prog_cc_cross
10497
10498
10499 fi
10500
10501   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
10502   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
10503     for ac_func in tanl
10504 do
10505 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10506 echo "configure:10507: checking for $ac_func" >&5
10507 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10508   echo $ac_n "(cached) $ac_c" 1>&6
10509 else
10510   cat > conftest.$ac_ext <<EOF
10511 #line 10512 "configure"
10512 #include "confdefs.h"
10513 /* System header to define __stub macros and hopefully few prototypes,
10514     which can conflict with char $ac_func(); below.  */
10515 #include <assert.h>
10516 /* Override any gcc2 internal prototype to avoid an error.  */
10517 /* We use char because int might match the return type of a gcc2
10518     builtin and then its argument prototype would still apply.  */
10519 char $ac_func();
10520
10521 int main() {
10522
10523 /* The GNU C library defines this for functions which it implements
10524     to always fail with ENOSYS.  Some functions are actually named
10525     something starting with __ and the normal name is an alias.  */
10526 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10527 choke me
10528 #else
10529 $ac_func();
10530 #endif
10531
10532 ; return 0; }
10533 EOF
10534 if { (eval echo configure:10535: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10535   rm -rf conftest*
10536   eval "ac_cv_func_$ac_func=yes"
10537 else
10538   echo "configure: failed program was:" >&5
10539   cat conftest.$ac_ext >&5
10540   rm -rf conftest*
10541   eval "ac_cv_func_$ac_func=no"
10542 fi
10543 rm -f conftest*
10544 fi
10545
10546 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10547   echo "$ac_t""yes" 1>&6
10548     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10549   cat >> confdefs.h <<EOF
10550 #define $ac_tr_func 1
10551 EOF
10552
10553 else
10554   echo "$ac_t""no" 1>&6
10555 fi
10556 done
10557
10558   fi
10559
10560
10561   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
10562 echo "configure:10563: checking for tanhl declaration" >&5
10563   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
10564   echo $ac_n "(cached) $ac_c" 1>&6
10565 else
10566
10567
10568     ac_ext=C
10569 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10570 ac_cpp='$CXXCPP $CPPFLAGS'
10571 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10572 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10573 cross_compiling=$ac_cv_prog_cxx_cross
10574
10575     cat > conftest.$ac_ext <<EOF
10576 #line 10577 "configure"
10577 #include "confdefs.h"
10578 #include <math.h>
10579 int main() {
10580  tanhl(0);
10581 ; return 0; }
10582 EOF
10583 if { (eval echo configure:10584: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10584   rm -rf conftest*
10585   glibcpp_cv_func_tanhl_use=yes
10586 else
10587   echo "configure: failed program was:" >&5
10588   cat conftest.$ac_ext >&5
10589   rm -rf conftest*
10590   glibcpp_cv_func_tanhl_use=no
10591 fi
10592 rm -f conftest*
10593     ac_ext=c
10594 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10595 ac_cpp='$CPP $CPPFLAGS'
10596 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10597 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10598 cross_compiling=$ac_cv_prog_cc_cross
10599
10600
10601 fi
10602
10603   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
10604   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
10605     for ac_func in tanhl
10606 do
10607 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10608 echo "configure:10609: checking for $ac_func" >&5
10609 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10610   echo $ac_n "(cached) $ac_c" 1>&6
10611 else
10612   cat > conftest.$ac_ext <<EOF
10613 #line 10614 "configure"
10614 #include "confdefs.h"
10615 /* System header to define __stub macros and hopefully few prototypes,
10616     which can conflict with char $ac_func(); below.  */
10617 #include <assert.h>
10618 /* Override any gcc2 internal prototype to avoid an error.  */
10619 /* We use char because int might match the return type of a gcc2
10620     builtin and then its argument prototype would still apply.  */
10621 char $ac_func();
10622
10623 int main() {
10624
10625 /* The GNU C library defines this for functions which it implements
10626     to always fail with ENOSYS.  Some functions are actually named
10627     something starting with __ and the normal name is an alias.  */
10628 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10629 choke me
10630 #else
10631 $ac_func();
10632 #endif
10633
10634 ; return 0; }
10635 EOF
10636 if { (eval echo configure:10637: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10637   rm -rf conftest*
10638   eval "ac_cv_func_$ac_func=yes"
10639 else
10640   echo "configure: failed program was:" >&5
10641   cat conftest.$ac_ext >&5
10642   rm -rf conftest*
10643   eval "ac_cv_func_$ac_func=no"
10644 fi
10645 rm -f conftest*
10646 fi
10647
10648 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10649   echo "$ac_t""yes" 1>&6
10650     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10651   cat >> confdefs.h <<EOF
10652 #define $ac_tr_func 1
10653 EOF
10654
10655 else
10656   echo "$ac_t""no" 1>&6
10657 fi
10658 done
10659
10660   fi
10661
10662
10663   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
10664 echo "configure:10665: checking for sincosl declaration" >&5
10665   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
10666   echo $ac_n "(cached) $ac_c" 1>&6
10667 else
10668
10669
10670     ac_ext=C
10671 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10672 ac_cpp='$CXXCPP $CPPFLAGS'
10673 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10674 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10675 cross_compiling=$ac_cv_prog_cxx_cross
10676
10677     cat > conftest.$ac_ext <<EOF
10678 #line 10679 "configure"
10679 #include "confdefs.h"
10680 #include <math.h>
10681 int main() {
10682  sincosl(0, 0, 0);
10683 ; return 0; }
10684 EOF
10685 if { (eval echo configure:10686: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10686   rm -rf conftest*
10687   glibcpp_cv_func_sincosl_use=yes
10688 else
10689   echo "configure: failed program was:" >&5
10690   cat conftest.$ac_ext >&5
10691   rm -rf conftest*
10692   glibcpp_cv_func_sincosl_use=no
10693 fi
10694 rm -f conftest*
10695     ac_ext=c
10696 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10697 ac_cpp='$CPP $CPPFLAGS'
10698 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10699 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10700 cross_compiling=$ac_cv_prog_cc_cross
10701
10702
10703 fi
10704
10705   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
10706   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
10707     for ac_func in sincosl
10708 do
10709 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10710 echo "configure:10711: checking for $ac_func" >&5
10711 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10712   echo $ac_n "(cached) $ac_c" 1>&6
10713 else
10714   cat > conftest.$ac_ext <<EOF
10715 #line 10716 "configure"
10716 #include "confdefs.h"
10717 /* System header to define __stub macros and hopefully few prototypes,
10718     which can conflict with char $ac_func(); below.  */
10719 #include <assert.h>
10720 /* Override any gcc2 internal prototype to avoid an error.  */
10721 /* We use char because int might match the return type of a gcc2
10722     builtin and then its argument prototype would still apply.  */
10723 char $ac_func();
10724
10725 int main() {
10726
10727 /* The GNU C library defines this for functions which it implements
10728     to always fail with ENOSYS.  Some functions are actually named
10729     something starting with __ and the normal name is an alias.  */
10730 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10731 choke me
10732 #else
10733 $ac_func();
10734 #endif
10735
10736 ; return 0; }
10737 EOF
10738 if { (eval echo configure:10739: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10739   rm -rf conftest*
10740   eval "ac_cv_func_$ac_func=yes"
10741 else
10742   echo "configure: failed program was:" >&5
10743   cat conftest.$ac_ext >&5
10744   rm -rf conftest*
10745   eval "ac_cv_func_$ac_func=no"
10746 fi
10747 rm -f conftest*
10748 fi
10749
10750 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10751   echo "$ac_t""yes" 1>&6
10752     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10753   cat >> confdefs.h <<EOF
10754 #define $ac_tr_func 1
10755 EOF
10756
10757 else
10758   echo "$ac_t""no" 1>&6
10759 fi
10760 done
10761
10762   fi
10763
10764
10765   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10766 echo "configure:10767: checking for finitel declaration" >&5
10767   if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
10768   echo $ac_n "(cached) $ac_c" 1>&6
10769 else
10770
10771
10772     ac_ext=C
10773 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10774 ac_cpp='$CXXCPP $CPPFLAGS'
10775 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10776 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10777 cross_compiling=$ac_cv_prog_cxx_cross
10778
10779     cat > conftest.$ac_ext <<EOF
10780 #line 10781 "configure"
10781 #include "confdefs.h"
10782 #include <math.h>
10783 int main() {
10784  finitel(0);
10785 ; return 0; }
10786 EOF
10787 if { (eval echo configure:10788: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10788   rm -rf conftest*
10789   glibcpp_cv_func_finitel_use=yes
10790 else
10791   echo "configure: failed program was:" >&5
10792   cat conftest.$ac_ext >&5
10793   rm -rf conftest*
10794   glibcpp_cv_func_finitel_use=no
10795 fi
10796 rm -f conftest*
10797     ac_ext=c
10798 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10799 ac_cpp='$CPP $CPPFLAGS'
10800 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10801 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10802 cross_compiling=$ac_cv_prog_cc_cross
10803
10804
10805 fi
10806
10807   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
10808   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
10809     for ac_func in finitel
10810 do
10811 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10812 echo "configure:10813: checking for $ac_func" >&5
10813 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10814   echo $ac_n "(cached) $ac_c" 1>&6
10815 else
10816   cat > conftest.$ac_ext <<EOF
10817 #line 10818 "configure"
10818 #include "confdefs.h"
10819 /* System header to define __stub macros and hopefully few prototypes,
10820     which can conflict with char $ac_func(); below.  */
10821 #include <assert.h>
10822 /* Override any gcc2 internal prototype to avoid an error.  */
10823 /* We use char because int might match the return type of a gcc2
10824     builtin and then its argument prototype would still apply.  */
10825 char $ac_func();
10826
10827 int main() {
10828
10829 /* The GNU C library defines this for functions which it implements
10830     to always fail with ENOSYS.  Some functions are actually named
10831     something starting with __ and the normal name is an alias.  */
10832 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10833 choke me
10834 #else
10835 $ac_func();
10836 #endif
10837
10838 ; return 0; }
10839 EOF
10840 if { (eval echo configure:10841: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10841   rm -rf conftest*
10842   eval "ac_cv_func_$ac_func=yes"
10843 else
10844   echo "configure: failed program was:" >&5
10845   cat conftest.$ac_ext >&5
10846   rm -rf conftest*
10847   eval "ac_cv_func_$ac_func=no"
10848 fi
10849 rm -f conftest*
10850 fi
10851
10852 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10853   echo "$ac_t""yes" 1>&6
10854     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10855   cat >> confdefs.h <<EOF
10856 #define $ac_tr_func 1
10857 EOF
10858
10859 else
10860   echo "$ac_t""no" 1>&6
10861 fi
10862 done
10863
10864   fi
10865
10866
10867
10868   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
10869 echo "configure:10870: checking for _isinf declaration" >&5
10870   if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
10871   echo $ac_n "(cached) $ac_c" 1>&6
10872 else
10873
10874
10875     ac_ext=C
10876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10877 ac_cpp='$CXXCPP $CPPFLAGS'
10878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10880 cross_compiling=$ac_cv_prog_cxx_cross
10881
10882     cat > conftest.$ac_ext <<EOF
10883 #line 10884 "configure"
10884 #include "confdefs.h"
10885 #include <math.h>
10886 int main() {
10887  _isinf(0);
10888 ; return 0; }
10889 EOF
10890 if { (eval echo configure:10891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10891   rm -rf conftest*
10892   glibcpp_cv_func__isinf_use=yes
10893 else
10894   echo "configure: failed program was:" >&5
10895   cat conftest.$ac_ext >&5
10896   rm -rf conftest*
10897   glibcpp_cv_func__isinf_use=no
10898 fi
10899 rm -f conftest*
10900     ac_ext=c
10901 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10902 ac_cpp='$CPP $CPPFLAGS'
10903 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10904 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10905 cross_compiling=$ac_cv_prog_cc_cross
10906
10907
10908 fi
10909
10910   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
10911   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
10912     for ac_func in _isinf
10913 do
10914 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10915 echo "configure:10916: checking for $ac_func" >&5
10916 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10917   echo $ac_n "(cached) $ac_c" 1>&6
10918 else
10919   cat > conftest.$ac_ext <<EOF
10920 #line 10921 "configure"
10921 #include "confdefs.h"
10922 /* System header to define __stub macros and hopefully few prototypes,
10923     which can conflict with char $ac_func(); below.  */
10924 #include <assert.h>
10925 /* Override any gcc2 internal prototype to avoid an error.  */
10926 /* We use char because int might match the return type of a gcc2
10927     builtin and then its argument prototype would still apply.  */
10928 char $ac_func();
10929
10930 int main() {
10931
10932 /* The GNU C library defines this for functions which it implements
10933     to always fail with ENOSYS.  Some functions are actually named
10934     something starting with __ and the normal name is an alias.  */
10935 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10936 choke me
10937 #else
10938 $ac_func();
10939 #endif
10940
10941 ; return 0; }
10942 EOF
10943 if { (eval echo configure:10944: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10944   rm -rf conftest*
10945   eval "ac_cv_func_$ac_func=yes"
10946 else
10947   echo "configure: failed program was:" >&5
10948   cat conftest.$ac_ext >&5
10949   rm -rf conftest*
10950   eval "ac_cv_func_$ac_func=no"
10951 fi
10952 rm -f conftest*
10953 fi
10954
10955 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10956   echo "$ac_t""yes" 1>&6
10957     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10958   cat >> confdefs.h <<EOF
10959 #define $ac_tr_func 1
10960 EOF
10961
10962 else
10963   echo "$ac_t""no" 1>&6
10964 fi
10965 done
10966
10967   fi
10968
10969
10970   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
10971 echo "configure:10972: checking for _isnan declaration" >&5
10972   if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
10973   echo $ac_n "(cached) $ac_c" 1>&6
10974 else
10975
10976
10977     ac_ext=C
10978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10979 ac_cpp='$CXXCPP $CPPFLAGS'
10980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10982 cross_compiling=$ac_cv_prog_cxx_cross
10983
10984     cat > conftest.$ac_ext <<EOF
10985 #line 10986 "configure"
10986 #include "confdefs.h"
10987 #include <math.h>
10988 int main() {
10989  _isnan(0);
10990 ; return 0; }
10991 EOF
10992 if { (eval echo configure:10993: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10993   rm -rf conftest*
10994   glibcpp_cv_func__isnan_use=yes
10995 else
10996   echo "configure: failed program was:" >&5
10997   cat conftest.$ac_ext >&5
10998   rm -rf conftest*
10999   glibcpp_cv_func__isnan_use=no
11000 fi
11001 rm -f conftest*
11002     ac_ext=c
11003 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11004 ac_cpp='$CPP $CPPFLAGS'
11005 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11006 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11007 cross_compiling=$ac_cv_prog_cc_cross
11008
11009
11010 fi
11011
11012   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
11013   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
11014     for ac_func in _isnan
11015 do
11016 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11017 echo "configure:11018: checking for $ac_func" >&5
11018 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11019   echo $ac_n "(cached) $ac_c" 1>&6
11020 else
11021   cat > conftest.$ac_ext <<EOF
11022 #line 11023 "configure"
11023 #include "confdefs.h"
11024 /* System header to define __stub macros and hopefully few prototypes,
11025     which can conflict with char $ac_func(); below.  */
11026 #include <assert.h>
11027 /* Override any gcc2 internal prototype to avoid an error.  */
11028 /* We use char because int might match the return type of a gcc2
11029     builtin and then its argument prototype would still apply.  */
11030 char $ac_func();
11031
11032 int main() {
11033
11034 /* The GNU C library defines this for functions which it implements
11035     to always fail with ENOSYS.  Some functions are actually named
11036     something starting with __ and the normal name is an alias.  */
11037 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11038 choke me
11039 #else
11040 $ac_func();
11041 #endif
11042
11043 ; return 0; }
11044 EOF
11045 if { (eval echo configure:11046: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11046   rm -rf conftest*
11047   eval "ac_cv_func_$ac_func=yes"
11048 else
11049   echo "configure: failed program was:" >&5
11050   cat conftest.$ac_ext >&5
11051   rm -rf conftest*
11052   eval "ac_cv_func_$ac_func=no"
11053 fi
11054 rm -f conftest*
11055 fi
11056
11057 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11058   echo "$ac_t""yes" 1>&6
11059     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11060   cat >> confdefs.h <<EOF
11061 #define $ac_tr_func 1
11062 EOF
11063
11064 else
11065   echo "$ac_t""no" 1>&6
11066 fi
11067 done
11068
11069   fi
11070
11071
11072   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
11073 echo "configure:11074: checking for _finite declaration" >&5
11074   if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
11075   echo $ac_n "(cached) $ac_c" 1>&6
11076 else
11077
11078
11079     ac_ext=C
11080 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11081 ac_cpp='$CXXCPP $CPPFLAGS'
11082 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11083 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11084 cross_compiling=$ac_cv_prog_cxx_cross
11085
11086     cat > conftest.$ac_ext <<EOF
11087 #line 11088 "configure"
11088 #include "confdefs.h"
11089 #include <math.h>
11090 int main() {
11091  _finite(0);
11092 ; return 0; }
11093 EOF
11094 if { (eval echo configure:11095: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11095   rm -rf conftest*
11096   glibcpp_cv_func__finite_use=yes
11097 else
11098   echo "configure: failed program was:" >&5
11099   cat conftest.$ac_ext >&5
11100   rm -rf conftest*
11101   glibcpp_cv_func__finite_use=no
11102 fi
11103 rm -f conftest*
11104     ac_ext=c
11105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11106 ac_cpp='$CPP $CPPFLAGS'
11107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11109 cross_compiling=$ac_cv_prog_cc_cross
11110
11111
11112 fi
11113
11114   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
11115   if test x$glibcpp_cv_func__finite_use = x"yes"; then
11116     for ac_func in _finite
11117 do
11118 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11119 echo "configure:11120: checking for $ac_func" >&5
11120 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11121   echo $ac_n "(cached) $ac_c" 1>&6
11122 else
11123   cat > conftest.$ac_ext <<EOF
11124 #line 11125 "configure"
11125 #include "confdefs.h"
11126 /* System header to define __stub macros and hopefully few prototypes,
11127     which can conflict with char $ac_func(); below.  */
11128 #include <assert.h>
11129 /* Override any gcc2 internal prototype to avoid an error.  */
11130 /* We use char because int might match the return type of a gcc2
11131     builtin and then its argument prototype would still apply.  */
11132 char $ac_func();
11133
11134 int main() {
11135
11136 /* The GNU C library defines this for functions which it implements
11137     to always fail with ENOSYS.  Some functions are actually named
11138     something starting with __ and the normal name is an alias.  */
11139 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11140 choke me
11141 #else
11142 $ac_func();
11143 #endif
11144
11145 ; return 0; }
11146 EOF
11147 if { (eval echo configure:11148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11148   rm -rf conftest*
11149   eval "ac_cv_func_$ac_func=yes"
11150 else
11151   echo "configure: failed program was:" >&5
11152   cat conftest.$ac_ext >&5
11153   rm -rf conftest*
11154   eval "ac_cv_func_$ac_func=no"
11155 fi
11156 rm -f conftest*
11157 fi
11158
11159 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11160   echo "$ac_t""yes" 1>&6
11161     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11162   cat >> confdefs.h <<EOF
11163 #define $ac_tr_func 1
11164 EOF
11165
11166 else
11167   echo "$ac_t""no" 1>&6
11168 fi
11169 done
11170
11171   fi
11172
11173
11174   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
11175 echo "configure:11176: checking for _copysign declaration" >&5
11176   if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
11177   echo $ac_n "(cached) $ac_c" 1>&6
11178 else
11179
11180
11181     ac_ext=C
11182 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11183 ac_cpp='$CXXCPP $CPPFLAGS'
11184 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11185 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11186 cross_compiling=$ac_cv_prog_cxx_cross
11187
11188     cat > conftest.$ac_ext <<EOF
11189 #line 11190 "configure"
11190 #include "confdefs.h"
11191 #include <math.h>
11192 int main() {
11193  _copysign(0, 0);
11194 ; return 0; }
11195 EOF
11196 if { (eval echo configure:11197: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11197   rm -rf conftest*
11198   glibcpp_cv_func__copysign_use=yes
11199 else
11200   echo "configure: failed program was:" >&5
11201   cat conftest.$ac_ext >&5
11202   rm -rf conftest*
11203   glibcpp_cv_func__copysign_use=no
11204 fi
11205 rm -f conftest*
11206     ac_ext=c
11207 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11208 ac_cpp='$CPP $CPPFLAGS'
11209 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11210 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11211 cross_compiling=$ac_cv_prog_cc_cross
11212
11213
11214 fi
11215
11216   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
11217   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
11218     for ac_func in _copysign
11219 do
11220 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11221 echo "configure:11222: checking for $ac_func" >&5
11222 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11223   echo $ac_n "(cached) $ac_c" 1>&6
11224 else
11225   cat > conftest.$ac_ext <<EOF
11226 #line 11227 "configure"
11227 #include "confdefs.h"
11228 /* System header to define __stub macros and hopefully few prototypes,
11229     which can conflict with char $ac_func(); below.  */
11230 #include <assert.h>
11231 /* Override any gcc2 internal prototype to avoid an error.  */
11232 /* We use char because int might match the return type of a gcc2
11233     builtin and then its argument prototype would still apply.  */
11234 char $ac_func();
11235
11236 int main() {
11237
11238 /* The GNU C library defines this for functions which it implements
11239     to always fail with ENOSYS.  Some functions are actually named
11240     something starting with __ and the normal name is an alias.  */
11241 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11242 choke me
11243 #else
11244 $ac_func();
11245 #endif
11246
11247 ; return 0; }
11248 EOF
11249 if { (eval echo configure:11250: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11250   rm -rf conftest*
11251   eval "ac_cv_func_$ac_func=yes"
11252 else
11253   echo "configure: failed program was:" >&5
11254   cat conftest.$ac_ext >&5
11255   rm -rf conftest*
11256   eval "ac_cv_func_$ac_func=no"
11257 fi
11258 rm -f conftest*
11259 fi
11260
11261 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11262   echo "$ac_t""yes" 1>&6
11263     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11264   cat >> confdefs.h <<EOF
11265 #define $ac_tr_func 1
11266 EOF
11267
11268 else
11269   echo "$ac_t""no" 1>&6
11270 fi
11271 done
11272
11273   fi
11274
11275
11276   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
11277 echo "configure:11278: checking for _sincos declaration" >&5
11278   if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
11279   echo $ac_n "(cached) $ac_c" 1>&6
11280 else
11281
11282
11283     ac_ext=C
11284 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11285 ac_cpp='$CXXCPP $CPPFLAGS'
11286 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11287 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11288 cross_compiling=$ac_cv_prog_cxx_cross
11289
11290     cat > conftest.$ac_ext <<EOF
11291 #line 11292 "configure"
11292 #include "confdefs.h"
11293 #include <math.h>
11294 int main() {
11295  _sincos(0, 0, 0);
11296 ; return 0; }
11297 EOF
11298 if { (eval echo configure:11299: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11299   rm -rf conftest*
11300   glibcpp_cv_func__sincos_use=yes
11301 else
11302   echo "configure: failed program was:" >&5
11303   cat conftest.$ac_ext >&5
11304   rm -rf conftest*
11305   glibcpp_cv_func__sincos_use=no
11306 fi
11307 rm -f conftest*
11308     ac_ext=c
11309 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11310 ac_cpp='$CPP $CPPFLAGS'
11311 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11312 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11313 cross_compiling=$ac_cv_prog_cc_cross
11314
11315
11316 fi
11317
11318   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
11319   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
11320     for ac_func in _sincos
11321 do
11322 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11323 echo "configure:11324: checking for $ac_func" >&5
11324 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11325   echo $ac_n "(cached) $ac_c" 1>&6
11326 else
11327   cat > conftest.$ac_ext <<EOF
11328 #line 11329 "configure"
11329 #include "confdefs.h"
11330 /* System header to define __stub macros and hopefully few prototypes,
11331     which can conflict with char $ac_func(); below.  */
11332 #include <assert.h>
11333 /* Override any gcc2 internal prototype to avoid an error.  */
11334 /* We use char because int might match the return type of a gcc2
11335     builtin and then its argument prototype would still apply.  */
11336 char $ac_func();
11337
11338 int main() {
11339
11340 /* The GNU C library defines this for functions which it implements
11341     to always fail with ENOSYS.  Some functions are actually named
11342     something starting with __ and the normal name is an alias.  */
11343 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11344 choke me
11345 #else
11346 $ac_func();
11347 #endif
11348
11349 ; return 0; }
11350 EOF
11351 if { (eval echo configure:11352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11352   rm -rf conftest*
11353   eval "ac_cv_func_$ac_func=yes"
11354 else
11355   echo "configure: failed program was:" >&5
11356   cat conftest.$ac_ext >&5
11357   rm -rf conftest*
11358   eval "ac_cv_func_$ac_func=no"
11359 fi
11360 rm -f conftest*
11361 fi
11362
11363 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11364   echo "$ac_t""yes" 1>&6
11365     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11366   cat >> confdefs.h <<EOF
11367 #define $ac_tr_func 1
11368 EOF
11369
11370 else
11371   echo "$ac_t""no" 1>&6
11372 fi
11373 done
11374
11375   fi
11376
11377
11378   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
11379 echo "configure:11380: checking for _fpclass declaration" >&5
11380   if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
11381   echo $ac_n "(cached) $ac_c" 1>&6
11382 else
11383
11384
11385     ac_ext=C
11386 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11387 ac_cpp='$CXXCPP $CPPFLAGS'
11388 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11389 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11390 cross_compiling=$ac_cv_prog_cxx_cross
11391
11392     cat > conftest.$ac_ext <<EOF
11393 #line 11394 "configure"
11394 #include "confdefs.h"
11395 #include <math.h>
11396 int main() {
11397  _fpclass(0);
11398 ; return 0; }
11399 EOF
11400 if { (eval echo configure:11401: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11401   rm -rf conftest*
11402   glibcpp_cv_func__fpclass_use=yes
11403 else
11404   echo "configure: failed program was:" >&5
11405   cat conftest.$ac_ext >&5
11406   rm -rf conftest*
11407   glibcpp_cv_func__fpclass_use=no
11408 fi
11409 rm -f conftest*
11410     ac_ext=c
11411 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11412 ac_cpp='$CPP $CPPFLAGS'
11413 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11414 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11415 cross_compiling=$ac_cv_prog_cc_cross
11416
11417
11418 fi
11419
11420   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
11421   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
11422     for ac_func in _fpclass
11423 do
11424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11425 echo "configure:11426: checking for $ac_func" >&5
11426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11427   echo $ac_n "(cached) $ac_c" 1>&6
11428 else
11429   cat > conftest.$ac_ext <<EOF
11430 #line 11431 "configure"
11431 #include "confdefs.h"
11432 /* System header to define __stub macros and hopefully few prototypes,
11433     which can conflict with char $ac_func(); below.  */
11434 #include <assert.h>
11435 /* Override any gcc2 internal prototype to avoid an error.  */
11436 /* We use char because int might match the return type of a gcc2
11437     builtin and then its argument prototype would still apply.  */
11438 char $ac_func();
11439
11440 int main() {
11441
11442 /* The GNU C library defines this for functions which it implements
11443     to always fail with ENOSYS.  Some functions are actually named
11444     something starting with __ and the normal name is an alias.  */
11445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11446 choke me
11447 #else
11448 $ac_func();
11449 #endif
11450
11451 ; return 0; }
11452 EOF
11453 if { (eval echo configure:11454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11454   rm -rf conftest*
11455   eval "ac_cv_func_$ac_func=yes"
11456 else
11457   echo "configure: failed program was:" >&5
11458   cat conftest.$ac_ext >&5
11459   rm -rf conftest*
11460   eval "ac_cv_func_$ac_func=no"
11461 fi
11462 rm -f conftest*
11463 fi
11464
11465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11466   echo "$ac_t""yes" 1>&6
11467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11468   cat >> confdefs.h <<EOF
11469 #define $ac_tr_func 1
11470 EOF
11471
11472 else
11473   echo "$ac_t""no" 1>&6
11474 fi
11475 done
11476
11477   fi
11478
11479
11480   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
11481 echo "configure:11482: checking for _qfpclass declaration" >&5
11482   if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
11483   echo $ac_n "(cached) $ac_c" 1>&6
11484 else
11485
11486
11487     ac_ext=C
11488 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11489 ac_cpp='$CXXCPP $CPPFLAGS'
11490 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11491 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11492 cross_compiling=$ac_cv_prog_cxx_cross
11493
11494     cat > conftest.$ac_ext <<EOF
11495 #line 11496 "configure"
11496 #include "confdefs.h"
11497 #include <math.h>
11498 int main() {
11499  _qfpclass(0);
11500 ; return 0; }
11501 EOF
11502 if { (eval echo configure:11503: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11503   rm -rf conftest*
11504   glibcpp_cv_func__qfpclass_use=yes
11505 else
11506   echo "configure: failed program was:" >&5
11507   cat conftest.$ac_ext >&5
11508   rm -rf conftest*
11509   glibcpp_cv_func__qfpclass_use=no
11510 fi
11511 rm -f conftest*
11512     ac_ext=c
11513 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11514 ac_cpp='$CPP $CPPFLAGS'
11515 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11516 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11517 cross_compiling=$ac_cv_prog_cc_cross
11518
11519
11520 fi
11521
11522   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
11523   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
11524     for ac_func in _qfpclass
11525 do
11526 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11527 echo "configure:11528: checking for $ac_func" >&5
11528 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11529   echo $ac_n "(cached) $ac_c" 1>&6
11530 else
11531   cat > conftest.$ac_ext <<EOF
11532 #line 11533 "configure"
11533 #include "confdefs.h"
11534 /* System header to define __stub macros and hopefully few prototypes,
11535     which can conflict with char $ac_func(); below.  */
11536 #include <assert.h>
11537 /* Override any gcc2 internal prototype to avoid an error.  */
11538 /* We use char because int might match the return type of a gcc2
11539     builtin and then its argument prototype would still apply.  */
11540 char $ac_func();
11541
11542 int main() {
11543
11544 /* The GNU C library defines this for functions which it implements
11545     to always fail with ENOSYS.  Some functions are actually named
11546     something starting with __ and the normal name is an alias.  */
11547 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11548 choke me
11549 #else
11550 $ac_func();
11551 #endif
11552
11553 ; return 0; }
11554 EOF
11555 if { (eval echo configure:11556: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11556   rm -rf conftest*
11557   eval "ac_cv_func_$ac_func=yes"
11558 else
11559   echo "configure: failed program was:" >&5
11560   cat conftest.$ac_ext >&5
11561   rm -rf conftest*
11562   eval "ac_cv_func_$ac_func=no"
11563 fi
11564 rm -f conftest*
11565 fi
11566
11567 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11568   echo "$ac_t""yes" 1>&6
11569     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11570   cat >> confdefs.h <<EOF
11571 #define $ac_tr_func 1
11572 EOF
11573
11574 else
11575   echo "$ac_t""no" 1>&6
11576 fi
11577 done
11578
11579   fi
11580
11581
11582
11583   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11584 echo "configure:11585: checking for _isnanf declaration" >&5
11585   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
11586   echo $ac_n "(cached) $ac_c" 1>&6
11587 else
11588
11589
11590     ac_ext=C
11591 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11592 ac_cpp='$CXXCPP $CPPFLAGS'
11593 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11594 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11595 cross_compiling=$ac_cv_prog_cxx_cross
11596
11597     cat > conftest.$ac_ext <<EOF
11598 #line 11599 "configure"
11599 #include "confdefs.h"
11600 #include <math.h>
11601 int main() {
11602  _isnanf(0);
11603 ; return 0; }
11604 EOF
11605 if { (eval echo configure:11606: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11606   rm -rf conftest*
11607   glibcpp_cv_func__isnanf_use=yes
11608 else
11609   echo "configure: failed program was:" >&5
11610   cat conftest.$ac_ext >&5
11611   rm -rf conftest*
11612   glibcpp_cv_func__isnanf_use=no
11613 fi
11614 rm -f conftest*
11615     ac_ext=c
11616 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11617 ac_cpp='$CPP $CPPFLAGS'
11618 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11619 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11620 cross_compiling=$ac_cv_prog_cc_cross
11621
11622
11623 fi
11624
11625   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
11626   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
11627     for ac_func in _isnanf
11628 do
11629 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11630 echo "configure:11631: checking for $ac_func" >&5
11631 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11632   echo $ac_n "(cached) $ac_c" 1>&6
11633 else
11634   cat > conftest.$ac_ext <<EOF
11635 #line 11636 "configure"
11636 #include "confdefs.h"
11637 /* System header to define __stub macros and hopefully few prototypes,
11638     which can conflict with char $ac_func(); below.  */
11639 #include <assert.h>
11640 /* Override any gcc2 internal prototype to avoid an error.  */
11641 /* We use char because int might match the return type of a gcc2
11642     builtin and then its argument prototype would still apply.  */
11643 char $ac_func();
11644
11645 int main() {
11646
11647 /* The GNU C library defines this for functions which it implements
11648     to always fail with ENOSYS.  Some functions are actually named
11649     something starting with __ and the normal name is an alias.  */
11650 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11651 choke me
11652 #else
11653 $ac_func();
11654 #endif
11655
11656 ; return 0; }
11657 EOF
11658 if { (eval echo configure:11659: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11659   rm -rf conftest*
11660   eval "ac_cv_func_$ac_func=yes"
11661 else
11662   echo "configure: failed program was:" >&5
11663   cat conftest.$ac_ext >&5
11664   rm -rf conftest*
11665   eval "ac_cv_func_$ac_func=no"
11666 fi
11667 rm -f conftest*
11668 fi
11669
11670 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11671   echo "$ac_t""yes" 1>&6
11672     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11673   cat >> confdefs.h <<EOF
11674 #define $ac_tr_func 1
11675 EOF
11676
11677 else
11678   echo "$ac_t""no" 1>&6
11679 fi
11680 done
11681
11682   fi
11683
11684
11685   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11686 echo "configure:11687: checking for _isinff declaration" >&5
11687   if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
11688   echo $ac_n "(cached) $ac_c" 1>&6
11689 else
11690
11691
11692     ac_ext=C
11693 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11694 ac_cpp='$CXXCPP $CPPFLAGS'
11695 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11696 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11697 cross_compiling=$ac_cv_prog_cxx_cross
11698
11699     cat > conftest.$ac_ext <<EOF
11700 #line 11701 "configure"
11701 #include "confdefs.h"
11702 #include <math.h>
11703 int main() {
11704  _isinff(0);
11705 ; return 0; }
11706 EOF
11707 if { (eval echo configure:11708: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11708   rm -rf conftest*
11709   glibcpp_cv_func__isinff_use=yes
11710 else
11711   echo "configure: failed program was:" >&5
11712   cat conftest.$ac_ext >&5
11713   rm -rf conftest*
11714   glibcpp_cv_func__isinff_use=no
11715 fi
11716 rm -f conftest*
11717     ac_ext=c
11718 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11719 ac_cpp='$CPP $CPPFLAGS'
11720 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11721 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11722 cross_compiling=$ac_cv_prog_cc_cross
11723
11724
11725 fi
11726
11727   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
11728   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
11729     for ac_func in _isinff
11730 do
11731 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11732 echo "configure:11733: checking for $ac_func" >&5
11733 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11734   echo $ac_n "(cached) $ac_c" 1>&6
11735 else
11736   cat > conftest.$ac_ext <<EOF
11737 #line 11738 "configure"
11738 #include "confdefs.h"
11739 /* System header to define __stub macros and hopefully few prototypes,
11740     which can conflict with char $ac_func(); below.  */
11741 #include <assert.h>
11742 /* Override any gcc2 internal prototype to avoid an error.  */
11743 /* We use char because int might match the return type of a gcc2
11744     builtin and then its argument prototype would still apply.  */
11745 char $ac_func();
11746
11747 int main() {
11748
11749 /* The GNU C library defines this for functions which it implements
11750     to always fail with ENOSYS.  Some functions are actually named
11751     something starting with __ and the normal name is an alias.  */
11752 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11753 choke me
11754 #else
11755 $ac_func();
11756 #endif
11757
11758 ; return 0; }
11759 EOF
11760 if { (eval echo configure:11761: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11761   rm -rf conftest*
11762   eval "ac_cv_func_$ac_func=yes"
11763 else
11764   echo "configure: failed program was:" >&5
11765   cat conftest.$ac_ext >&5
11766   rm -rf conftest*
11767   eval "ac_cv_func_$ac_func=no"
11768 fi
11769 rm -f conftest*
11770 fi
11771
11772 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11773   echo "$ac_t""yes" 1>&6
11774     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11775   cat >> confdefs.h <<EOF
11776 #define $ac_tr_func 1
11777 EOF
11778
11779 else
11780   echo "$ac_t""no" 1>&6
11781 fi
11782 done
11783
11784   fi
11785
11786
11787   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11788 echo "configure:11789: checking for _acosf declaration" >&5
11789   if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
11790   echo $ac_n "(cached) $ac_c" 1>&6
11791 else
11792
11793
11794     ac_ext=C
11795 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11796 ac_cpp='$CXXCPP $CPPFLAGS'
11797 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11798 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11799 cross_compiling=$ac_cv_prog_cxx_cross
11800
11801     cat > conftest.$ac_ext <<EOF
11802 #line 11803 "configure"
11803 #include "confdefs.h"
11804 #include <math.h>
11805 int main() {
11806  _acosf(0);
11807 ; return 0; }
11808 EOF
11809 if { (eval echo configure:11810: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11810   rm -rf conftest*
11811   glibcpp_cv_func__acosf_use=yes
11812 else
11813   echo "configure: failed program was:" >&5
11814   cat conftest.$ac_ext >&5
11815   rm -rf conftest*
11816   glibcpp_cv_func__acosf_use=no
11817 fi
11818 rm -f conftest*
11819     ac_ext=c
11820 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11821 ac_cpp='$CPP $CPPFLAGS'
11822 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11823 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11824 cross_compiling=$ac_cv_prog_cc_cross
11825
11826
11827 fi
11828
11829   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
11830   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
11831     for ac_func in _acosf
11832 do
11833 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11834 echo "configure:11835: checking for $ac_func" >&5
11835 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11836   echo $ac_n "(cached) $ac_c" 1>&6
11837 else
11838   cat > conftest.$ac_ext <<EOF
11839 #line 11840 "configure"
11840 #include "confdefs.h"
11841 /* System header to define __stub macros and hopefully few prototypes,
11842     which can conflict with char $ac_func(); below.  */
11843 #include <assert.h>
11844 /* Override any gcc2 internal prototype to avoid an error.  */
11845 /* We use char because int might match the return type of a gcc2
11846     builtin and then its argument prototype would still apply.  */
11847 char $ac_func();
11848
11849 int main() {
11850
11851 /* The GNU C library defines this for functions which it implements
11852     to always fail with ENOSYS.  Some functions are actually named
11853     something starting with __ and the normal name is an alias.  */
11854 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11855 choke me
11856 #else
11857 $ac_func();
11858 #endif
11859
11860 ; return 0; }
11861 EOF
11862 if { (eval echo configure:11863: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11863   rm -rf conftest*
11864   eval "ac_cv_func_$ac_func=yes"
11865 else
11866   echo "configure: failed program was:" >&5
11867   cat conftest.$ac_ext >&5
11868   rm -rf conftest*
11869   eval "ac_cv_func_$ac_func=no"
11870 fi
11871 rm -f conftest*
11872 fi
11873
11874 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11875   echo "$ac_t""yes" 1>&6
11876     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11877   cat >> confdefs.h <<EOF
11878 #define $ac_tr_func 1
11879 EOF
11880
11881 else
11882   echo "$ac_t""no" 1>&6
11883 fi
11884 done
11885
11886   fi
11887
11888
11889   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11890 echo "configure:11891: checking for _asinf declaration" >&5
11891   if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
11892   echo $ac_n "(cached) $ac_c" 1>&6
11893 else
11894
11895
11896     ac_ext=C
11897 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11898 ac_cpp='$CXXCPP $CPPFLAGS'
11899 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11900 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11901 cross_compiling=$ac_cv_prog_cxx_cross
11902
11903     cat > conftest.$ac_ext <<EOF
11904 #line 11905 "configure"
11905 #include "confdefs.h"
11906 #include <math.h>
11907 int main() {
11908  _asinf(0);
11909 ; return 0; }
11910 EOF
11911 if { (eval echo configure:11912: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11912   rm -rf conftest*
11913   glibcpp_cv_func__asinf_use=yes
11914 else
11915   echo "configure: failed program was:" >&5
11916   cat conftest.$ac_ext >&5
11917   rm -rf conftest*
11918   glibcpp_cv_func__asinf_use=no
11919 fi
11920 rm -f conftest*
11921     ac_ext=c
11922 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11923 ac_cpp='$CPP $CPPFLAGS'
11924 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11925 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11926 cross_compiling=$ac_cv_prog_cc_cross
11927
11928
11929 fi
11930
11931   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
11932   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
11933     for ac_func in _asinf
11934 do
11935 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11936 echo "configure:11937: checking for $ac_func" >&5
11937 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11938   echo $ac_n "(cached) $ac_c" 1>&6
11939 else
11940   cat > conftest.$ac_ext <<EOF
11941 #line 11942 "configure"
11942 #include "confdefs.h"
11943 /* System header to define __stub macros and hopefully few prototypes,
11944     which can conflict with char $ac_func(); below.  */
11945 #include <assert.h>
11946 /* Override any gcc2 internal prototype to avoid an error.  */
11947 /* We use char because int might match the return type of a gcc2
11948     builtin and then its argument prototype would still apply.  */
11949 char $ac_func();
11950
11951 int main() {
11952
11953 /* The GNU C library defines this for functions which it implements
11954     to always fail with ENOSYS.  Some functions are actually named
11955     something starting with __ and the normal name is an alias.  */
11956 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11957 choke me
11958 #else
11959 $ac_func();
11960 #endif
11961
11962 ; return 0; }
11963 EOF
11964 if { (eval echo configure:11965: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11965   rm -rf conftest*
11966   eval "ac_cv_func_$ac_func=yes"
11967 else
11968   echo "configure: failed program was:" >&5
11969   cat conftest.$ac_ext >&5
11970   rm -rf conftest*
11971   eval "ac_cv_func_$ac_func=no"
11972 fi
11973 rm -f conftest*
11974 fi
11975
11976 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11977   echo "$ac_t""yes" 1>&6
11978     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11979   cat >> confdefs.h <<EOF
11980 #define $ac_tr_func 1
11981 EOF
11982
11983 else
11984   echo "$ac_t""no" 1>&6
11985 fi
11986 done
11987
11988   fi
11989
11990
11991   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
11992 echo "configure:11993: checking for _atanf declaration" >&5
11993   if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
11994   echo $ac_n "(cached) $ac_c" 1>&6
11995 else
11996
11997
11998     ac_ext=C
11999 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12000 ac_cpp='$CXXCPP $CPPFLAGS'
12001 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12002 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12003 cross_compiling=$ac_cv_prog_cxx_cross
12004
12005     cat > conftest.$ac_ext <<EOF
12006 #line 12007 "configure"
12007 #include "confdefs.h"
12008 #include <math.h>
12009 int main() {
12010  _atanf(0);
12011 ; return 0; }
12012 EOF
12013 if { (eval echo configure:12014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12014   rm -rf conftest*
12015   glibcpp_cv_func__atanf_use=yes
12016 else
12017   echo "configure: failed program was:" >&5
12018   cat conftest.$ac_ext >&5
12019   rm -rf conftest*
12020   glibcpp_cv_func__atanf_use=no
12021 fi
12022 rm -f conftest*
12023     ac_ext=c
12024 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12025 ac_cpp='$CPP $CPPFLAGS'
12026 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12027 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12028 cross_compiling=$ac_cv_prog_cc_cross
12029
12030
12031 fi
12032
12033   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
12034   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
12035     for ac_func in _atanf
12036 do
12037 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12038 echo "configure:12039: checking for $ac_func" >&5
12039 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12040   echo $ac_n "(cached) $ac_c" 1>&6
12041 else
12042   cat > conftest.$ac_ext <<EOF
12043 #line 12044 "configure"
12044 #include "confdefs.h"
12045 /* System header to define __stub macros and hopefully few prototypes,
12046     which can conflict with char $ac_func(); below.  */
12047 #include <assert.h>
12048 /* Override any gcc2 internal prototype to avoid an error.  */
12049 /* We use char because int might match the return type of a gcc2
12050     builtin and then its argument prototype would still apply.  */
12051 char $ac_func();
12052
12053 int main() {
12054
12055 /* The GNU C library defines this for functions which it implements
12056     to always fail with ENOSYS.  Some functions are actually named
12057     something starting with __ and the normal name is an alias.  */
12058 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12059 choke me
12060 #else
12061 $ac_func();
12062 #endif
12063
12064 ; return 0; }
12065 EOF
12066 if { (eval echo configure:12067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12067   rm -rf conftest*
12068   eval "ac_cv_func_$ac_func=yes"
12069 else
12070   echo "configure: failed program was:" >&5
12071   cat conftest.$ac_ext >&5
12072   rm -rf conftest*
12073   eval "ac_cv_func_$ac_func=no"
12074 fi
12075 rm -f conftest*
12076 fi
12077
12078 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12079   echo "$ac_t""yes" 1>&6
12080     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12081   cat >> confdefs.h <<EOF
12082 #define $ac_tr_func 1
12083 EOF
12084
12085 else
12086   echo "$ac_t""no" 1>&6
12087 fi
12088 done
12089
12090   fi
12091
12092
12093   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
12094 echo "configure:12095: checking for _atan2f declaration" >&5
12095   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
12096   echo $ac_n "(cached) $ac_c" 1>&6
12097 else
12098
12099
12100     ac_ext=C
12101 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12102 ac_cpp='$CXXCPP $CPPFLAGS'
12103 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12104 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12105 cross_compiling=$ac_cv_prog_cxx_cross
12106
12107     cat > conftest.$ac_ext <<EOF
12108 #line 12109 "configure"
12109 #include "confdefs.h"
12110 #include <math.h>
12111 int main() {
12112  _atan2f(0, 0);
12113 ; return 0; }
12114 EOF
12115 if { (eval echo configure:12116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12116   rm -rf conftest*
12117   glibcpp_cv_func__atan2f_use=yes
12118 else
12119   echo "configure: failed program was:" >&5
12120   cat conftest.$ac_ext >&5
12121   rm -rf conftest*
12122   glibcpp_cv_func__atan2f_use=no
12123 fi
12124 rm -f conftest*
12125     ac_ext=c
12126 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12127 ac_cpp='$CPP $CPPFLAGS'
12128 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12129 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12130 cross_compiling=$ac_cv_prog_cc_cross
12131
12132
12133 fi
12134
12135   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
12136   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
12137     for ac_func in _atan2f
12138 do
12139 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12140 echo "configure:12141: checking for $ac_func" >&5
12141 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12142   echo $ac_n "(cached) $ac_c" 1>&6
12143 else
12144   cat > conftest.$ac_ext <<EOF
12145 #line 12146 "configure"
12146 #include "confdefs.h"
12147 /* System header to define __stub macros and hopefully few prototypes,
12148     which can conflict with char $ac_func(); below.  */
12149 #include <assert.h>
12150 /* Override any gcc2 internal prototype to avoid an error.  */
12151 /* We use char because int might match the return type of a gcc2
12152     builtin and then its argument prototype would still apply.  */
12153 char $ac_func();
12154
12155 int main() {
12156
12157 /* The GNU C library defines this for functions which it implements
12158     to always fail with ENOSYS.  Some functions are actually named
12159     something starting with __ and the normal name is an alias.  */
12160 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12161 choke me
12162 #else
12163 $ac_func();
12164 #endif
12165
12166 ; return 0; }
12167 EOF
12168 if { (eval echo configure:12169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12169   rm -rf conftest*
12170   eval "ac_cv_func_$ac_func=yes"
12171 else
12172   echo "configure: failed program was:" >&5
12173   cat conftest.$ac_ext >&5
12174   rm -rf conftest*
12175   eval "ac_cv_func_$ac_func=no"
12176 fi
12177 rm -f conftest*
12178 fi
12179
12180 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12181   echo "$ac_t""yes" 1>&6
12182     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12183   cat >> confdefs.h <<EOF
12184 #define $ac_tr_func 1
12185 EOF
12186
12187 else
12188   echo "$ac_t""no" 1>&6
12189 fi
12190 done
12191
12192   fi
12193
12194
12195   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
12196 echo "configure:12197: checking for _ceilf declaration" >&5
12197   if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
12198   echo $ac_n "(cached) $ac_c" 1>&6
12199 else
12200
12201
12202     ac_ext=C
12203 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12204 ac_cpp='$CXXCPP $CPPFLAGS'
12205 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12206 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12207 cross_compiling=$ac_cv_prog_cxx_cross
12208
12209     cat > conftest.$ac_ext <<EOF
12210 #line 12211 "configure"
12211 #include "confdefs.h"
12212 #include <math.h>
12213 int main() {
12214  _ceilf(0);
12215 ; return 0; }
12216 EOF
12217 if { (eval echo configure:12218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12218   rm -rf conftest*
12219   glibcpp_cv_func__ceilf_use=yes
12220 else
12221   echo "configure: failed program was:" >&5
12222   cat conftest.$ac_ext >&5
12223   rm -rf conftest*
12224   glibcpp_cv_func__ceilf_use=no
12225 fi
12226 rm -f conftest*
12227     ac_ext=c
12228 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12229 ac_cpp='$CPP $CPPFLAGS'
12230 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12231 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12232 cross_compiling=$ac_cv_prog_cc_cross
12233
12234
12235 fi
12236
12237   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
12238   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
12239     for ac_func in _ceilf
12240 do
12241 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12242 echo "configure:12243: checking for $ac_func" >&5
12243 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12244   echo $ac_n "(cached) $ac_c" 1>&6
12245 else
12246   cat > conftest.$ac_ext <<EOF
12247 #line 12248 "configure"
12248 #include "confdefs.h"
12249 /* System header to define __stub macros and hopefully few prototypes,
12250     which can conflict with char $ac_func(); below.  */
12251 #include <assert.h>
12252 /* Override any gcc2 internal prototype to avoid an error.  */
12253 /* We use char because int might match the return type of a gcc2
12254     builtin and then its argument prototype would still apply.  */
12255 char $ac_func();
12256
12257 int main() {
12258
12259 /* The GNU C library defines this for functions which it implements
12260     to always fail with ENOSYS.  Some functions are actually named
12261     something starting with __ and the normal name is an alias.  */
12262 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12263 choke me
12264 #else
12265 $ac_func();
12266 #endif
12267
12268 ; return 0; }
12269 EOF
12270 if { (eval echo configure:12271: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12271   rm -rf conftest*
12272   eval "ac_cv_func_$ac_func=yes"
12273 else
12274   echo "configure: failed program was:" >&5
12275   cat conftest.$ac_ext >&5
12276   rm -rf conftest*
12277   eval "ac_cv_func_$ac_func=no"
12278 fi
12279 rm -f conftest*
12280 fi
12281
12282 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12283   echo "$ac_t""yes" 1>&6
12284     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12285   cat >> confdefs.h <<EOF
12286 #define $ac_tr_func 1
12287 EOF
12288
12289 else
12290   echo "$ac_t""no" 1>&6
12291 fi
12292 done
12293
12294   fi
12295
12296
12297   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
12298 echo "configure:12299: checking for _cosf declaration" >&5
12299   if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
12300   echo $ac_n "(cached) $ac_c" 1>&6
12301 else
12302
12303
12304     ac_ext=C
12305 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12306 ac_cpp='$CXXCPP $CPPFLAGS'
12307 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12308 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12309 cross_compiling=$ac_cv_prog_cxx_cross
12310
12311     cat > conftest.$ac_ext <<EOF
12312 #line 12313 "configure"
12313 #include "confdefs.h"
12314 #include <math.h>
12315 int main() {
12316  _cosf(0);
12317 ; return 0; }
12318 EOF
12319 if { (eval echo configure:12320: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12320   rm -rf conftest*
12321   glibcpp_cv_func__cosf_use=yes
12322 else
12323   echo "configure: failed program was:" >&5
12324   cat conftest.$ac_ext >&5
12325   rm -rf conftest*
12326   glibcpp_cv_func__cosf_use=no
12327 fi
12328 rm -f conftest*
12329     ac_ext=c
12330 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12331 ac_cpp='$CPP $CPPFLAGS'
12332 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12333 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12334 cross_compiling=$ac_cv_prog_cc_cross
12335
12336
12337 fi
12338
12339   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
12340   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
12341     for ac_func in _cosf
12342 do
12343 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12344 echo "configure:12345: checking for $ac_func" >&5
12345 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12346   echo $ac_n "(cached) $ac_c" 1>&6
12347 else
12348   cat > conftest.$ac_ext <<EOF
12349 #line 12350 "configure"
12350 #include "confdefs.h"
12351 /* System header to define __stub macros and hopefully few prototypes,
12352     which can conflict with char $ac_func(); below.  */
12353 #include <assert.h>
12354 /* Override any gcc2 internal prototype to avoid an error.  */
12355 /* We use char because int might match the return type of a gcc2
12356     builtin and then its argument prototype would still apply.  */
12357 char $ac_func();
12358
12359 int main() {
12360
12361 /* The GNU C library defines this for functions which it implements
12362     to always fail with ENOSYS.  Some functions are actually named
12363     something starting with __ and the normal name is an alias.  */
12364 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12365 choke me
12366 #else
12367 $ac_func();
12368 #endif
12369
12370 ; return 0; }
12371 EOF
12372 if { (eval echo configure:12373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12373   rm -rf conftest*
12374   eval "ac_cv_func_$ac_func=yes"
12375 else
12376   echo "configure: failed program was:" >&5
12377   cat conftest.$ac_ext >&5
12378   rm -rf conftest*
12379   eval "ac_cv_func_$ac_func=no"
12380 fi
12381 rm -f conftest*
12382 fi
12383
12384 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12385   echo "$ac_t""yes" 1>&6
12386     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12387   cat >> confdefs.h <<EOF
12388 #define $ac_tr_func 1
12389 EOF
12390
12391 else
12392   echo "$ac_t""no" 1>&6
12393 fi
12394 done
12395
12396   fi
12397
12398
12399   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12400 echo "configure:12401: checking for _coshf declaration" >&5
12401   if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
12402   echo $ac_n "(cached) $ac_c" 1>&6
12403 else
12404
12405
12406     ac_ext=C
12407 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12408 ac_cpp='$CXXCPP $CPPFLAGS'
12409 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12410 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12411 cross_compiling=$ac_cv_prog_cxx_cross
12412
12413     cat > conftest.$ac_ext <<EOF
12414 #line 12415 "configure"
12415 #include "confdefs.h"
12416 #include <math.h>
12417 int main() {
12418  _coshf(0);
12419 ; return 0; }
12420 EOF
12421 if { (eval echo configure:12422: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12422   rm -rf conftest*
12423   glibcpp_cv_func__coshf_use=yes
12424 else
12425   echo "configure: failed program was:" >&5
12426   cat conftest.$ac_ext >&5
12427   rm -rf conftest*
12428   glibcpp_cv_func__coshf_use=no
12429 fi
12430 rm -f conftest*
12431     ac_ext=c
12432 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12433 ac_cpp='$CPP $CPPFLAGS'
12434 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12435 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12436 cross_compiling=$ac_cv_prog_cc_cross
12437
12438
12439 fi
12440
12441   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
12442   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
12443     for ac_func in _coshf
12444 do
12445 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12446 echo "configure:12447: checking for $ac_func" >&5
12447 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12448   echo $ac_n "(cached) $ac_c" 1>&6
12449 else
12450   cat > conftest.$ac_ext <<EOF
12451 #line 12452 "configure"
12452 #include "confdefs.h"
12453 /* System header to define __stub macros and hopefully few prototypes,
12454     which can conflict with char $ac_func(); below.  */
12455 #include <assert.h>
12456 /* Override any gcc2 internal prototype to avoid an error.  */
12457 /* We use char because int might match the return type of a gcc2
12458     builtin and then its argument prototype would still apply.  */
12459 char $ac_func();
12460
12461 int main() {
12462
12463 /* The GNU C library defines this for functions which it implements
12464     to always fail with ENOSYS.  Some functions are actually named
12465     something starting with __ and the normal name is an alias.  */
12466 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12467 choke me
12468 #else
12469 $ac_func();
12470 #endif
12471
12472 ; return 0; }
12473 EOF
12474 if { (eval echo configure:12475: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12475   rm -rf conftest*
12476   eval "ac_cv_func_$ac_func=yes"
12477 else
12478   echo "configure: failed program was:" >&5
12479   cat conftest.$ac_ext >&5
12480   rm -rf conftest*
12481   eval "ac_cv_func_$ac_func=no"
12482 fi
12483 rm -f conftest*
12484 fi
12485
12486 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12487   echo "$ac_t""yes" 1>&6
12488     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12489   cat >> confdefs.h <<EOF
12490 #define $ac_tr_func 1
12491 EOF
12492
12493 else
12494   echo "$ac_t""no" 1>&6
12495 fi
12496 done
12497
12498   fi
12499
12500
12501   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12502 echo "configure:12503: checking for _expf declaration" >&5
12503   if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
12504   echo $ac_n "(cached) $ac_c" 1>&6
12505 else
12506
12507
12508     ac_ext=C
12509 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12510 ac_cpp='$CXXCPP $CPPFLAGS'
12511 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12512 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12513 cross_compiling=$ac_cv_prog_cxx_cross
12514
12515     cat > conftest.$ac_ext <<EOF
12516 #line 12517 "configure"
12517 #include "confdefs.h"
12518 #include <math.h>
12519 int main() {
12520  _expf(0);
12521 ; return 0; }
12522 EOF
12523 if { (eval echo configure:12524: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12524   rm -rf conftest*
12525   glibcpp_cv_func__expf_use=yes
12526 else
12527   echo "configure: failed program was:" >&5
12528   cat conftest.$ac_ext >&5
12529   rm -rf conftest*
12530   glibcpp_cv_func__expf_use=no
12531 fi
12532 rm -f conftest*
12533     ac_ext=c
12534 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12535 ac_cpp='$CPP $CPPFLAGS'
12536 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12537 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12538 cross_compiling=$ac_cv_prog_cc_cross
12539
12540
12541 fi
12542
12543   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
12544   if test x$glibcpp_cv_func__expf_use = x"yes"; then
12545     for ac_func in _expf
12546 do
12547 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12548 echo "configure:12549: checking for $ac_func" >&5
12549 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12550   echo $ac_n "(cached) $ac_c" 1>&6
12551 else
12552   cat > conftest.$ac_ext <<EOF
12553 #line 12554 "configure"
12554 #include "confdefs.h"
12555 /* System header to define __stub macros and hopefully few prototypes,
12556     which can conflict with char $ac_func(); below.  */
12557 #include <assert.h>
12558 /* Override any gcc2 internal prototype to avoid an error.  */
12559 /* We use char because int might match the return type of a gcc2
12560     builtin and then its argument prototype would still apply.  */
12561 char $ac_func();
12562
12563 int main() {
12564
12565 /* The GNU C library defines this for functions which it implements
12566     to always fail with ENOSYS.  Some functions are actually named
12567     something starting with __ and the normal name is an alias.  */
12568 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12569 choke me
12570 #else
12571 $ac_func();
12572 #endif
12573
12574 ; return 0; }
12575 EOF
12576 if { (eval echo configure:12577: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12577   rm -rf conftest*
12578   eval "ac_cv_func_$ac_func=yes"
12579 else
12580   echo "configure: failed program was:" >&5
12581   cat conftest.$ac_ext >&5
12582   rm -rf conftest*
12583   eval "ac_cv_func_$ac_func=no"
12584 fi
12585 rm -f conftest*
12586 fi
12587
12588 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12589   echo "$ac_t""yes" 1>&6
12590     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12591   cat >> confdefs.h <<EOF
12592 #define $ac_tr_func 1
12593 EOF
12594
12595 else
12596   echo "$ac_t""no" 1>&6
12597 fi
12598 done
12599
12600   fi
12601
12602
12603   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12604 echo "configure:12605: checking for _fabsf declaration" >&5
12605   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
12606   echo $ac_n "(cached) $ac_c" 1>&6
12607 else
12608
12609
12610     ac_ext=C
12611 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12612 ac_cpp='$CXXCPP $CPPFLAGS'
12613 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12614 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12615 cross_compiling=$ac_cv_prog_cxx_cross
12616
12617     cat > conftest.$ac_ext <<EOF
12618 #line 12619 "configure"
12619 #include "confdefs.h"
12620 #include <math.h>
12621 int main() {
12622  _fabsf(0);
12623 ; return 0; }
12624 EOF
12625 if { (eval echo configure:12626: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12626   rm -rf conftest*
12627   glibcpp_cv_func__fabsf_use=yes
12628 else
12629   echo "configure: failed program was:" >&5
12630   cat conftest.$ac_ext >&5
12631   rm -rf conftest*
12632   glibcpp_cv_func__fabsf_use=no
12633 fi
12634 rm -f conftest*
12635     ac_ext=c
12636 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12637 ac_cpp='$CPP $CPPFLAGS'
12638 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12639 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12640 cross_compiling=$ac_cv_prog_cc_cross
12641
12642
12643 fi
12644
12645   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
12646   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
12647     for ac_func in _fabsf
12648 do
12649 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12650 echo "configure:12651: checking for $ac_func" >&5
12651 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12652   echo $ac_n "(cached) $ac_c" 1>&6
12653 else
12654   cat > conftest.$ac_ext <<EOF
12655 #line 12656 "configure"
12656 #include "confdefs.h"
12657 /* System header to define __stub macros and hopefully few prototypes,
12658     which can conflict with char $ac_func(); below.  */
12659 #include <assert.h>
12660 /* Override any gcc2 internal prototype to avoid an error.  */
12661 /* We use char because int might match the return type of a gcc2
12662     builtin and then its argument prototype would still apply.  */
12663 char $ac_func();
12664
12665 int main() {
12666
12667 /* The GNU C library defines this for functions which it implements
12668     to always fail with ENOSYS.  Some functions are actually named
12669     something starting with __ and the normal name is an alias.  */
12670 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12671 choke me
12672 #else
12673 $ac_func();
12674 #endif
12675
12676 ; return 0; }
12677 EOF
12678 if { (eval echo configure:12679: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12679   rm -rf conftest*
12680   eval "ac_cv_func_$ac_func=yes"
12681 else
12682   echo "configure: failed program was:" >&5
12683   cat conftest.$ac_ext >&5
12684   rm -rf conftest*
12685   eval "ac_cv_func_$ac_func=no"
12686 fi
12687 rm -f conftest*
12688 fi
12689
12690 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12691   echo "$ac_t""yes" 1>&6
12692     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12693   cat >> confdefs.h <<EOF
12694 #define $ac_tr_func 1
12695 EOF
12696
12697 else
12698   echo "$ac_t""no" 1>&6
12699 fi
12700 done
12701
12702   fi
12703
12704
12705   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12706 echo "configure:12707: checking for _floorf declaration" >&5
12707   if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
12708   echo $ac_n "(cached) $ac_c" 1>&6
12709 else
12710
12711
12712     ac_ext=C
12713 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12714 ac_cpp='$CXXCPP $CPPFLAGS'
12715 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12716 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12717 cross_compiling=$ac_cv_prog_cxx_cross
12718
12719     cat > conftest.$ac_ext <<EOF
12720 #line 12721 "configure"
12721 #include "confdefs.h"
12722 #include <math.h>
12723 int main() {
12724  _floorf(0);
12725 ; return 0; }
12726 EOF
12727 if { (eval echo configure:12728: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12728   rm -rf conftest*
12729   glibcpp_cv_func__floorf_use=yes
12730 else
12731   echo "configure: failed program was:" >&5
12732   cat conftest.$ac_ext >&5
12733   rm -rf conftest*
12734   glibcpp_cv_func__floorf_use=no
12735 fi
12736 rm -f conftest*
12737     ac_ext=c
12738 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12739 ac_cpp='$CPP $CPPFLAGS'
12740 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12741 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12742 cross_compiling=$ac_cv_prog_cc_cross
12743
12744
12745 fi
12746
12747   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
12748   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
12749     for ac_func in _floorf
12750 do
12751 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12752 echo "configure:12753: checking for $ac_func" >&5
12753 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12754   echo $ac_n "(cached) $ac_c" 1>&6
12755 else
12756   cat > conftest.$ac_ext <<EOF
12757 #line 12758 "configure"
12758 #include "confdefs.h"
12759 /* System header to define __stub macros and hopefully few prototypes,
12760     which can conflict with char $ac_func(); below.  */
12761 #include <assert.h>
12762 /* Override any gcc2 internal prototype to avoid an error.  */
12763 /* We use char because int might match the return type of a gcc2
12764     builtin and then its argument prototype would still apply.  */
12765 char $ac_func();
12766
12767 int main() {
12768
12769 /* The GNU C library defines this for functions which it implements
12770     to always fail with ENOSYS.  Some functions are actually named
12771     something starting with __ and the normal name is an alias.  */
12772 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12773 choke me
12774 #else
12775 $ac_func();
12776 #endif
12777
12778 ; return 0; }
12779 EOF
12780 if { (eval echo configure:12781: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12781   rm -rf conftest*
12782   eval "ac_cv_func_$ac_func=yes"
12783 else
12784   echo "configure: failed program was:" >&5
12785   cat conftest.$ac_ext >&5
12786   rm -rf conftest*
12787   eval "ac_cv_func_$ac_func=no"
12788 fi
12789 rm -f conftest*
12790 fi
12791
12792 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12793   echo "$ac_t""yes" 1>&6
12794     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12795   cat >> confdefs.h <<EOF
12796 #define $ac_tr_func 1
12797 EOF
12798
12799 else
12800   echo "$ac_t""no" 1>&6
12801 fi
12802 done
12803
12804   fi
12805
12806
12807   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12808 echo "configure:12809: checking for _fmodf declaration" >&5
12809   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
12810   echo $ac_n "(cached) $ac_c" 1>&6
12811 else
12812
12813
12814     ac_ext=C
12815 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12816 ac_cpp='$CXXCPP $CPPFLAGS'
12817 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12818 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12819 cross_compiling=$ac_cv_prog_cxx_cross
12820
12821     cat > conftest.$ac_ext <<EOF
12822 #line 12823 "configure"
12823 #include "confdefs.h"
12824 #include <math.h>
12825 int main() {
12826  _fmodf(0, 0);
12827 ; return 0; }
12828 EOF
12829 if { (eval echo configure:12830: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12830   rm -rf conftest*
12831   glibcpp_cv_func__fmodf_use=yes
12832 else
12833   echo "configure: failed program was:" >&5
12834   cat conftest.$ac_ext >&5
12835   rm -rf conftest*
12836   glibcpp_cv_func__fmodf_use=no
12837 fi
12838 rm -f conftest*
12839     ac_ext=c
12840 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12841 ac_cpp='$CPP $CPPFLAGS'
12842 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12843 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12844 cross_compiling=$ac_cv_prog_cc_cross
12845
12846
12847 fi
12848
12849   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
12850   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
12851     for ac_func in _fmodf
12852 do
12853 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12854 echo "configure:12855: checking for $ac_func" >&5
12855 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12856   echo $ac_n "(cached) $ac_c" 1>&6
12857 else
12858   cat > conftest.$ac_ext <<EOF
12859 #line 12860 "configure"
12860 #include "confdefs.h"
12861 /* System header to define __stub macros and hopefully few prototypes,
12862     which can conflict with char $ac_func(); below.  */
12863 #include <assert.h>
12864 /* Override any gcc2 internal prototype to avoid an error.  */
12865 /* We use char because int might match the return type of a gcc2
12866     builtin and then its argument prototype would still apply.  */
12867 char $ac_func();
12868
12869 int main() {
12870
12871 /* The GNU C library defines this for functions which it implements
12872     to always fail with ENOSYS.  Some functions are actually named
12873     something starting with __ and the normal name is an alias.  */
12874 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12875 choke me
12876 #else
12877 $ac_func();
12878 #endif
12879
12880 ; return 0; }
12881 EOF
12882 if { (eval echo configure:12883: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12883   rm -rf conftest*
12884   eval "ac_cv_func_$ac_func=yes"
12885 else
12886   echo "configure: failed program was:" >&5
12887   cat conftest.$ac_ext >&5
12888   rm -rf conftest*
12889   eval "ac_cv_func_$ac_func=no"
12890 fi
12891 rm -f conftest*
12892 fi
12893
12894 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12895   echo "$ac_t""yes" 1>&6
12896     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12897   cat >> confdefs.h <<EOF
12898 #define $ac_tr_func 1
12899 EOF
12900
12901 else
12902   echo "$ac_t""no" 1>&6
12903 fi
12904 done
12905
12906   fi
12907
12908
12909   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12910 echo "configure:12911: checking for _frexpf declaration" >&5
12911   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
12912   echo $ac_n "(cached) $ac_c" 1>&6
12913 else
12914
12915
12916     ac_ext=C
12917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12918 ac_cpp='$CXXCPP $CPPFLAGS'
12919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12921 cross_compiling=$ac_cv_prog_cxx_cross
12922
12923     cat > conftest.$ac_ext <<EOF
12924 #line 12925 "configure"
12925 #include "confdefs.h"
12926 #include <math.h>
12927 int main() {
12928  _frexpf(0, 0);
12929 ; return 0; }
12930 EOF
12931 if { (eval echo configure:12932: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12932   rm -rf conftest*
12933   glibcpp_cv_func__frexpf_use=yes
12934 else
12935   echo "configure: failed program was:" >&5
12936   cat conftest.$ac_ext >&5
12937   rm -rf conftest*
12938   glibcpp_cv_func__frexpf_use=no
12939 fi
12940 rm -f conftest*
12941     ac_ext=c
12942 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12943 ac_cpp='$CPP $CPPFLAGS'
12944 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12945 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12946 cross_compiling=$ac_cv_prog_cc_cross
12947
12948
12949 fi
12950
12951   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
12952   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
12953     for ac_func in _frexpf
12954 do
12955 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12956 echo "configure:12957: checking for $ac_func" >&5
12957 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12958   echo $ac_n "(cached) $ac_c" 1>&6
12959 else
12960   cat > conftest.$ac_ext <<EOF
12961 #line 12962 "configure"
12962 #include "confdefs.h"
12963 /* System header to define __stub macros and hopefully few prototypes,
12964     which can conflict with char $ac_func(); below.  */
12965 #include <assert.h>
12966 /* Override any gcc2 internal prototype to avoid an error.  */
12967 /* We use char because int might match the return type of a gcc2
12968     builtin and then its argument prototype would still apply.  */
12969 char $ac_func();
12970
12971 int main() {
12972
12973 /* The GNU C library defines this for functions which it implements
12974     to always fail with ENOSYS.  Some functions are actually named
12975     something starting with __ and the normal name is an alias.  */
12976 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12977 choke me
12978 #else
12979 $ac_func();
12980 #endif
12981
12982 ; return 0; }
12983 EOF
12984 if { (eval echo configure:12985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12985   rm -rf conftest*
12986   eval "ac_cv_func_$ac_func=yes"
12987 else
12988   echo "configure: failed program was:" >&5
12989   cat conftest.$ac_ext >&5
12990   rm -rf conftest*
12991   eval "ac_cv_func_$ac_func=no"
12992 fi
12993 rm -f conftest*
12994 fi
12995
12996 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12997   echo "$ac_t""yes" 1>&6
12998     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12999   cat >> confdefs.h <<EOF
13000 #define $ac_tr_func 1
13001 EOF
13002
13003 else
13004   echo "$ac_t""no" 1>&6
13005 fi
13006 done
13007
13008   fi
13009
13010
13011   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13012 echo "configure:13013: checking for _ldexpf declaration" >&5
13013   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13014   echo $ac_n "(cached) $ac_c" 1>&6
13015 else
13016
13017
13018     ac_ext=C
13019 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13020 ac_cpp='$CXXCPP $CPPFLAGS'
13021 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13022 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13023 cross_compiling=$ac_cv_prog_cxx_cross
13024
13025     cat > conftest.$ac_ext <<EOF
13026 #line 13027 "configure"
13027 #include "confdefs.h"
13028 #include <math.h>
13029 int main() {
13030  _ldexpf(0, 0);
13031 ; return 0; }
13032 EOF
13033 if { (eval echo configure:13034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13034   rm -rf conftest*
13035   glibcpp_cv_func__ldexpf_use=yes
13036 else
13037   echo "configure: failed program was:" >&5
13038   cat conftest.$ac_ext >&5
13039   rm -rf conftest*
13040   glibcpp_cv_func__ldexpf_use=no
13041 fi
13042 rm -f conftest*
13043     ac_ext=c
13044 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13045 ac_cpp='$CPP $CPPFLAGS'
13046 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13047 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13048 cross_compiling=$ac_cv_prog_cc_cross
13049
13050
13051 fi
13052
13053   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13054   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13055     for ac_func in _ldexpf
13056 do
13057 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13058 echo "configure:13059: checking for $ac_func" >&5
13059 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13060   echo $ac_n "(cached) $ac_c" 1>&6
13061 else
13062   cat > conftest.$ac_ext <<EOF
13063 #line 13064 "configure"
13064 #include "confdefs.h"
13065 /* System header to define __stub macros and hopefully few prototypes,
13066     which can conflict with char $ac_func(); below.  */
13067 #include <assert.h>
13068 /* Override any gcc2 internal prototype to avoid an error.  */
13069 /* We use char because int might match the return type of a gcc2
13070     builtin and then its argument prototype would still apply.  */
13071 char $ac_func();
13072
13073 int main() {
13074
13075 /* The GNU C library defines this for functions which it implements
13076     to always fail with ENOSYS.  Some functions are actually named
13077     something starting with __ and the normal name is an alias.  */
13078 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13079 choke me
13080 #else
13081 $ac_func();
13082 #endif
13083
13084 ; return 0; }
13085 EOF
13086 if { (eval echo configure:13087: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13087   rm -rf conftest*
13088   eval "ac_cv_func_$ac_func=yes"
13089 else
13090   echo "configure: failed program was:" >&5
13091   cat conftest.$ac_ext >&5
13092   rm -rf conftest*
13093   eval "ac_cv_func_$ac_func=no"
13094 fi
13095 rm -f conftest*
13096 fi
13097
13098 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13099   echo "$ac_t""yes" 1>&6
13100     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13101   cat >> confdefs.h <<EOF
13102 #define $ac_tr_func 1
13103 EOF
13104
13105 else
13106   echo "$ac_t""no" 1>&6
13107 fi
13108 done
13109
13110   fi
13111
13112
13113   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
13114 echo "configure:13115: checking for _logf declaration" >&5
13115   if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
13116   echo $ac_n "(cached) $ac_c" 1>&6
13117 else
13118
13119
13120     ac_ext=C
13121 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13122 ac_cpp='$CXXCPP $CPPFLAGS'
13123 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13124 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13125 cross_compiling=$ac_cv_prog_cxx_cross
13126
13127     cat > conftest.$ac_ext <<EOF
13128 #line 13129 "configure"
13129 #include "confdefs.h"
13130 #include <math.h>
13131 int main() {
13132  _logf(0);
13133 ; return 0; }
13134 EOF
13135 if { (eval echo configure:13136: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13136   rm -rf conftest*
13137   glibcpp_cv_func__logf_use=yes
13138 else
13139   echo "configure: failed program was:" >&5
13140   cat conftest.$ac_ext >&5
13141   rm -rf conftest*
13142   glibcpp_cv_func__logf_use=no
13143 fi
13144 rm -f conftest*
13145     ac_ext=c
13146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13147 ac_cpp='$CPP $CPPFLAGS'
13148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13150 cross_compiling=$ac_cv_prog_cc_cross
13151
13152
13153 fi
13154
13155   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
13156   if test x$glibcpp_cv_func__logf_use = x"yes"; then
13157     for ac_func in _logf
13158 do
13159 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13160 echo "configure:13161: checking for $ac_func" >&5
13161 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13162   echo $ac_n "(cached) $ac_c" 1>&6
13163 else
13164   cat > conftest.$ac_ext <<EOF
13165 #line 13166 "configure"
13166 #include "confdefs.h"
13167 /* System header to define __stub macros and hopefully few prototypes,
13168     which can conflict with char $ac_func(); below.  */
13169 #include <assert.h>
13170 /* Override any gcc2 internal prototype to avoid an error.  */
13171 /* We use char because int might match the return type of a gcc2
13172     builtin and then its argument prototype would still apply.  */
13173 char $ac_func();
13174
13175 int main() {
13176
13177 /* The GNU C library defines this for functions which it implements
13178     to always fail with ENOSYS.  Some functions are actually named
13179     something starting with __ and the normal name is an alias.  */
13180 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13181 choke me
13182 #else
13183 $ac_func();
13184 #endif
13185
13186 ; return 0; }
13187 EOF
13188 if { (eval echo configure:13189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13189   rm -rf conftest*
13190   eval "ac_cv_func_$ac_func=yes"
13191 else
13192   echo "configure: failed program was:" >&5
13193   cat conftest.$ac_ext >&5
13194   rm -rf conftest*
13195   eval "ac_cv_func_$ac_func=no"
13196 fi
13197 rm -f conftest*
13198 fi
13199
13200 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13201   echo "$ac_t""yes" 1>&6
13202     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13203   cat >> confdefs.h <<EOF
13204 #define $ac_tr_func 1
13205 EOF
13206
13207 else
13208   echo "$ac_t""no" 1>&6
13209 fi
13210 done
13211
13212   fi
13213
13214
13215   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
13216 echo "configure:13217: checking for _log10f declaration" >&5
13217   if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
13218   echo $ac_n "(cached) $ac_c" 1>&6
13219 else
13220
13221
13222     ac_ext=C
13223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13224 ac_cpp='$CXXCPP $CPPFLAGS'
13225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13227 cross_compiling=$ac_cv_prog_cxx_cross
13228
13229     cat > conftest.$ac_ext <<EOF
13230 #line 13231 "configure"
13231 #include "confdefs.h"
13232 #include <math.h>
13233 int main() {
13234  _log10f(0);
13235 ; return 0; }
13236 EOF
13237 if { (eval echo configure:13238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13238   rm -rf conftest*
13239   glibcpp_cv_func__log10f_use=yes
13240 else
13241   echo "configure: failed program was:" >&5
13242   cat conftest.$ac_ext >&5
13243   rm -rf conftest*
13244   glibcpp_cv_func__log10f_use=no
13245 fi
13246 rm -f conftest*
13247     ac_ext=c
13248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13249 ac_cpp='$CPP $CPPFLAGS'
13250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13252 cross_compiling=$ac_cv_prog_cc_cross
13253
13254
13255 fi
13256
13257   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
13258   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
13259     for ac_func in _log10f
13260 do
13261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13262 echo "configure:13263: checking for $ac_func" >&5
13263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13264   echo $ac_n "(cached) $ac_c" 1>&6
13265 else
13266   cat > conftest.$ac_ext <<EOF
13267 #line 13268 "configure"
13268 #include "confdefs.h"
13269 /* System header to define __stub macros and hopefully few prototypes,
13270     which can conflict with char $ac_func(); below.  */
13271 #include <assert.h>
13272 /* Override any gcc2 internal prototype to avoid an error.  */
13273 /* We use char because int might match the return type of a gcc2
13274     builtin and then its argument prototype would still apply.  */
13275 char $ac_func();
13276
13277 int main() {
13278
13279 /* The GNU C library defines this for functions which it implements
13280     to always fail with ENOSYS.  Some functions are actually named
13281     something starting with __ and the normal name is an alias.  */
13282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13283 choke me
13284 #else
13285 $ac_func();
13286 #endif
13287
13288 ; return 0; }
13289 EOF
13290 if { (eval echo configure:13291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13291   rm -rf conftest*
13292   eval "ac_cv_func_$ac_func=yes"
13293 else
13294   echo "configure: failed program was:" >&5
13295   cat conftest.$ac_ext >&5
13296   rm -rf conftest*
13297   eval "ac_cv_func_$ac_func=no"
13298 fi
13299 rm -f conftest*
13300 fi
13301
13302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13303   echo "$ac_t""yes" 1>&6
13304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13305   cat >> confdefs.h <<EOF
13306 #define $ac_tr_func 1
13307 EOF
13308
13309 else
13310   echo "$ac_t""no" 1>&6
13311 fi
13312 done
13313
13314   fi
13315
13316
13317   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
13318 echo "configure:13319: checking for _modff declaration" >&5
13319   if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
13320   echo $ac_n "(cached) $ac_c" 1>&6
13321 else
13322
13323
13324     ac_ext=C
13325 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13326 ac_cpp='$CXXCPP $CPPFLAGS'
13327 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13328 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13329 cross_compiling=$ac_cv_prog_cxx_cross
13330
13331     cat > conftest.$ac_ext <<EOF
13332 #line 13333 "configure"
13333 #include "confdefs.h"
13334 #include <math.h>
13335 int main() {
13336  _modff(0, 0);
13337 ; return 0; }
13338 EOF
13339 if { (eval echo configure:13340: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13340   rm -rf conftest*
13341   glibcpp_cv_func__modff_use=yes
13342 else
13343   echo "configure: failed program was:" >&5
13344   cat conftest.$ac_ext >&5
13345   rm -rf conftest*
13346   glibcpp_cv_func__modff_use=no
13347 fi
13348 rm -f conftest*
13349     ac_ext=c
13350 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13351 ac_cpp='$CPP $CPPFLAGS'
13352 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13353 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13354 cross_compiling=$ac_cv_prog_cc_cross
13355
13356
13357 fi
13358
13359   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
13360   if test x$glibcpp_cv_func__modff_use = x"yes"; then
13361     for ac_func in _modff
13362 do
13363 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13364 echo "configure:13365: checking for $ac_func" >&5
13365 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13366   echo $ac_n "(cached) $ac_c" 1>&6
13367 else
13368   cat > conftest.$ac_ext <<EOF
13369 #line 13370 "configure"
13370 #include "confdefs.h"
13371 /* System header to define __stub macros and hopefully few prototypes,
13372     which can conflict with char $ac_func(); below.  */
13373 #include <assert.h>
13374 /* Override any gcc2 internal prototype to avoid an error.  */
13375 /* We use char because int might match the return type of a gcc2
13376     builtin and then its argument prototype would still apply.  */
13377 char $ac_func();
13378
13379 int main() {
13380
13381 /* The GNU C library defines this for functions which it implements
13382     to always fail with ENOSYS.  Some functions are actually named
13383     something starting with __ and the normal name is an alias.  */
13384 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13385 choke me
13386 #else
13387 $ac_func();
13388 #endif
13389
13390 ; return 0; }
13391 EOF
13392 if { (eval echo configure:13393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13393   rm -rf conftest*
13394   eval "ac_cv_func_$ac_func=yes"
13395 else
13396   echo "configure: failed program was:" >&5
13397   cat conftest.$ac_ext >&5
13398   rm -rf conftest*
13399   eval "ac_cv_func_$ac_func=no"
13400 fi
13401 rm -f conftest*
13402 fi
13403
13404 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13405   echo "$ac_t""yes" 1>&6
13406     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13407   cat >> confdefs.h <<EOF
13408 #define $ac_tr_func 1
13409 EOF
13410
13411 else
13412   echo "$ac_t""no" 1>&6
13413 fi
13414 done
13415
13416   fi
13417
13418
13419   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
13420 echo "configure:13421: checking for _powf declaration" >&5
13421   if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
13422   echo $ac_n "(cached) $ac_c" 1>&6
13423 else
13424
13425
13426     ac_ext=C
13427 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13428 ac_cpp='$CXXCPP $CPPFLAGS'
13429 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13430 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13431 cross_compiling=$ac_cv_prog_cxx_cross
13432
13433     cat > conftest.$ac_ext <<EOF
13434 #line 13435 "configure"
13435 #include "confdefs.h"
13436 #include <math.h>
13437 int main() {
13438  _powf(0, 0);
13439 ; return 0; }
13440 EOF
13441 if { (eval echo configure:13442: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13442   rm -rf conftest*
13443   glibcpp_cv_func__powf_use=yes
13444 else
13445   echo "configure: failed program was:" >&5
13446   cat conftest.$ac_ext >&5
13447   rm -rf conftest*
13448   glibcpp_cv_func__powf_use=no
13449 fi
13450 rm -f conftest*
13451     ac_ext=c
13452 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13453 ac_cpp='$CPP $CPPFLAGS'
13454 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13455 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13456 cross_compiling=$ac_cv_prog_cc_cross
13457
13458
13459 fi
13460
13461   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
13462   if test x$glibcpp_cv_func__powf_use = x"yes"; then
13463     for ac_func in _powf
13464 do
13465 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13466 echo "configure:13467: checking for $ac_func" >&5
13467 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13468   echo $ac_n "(cached) $ac_c" 1>&6
13469 else
13470   cat > conftest.$ac_ext <<EOF
13471 #line 13472 "configure"
13472 #include "confdefs.h"
13473 /* System header to define __stub macros and hopefully few prototypes,
13474     which can conflict with char $ac_func(); below.  */
13475 #include <assert.h>
13476 /* Override any gcc2 internal prototype to avoid an error.  */
13477 /* We use char because int might match the return type of a gcc2
13478     builtin and then its argument prototype would still apply.  */
13479 char $ac_func();
13480
13481 int main() {
13482
13483 /* The GNU C library defines this for functions which it implements
13484     to always fail with ENOSYS.  Some functions are actually named
13485     something starting with __ and the normal name is an alias.  */
13486 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13487 choke me
13488 #else
13489 $ac_func();
13490 #endif
13491
13492 ; return 0; }
13493 EOF
13494 if { (eval echo configure:13495: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13495   rm -rf conftest*
13496   eval "ac_cv_func_$ac_func=yes"
13497 else
13498   echo "configure: failed program was:" >&5
13499   cat conftest.$ac_ext >&5
13500   rm -rf conftest*
13501   eval "ac_cv_func_$ac_func=no"
13502 fi
13503 rm -f conftest*
13504 fi
13505
13506 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13507   echo "$ac_t""yes" 1>&6
13508     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13509   cat >> confdefs.h <<EOF
13510 #define $ac_tr_func 1
13511 EOF
13512
13513 else
13514   echo "$ac_t""no" 1>&6
13515 fi
13516 done
13517
13518   fi
13519
13520
13521   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
13522 echo "configure:13523: checking for _sinf declaration" >&5
13523   if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
13524   echo $ac_n "(cached) $ac_c" 1>&6
13525 else
13526
13527
13528     ac_ext=C
13529 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13530 ac_cpp='$CXXCPP $CPPFLAGS'
13531 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13532 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13533 cross_compiling=$ac_cv_prog_cxx_cross
13534
13535     cat > conftest.$ac_ext <<EOF
13536 #line 13537 "configure"
13537 #include "confdefs.h"
13538 #include <math.h>
13539 int main() {
13540  _sinf(0);
13541 ; return 0; }
13542 EOF
13543 if { (eval echo configure:13544: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13544   rm -rf conftest*
13545   glibcpp_cv_func__sinf_use=yes
13546 else
13547   echo "configure: failed program was:" >&5
13548   cat conftest.$ac_ext >&5
13549   rm -rf conftest*
13550   glibcpp_cv_func__sinf_use=no
13551 fi
13552 rm -f conftest*
13553     ac_ext=c
13554 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13555 ac_cpp='$CPP $CPPFLAGS'
13556 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13557 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13558 cross_compiling=$ac_cv_prog_cc_cross
13559
13560
13561 fi
13562
13563   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
13564   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
13565     for ac_func in _sinf
13566 do
13567 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13568 echo "configure:13569: checking for $ac_func" >&5
13569 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13570   echo $ac_n "(cached) $ac_c" 1>&6
13571 else
13572   cat > conftest.$ac_ext <<EOF
13573 #line 13574 "configure"
13574 #include "confdefs.h"
13575 /* System header to define __stub macros and hopefully few prototypes,
13576     which can conflict with char $ac_func(); below.  */
13577 #include <assert.h>
13578 /* Override any gcc2 internal prototype to avoid an error.  */
13579 /* We use char because int might match the return type of a gcc2
13580     builtin and then its argument prototype would still apply.  */
13581 char $ac_func();
13582
13583 int main() {
13584
13585 /* The GNU C library defines this for functions which it implements
13586     to always fail with ENOSYS.  Some functions are actually named
13587     something starting with __ and the normal name is an alias.  */
13588 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13589 choke me
13590 #else
13591 $ac_func();
13592 #endif
13593
13594 ; return 0; }
13595 EOF
13596 if { (eval echo configure:13597: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13597   rm -rf conftest*
13598   eval "ac_cv_func_$ac_func=yes"
13599 else
13600   echo "configure: failed program was:" >&5
13601   cat conftest.$ac_ext >&5
13602   rm -rf conftest*
13603   eval "ac_cv_func_$ac_func=no"
13604 fi
13605 rm -f conftest*
13606 fi
13607
13608 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13609   echo "$ac_t""yes" 1>&6
13610     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13611   cat >> confdefs.h <<EOF
13612 #define $ac_tr_func 1
13613 EOF
13614
13615 else
13616   echo "$ac_t""no" 1>&6
13617 fi
13618 done
13619
13620   fi
13621
13622
13623   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
13624 echo "configure:13625: checking for _sinhf declaration" >&5
13625   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
13626   echo $ac_n "(cached) $ac_c" 1>&6
13627 else
13628
13629
13630     ac_ext=C
13631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13632 ac_cpp='$CXXCPP $CPPFLAGS'
13633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13635 cross_compiling=$ac_cv_prog_cxx_cross
13636
13637     cat > conftest.$ac_ext <<EOF
13638 #line 13639 "configure"
13639 #include "confdefs.h"
13640 #include <math.h>
13641 int main() {
13642  _sinhf(0);
13643 ; return 0; }
13644 EOF
13645 if { (eval echo configure:13646: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13646   rm -rf conftest*
13647   glibcpp_cv_func__sinhf_use=yes
13648 else
13649   echo "configure: failed program was:" >&5
13650   cat conftest.$ac_ext >&5
13651   rm -rf conftest*
13652   glibcpp_cv_func__sinhf_use=no
13653 fi
13654 rm -f conftest*
13655     ac_ext=c
13656 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13657 ac_cpp='$CPP $CPPFLAGS'
13658 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13659 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13660 cross_compiling=$ac_cv_prog_cc_cross
13661
13662
13663 fi
13664
13665   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
13666   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
13667     for ac_func in _sinhf
13668 do
13669 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13670 echo "configure:13671: checking for $ac_func" >&5
13671 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13672   echo $ac_n "(cached) $ac_c" 1>&6
13673 else
13674   cat > conftest.$ac_ext <<EOF
13675 #line 13676 "configure"
13676 #include "confdefs.h"
13677 /* System header to define __stub macros and hopefully few prototypes,
13678     which can conflict with char $ac_func(); below.  */
13679 #include <assert.h>
13680 /* Override any gcc2 internal prototype to avoid an error.  */
13681 /* We use char because int might match the return type of a gcc2
13682     builtin and then its argument prototype would still apply.  */
13683 char $ac_func();
13684
13685 int main() {
13686
13687 /* The GNU C library defines this for functions which it implements
13688     to always fail with ENOSYS.  Some functions are actually named
13689     something starting with __ and the normal name is an alias.  */
13690 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13691 choke me
13692 #else
13693 $ac_func();
13694 #endif
13695
13696 ; return 0; }
13697 EOF
13698 if { (eval echo configure:13699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13699   rm -rf conftest*
13700   eval "ac_cv_func_$ac_func=yes"
13701 else
13702   echo "configure: failed program was:" >&5
13703   cat conftest.$ac_ext >&5
13704   rm -rf conftest*
13705   eval "ac_cv_func_$ac_func=no"
13706 fi
13707 rm -f conftest*
13708 fi
13709
13710 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13711   echo "$ac_t""yes" 1>&6
13712     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13713   cat >> confdefs.h <<EOF
13714 #define $ac_tr_func 1
13715 EOF
13716
13717 else
13718   echo "$ac_t""no" 1>&6
13719 fi
13720 done
13721
13722   fi
13723
13724
13725   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
13726 echo "configure:13727: checking for _sqrtf declaration" >&5
13727   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
13728   echo $ac_n "(cached) $ac_c" 1>&6
13729 else
13730
13731
13732     ac_ext=C
13733 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13734 ac_cpp='$CXXCPP $CPPFLAGS'
13735 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13736 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13737 cross_compiling=$ac_cv_prog_cxx_cross
13738
13739     cat > conftest.$ac_ext <<EOF
13740 #line 13741 "configure"
13741 #include "confdefs.h"
13742 #include <math.h>
13743 int main() {
13744  _sqrtf(0);
13745 ; return 0; }
13746 EOF
13747 if { (eval echo configure:13748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13748   rm -rf conftest*
13749   glibcpp_cv_func__sqrtf_use=yes
13750 else
13751   echo "configure: failed program was:" >&5
13752   cat conftest.$ac_ext >&5
13753   rm -rf conftest*
13754   glibcpp_cv_func__sqrtf_use=no
13755 fi
13756 rm -f conftest*
13757     ac_ext=c
13758 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13759 ac_cpp='$CPP $CPPFLAGS'
13760 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13761 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13762 cross_compiling=$ac_cv_prog_cc_cross
13763
13764
13765 fi
13766
13767   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
13768   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
13769     for ac_func in _sqrtf
13770 do
13771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13772 echo "configure:13773: checking for $ac_func" >&5
13773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13774   echo $ac_n "(cached) $ac_c" 1>&6
13775 else
13776   cat > conftest.$ac_ext <<EOF
13777 #line 13778 "configure"
13778 #include "confdefs.h"
13779 /* System header to define __stub macros and hopefully few prototypes,
13780     which can conflict with char $ac_func(); below.  */
13781 #include <assert.h>
13782 /* Override any gcc2 internal prototype to avoid an error.  */
13783 /* We use char because int might match the return type of a gcc2
13784     builtin and then its argument prototype would still apply.  */
13785 char $ac_func();
13786
13787 int main() {
13788
13789 /* The GNU C library defines this for functions which it implements
13790     to always fail with ENOSYS.  Some functions are actually named
13791     something starting with __ and the normal name is an alias.  */
13792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13793 choke me
13794 #else
13795 $ac_func();
13796 #endif
13797
13798 ; return 0; }
13799 EOF
13800 if { (eval echo configure:13801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13801   rm -rf conftest*
13802   eval "ac_cv_func_$ac_func=yes"
13803 else
13804   echo "configure: failed program was:" >&5
13805   cat conftest.$ac_ext >&5
13806   rm -rf conftest*
13807   eval "ac_cv_func_$ac_func=no"
13808 fi
13809 rm -f conftest*
13810 fi
13811
13812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13813   echo "$ac_t""yes" 1>&6
13814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13815   cat >> confdefs.h <<EOF
13816 #define $ac_tr_func 1
13817 EOF
13818
13819 else
13820   echo "$ac_t""no" 1>&6
13821 fi
13822 done
13823
13824   fi
13825
13826
13827   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
13828 echo "configure:13829: checking for _tanf declaration" >&5
13829   if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
13830   echo $ac_n "(cached) $ac_c" 1>&6
13831 else
13832
13833
13834     ac_ext=C
13835 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13836 ac_cpp='$CXXCPP $CPPFLAGS'
13837 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13838 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13839 cross_compiling=$ac_cv_prog_cxx_cross
13840
13841     cat > conftest.$ac_ext <<EOF
13842 #line 13843 "configure"
13843 #include "confdefs.h"
13844 #include <math.h>
13845 int main() {
13846  _tanf(0);
13847 ; return 0; }
13848 EOF
13849 if { (eval echo configure:13850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13850   rm -rf conftest*
13851   glibcpp_cv_func__tanf_use=yes
13852 else
13853   echo "configure: failed program was:" >&5
13854   cat conftest.$ac_ext >&5
13855   rm -rf conftest*
13856   glibcpp_cv_func__tanf_use=no
13857 fi
13858 rm -f conftest*
13859     ac_ext=c
13860 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13861 ac_cpp='$CPP $CPPFLAGS'
13862 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13863 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13864 cross_compiling=$ac_cv_prog_cc_cross
13865
13866
13867 fi
13868
13869   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
13870   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
13871     for ac_func in _tanf
13872 do
13873 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13874 echo "configure:13875: checking for $ac_func" >&5
13875 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13876   echo $ac_n "(cached) $ac_c" 1>&6
13877 else
13878   cat > conftest.$ac_ext <<EOF
13879 #line 13880 "configure"
13880 #include "confdefs.h"
13881 /* System header to define __stub macros and hopefully few prototypes,
13882     which can conflict with char $ac_func(); below.  */
13883 #include <assert.h>
13884 /* Override any gcc2 internal prototype to avoid an error.  */
13885 /* We use char because int might match the return type of a gcc2
13886     builtin and then its argument prototype would still apply.  */
13887 char $ac_func();
13888
13889 int main() {
13890
13891 /* The GNU C library defines this for functions which it implements
13892     to always fail with ENOSYS.  Some functions are actually named
13893     something starting with __ and the normal name is an alias.  */
13894 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13895 choke me
13896 #else
13897 $ac_func();
13898 #endif
13899
13900 ; return 0; }
13901 EOF
13902 if { (eval echo configure:13903: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13903   rm -rf conftest*
13904   eval "ac_cv_func_$ac_func=yes"
13905 else
13906   echo "configure: failed program was:" >&5
13907   cat conftest.$ac_ext >&5
13908   rm -rf conftest*
13909   eval "ac_cv_func_$ac_func=no"
13910 fi
13911 rm -f conftest*
13912 fi
13913
13914 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13915   echo "$ac_t""yes" 1>&6
13916     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13917   cat >> confdefs.h <<EOF
13918 #define $ac_tr_func 1
13919 EOF
13920
13921 else
13922   echo "$ac_t""no" 1>&6
13923 fi
13924 done
13925
13926   fi
13927
13928
13929   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
13930 echo "configure:13931: checking for _tanhf declaration" >&5
13931   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
13932   echo $ac_n "(cached) $ac_c" 1>&6
13933 else
13934
13935
13936     ac_ext=C
13937 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13938 ac_cpp='$CXXCPP $CPPFLAGS'
13939 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13940 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13941 cross_compiling=$ac_cv_prog_cxx_cross
13942
13943     cat > conftest.$ac_ext <<EOF
13944 #line 13945 "configure"
13945 #include "confdefs.h"
13946 #include <math.h>
13947 int main() {
13948  _tanhf(0);
13949 ; return 0; }
13950 EOF
13951 if { (eval echo configure:13952: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13952   rm -rf conftest*
13953   glibcpp_cv_func__tanhf_use=yes
13954 else
13955   echo "configure: failed program was:" >&5
13956   cat conftest.$ac_ext >&5
13957   rm -rf conftest*
13958   glibcpp_cv_func__tanhf_use=no
13959 fi
13960 rm -f conftest*
13961     ac_ext=c
13962 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13963 ac_cpp='$CPP $CPPFLAGS'
13964 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13965 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13966 cross_compiling=$ac_cv_prog_cc_cross
13967
13968
13969 fi
13970
13971   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
13972   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
13973     for ac_func in _tanhf
13974 do
13975 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13976 echo "configure:13977: checking for $ac_func" >&5
13977 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13978   echo $ac_n "(cached) $ac_c" 1>&6
13979 else
13980   cat > conftest.$ac_ext <<EOF
13981 #line 13982 "configure"
13982 #include "confdefs.h"
13983 /* System header to define __stub macros and hopefully few prototypes,
13984     which can conflict with char $ac_func(); below.  */
13985 #include <assert.h>
13986 /* Override any gcc2 internal prototype to avoid an error.  */
13987 /* We use char because int might match the return type of a gcc2
13988     builtin and then its argument prototype would still apply.  */
13989 char $ac_func();
13990
13991 int main() {
13992
13993 /* The GNU C library defines this for functions which it implements
13994     to always fail with ENOSYS.  Some functions are actually named
13995     something starting with __ and the normal name is an alias.  */
13996 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13997 choke me
13998 #else
13999 $ac_func();
14000 #endif
14001
14002 ; return 0; }
14003 EOF
14004 if { (eval echo configure:14005: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14005   rm -rf conftest*
14006   eval "ac_cv_func_$ac_func=yes"
14007 else
14008   echo "configure: failed program was:" >&5
14009   cat conftest.$ac_ext >&5
14010   rm -rf conftest*
14011   eval "ac_cv_func_$ac_func=no"
14012 fi
14013 rm -f conftest*
14014 fi
14015
14016 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14017   echo "$ac_t""yes" 1>&6
14018     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14019   cat >> confdefs.h <<EOF
14020 #define $ac_tr_func 1
14021 EOF
14022
14023 else
14024   echo "$ac_t""no" 1>&6
14025 fi
14026 done
14027
14028   fi
14029
14030
14031   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14032 echo "configure:14033: checking for _sincosf declaration" >&5
14033   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14034   echo $ac_n "(cached) $ac_c" 1>&6
14035 else
14036
14037
14038     ac_ext=C
14039 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14040 ac_cpp='$CXXCPP $CPPFLAGS'
14041 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14042 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14043 cross_compiling=$ac_cv_prog_cxx_cross
14044
14045     cat > conftest.$ac_ext <<EOF
14046 #line 14047 "configure"
14047 #include "confdefs.h"
14048 #include <math.h>
14049 int main() {
14050  _sincosf(0, 0, 0);
14051 ; return 0; }
14052 EOF
14053 if { (eval echo configure:14054: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14054   rm -rf conftest*
14055   glibcpp_cv_func__sincosf_use=yes
14056 else
14057   echo "configure: failed program was:" >&5
14058   cat conftest.$ac_ext >&5
14059   rm -rf conftest*
14060   glibcpp_cv_func__sincosf_use=no
14061 fi
14062 rm -f conftest*
14063     ac_ext=c
14064 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14065 ac_cpp='$CPP $CPPFLAGS'
14066 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14067 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14068 cross_compiling=$ac_cv_prog_cc_cross
14069
14070
14071 fi
14072
14073   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
14074   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
14075     for ac_func in _sincosf
14076 do
14077 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14078 echo "configure:14079: checking for $ac_func" >&5
14079 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14080   echo $ac_n "(cached) $ac_c" 1>&6
14081 else
14082   cat > conftest.$ac_ext <<EOF
14083 #line 14084 "configure"
14084 #include "confdefs.h"
14085 /* System header to define __stub macros and hopefully few prototypes,
14086     which can conflict with char $ac_func(); below.  */
14087 #include <assert.h>
14088 /* Override any gcc2 internal prototype to avoid an error.  */
14089 /* We use char because int might match the return type of a gcc2
14090     builtin and then its argument prototype would still apply.  */
14091 char $ac_func();
14092
14093 int main() {
14094
14095 /* The GNU C library defines this for functions which it implements
14096     to always fail with ENOSYS.  Some functions are actually named
14097     something starting with __ and the normal name is an alias.  */
14098 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14099 choke me
14100 #else
14101 $ac_func();
14102 #endif
14103
14104 ; return 0; }
14105 EOF
14106 if { (eval echo configure:14107: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14107   rm -rf conftest*
14108   eval "ac_cv_func_$ac_func=yes"
14109 else
14110   echo "configure: failed program was:" >&5
14111   cat conftest.$ac_ext >&5
14112   rm -rf conftest*
14113   eval "ac_cv_func_$ac_func=no"
14114 fi
14115 rm -f conftest*
14116 fi
14117
14118 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14119   echo "$ac_t""yes" 1>&6
14120     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14121   cat >> confdefs.h <<EOF
14122 #define $ac_tr_func 1
14123 EOF
14124
14125 else
14126   echo "$ac_t""no" 1>&6
14127 fi
14128 done
14129
14130   fi
14131
14132
14133   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
14134 echo "configure:14135: checking for _finitef declaration" >&5
14135   if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
14136   echo $ac_n "(cached) $ac_c" 1>&6
14137 else
14138
14139
14140     ac_ext=C
14141 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14142 ac_cpp='$CXXCPP $CPPFLAGS'
14143 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14144 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14145 cross_compiling=$ac_cv_prog_cxx_cross
14146
14147     cat > conftest.$ac_ext <<EOF
14148 #line 14149 "configure"
14149 #include "confdefs.h"
14150 #include <math.h>
14151 int main() {
14152  _finitef(0);
14153 ; return 0; }
14154 EOF
14155 if { (eval echo configure:14156: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14156   rm -rf conftest*
14157   glibcpp_cv_func__finitef_use=yes
14158 else
14159   echo "configure: failed program was:" >&5
14160   cat conftest.$ac_ext >&5
14161   rm -rf conftest*
14162   glibcpp_cv_func__finitef_use=no
14163 fi
14164 rm -f conftest*
14165     ac_ext=c
14166 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14167 ac_cpp='$CPP $CPPFLAGS'
14168 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14169 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14170 cross_compiling=$ac_cv_prog_cc_cross
14171
14172
14173 fi
14174
14175   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
14176   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
14177     for ac_func in _finitef
14178 do
14179 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14180 echo "configure:14181: checking for $ac_func" >&5
14181 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14182   echo $ac_n "(cached) $ac_c" 1>&6
14183 else
14184   cat > conftest.$ac_ext <<EOF
14185 #line 14186 "configure"
14186 #include "confdefs.h"
14187 /* System header to define __stub macros and hopefully few prototypes,
14188     which can conflict with char $ac_func(); below.  */
14189 #include <assert.h>
14190 /* Override any gcc2 internal prototype to avoid an error.  */
14191 /* We use char because int might match the return type of a gcc2
14192     builtin and then its argument prototype would still apply.  */
14193 char $ac_func();
14194
14195 int main() {
14196
14197 /* The GNU C library defines this for functions which it implements
14198     to always fail with ENOSYS.  Some functions are actually named
14199     something starting with __ and the normal name is an alias.  */
14200 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14201 choke me
14202 #else
14203 $ac_func();
14204 #endif
14205
14206 ; return 0; }
14207 EOF
14208 if { (eval echo configure:14209: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14209   rm -rf conftest*
14210   eval "ac_cv_func_$ac_func=yes"
14211 else
14212   echo "configure: failed program was:" >&5
14213   cat conftest.$ac_ext >&5
14214   rm -rf conftest*
14215   eval "ac_cv_func_$ac_func=no"
14216 fi
14217 rm -f conftest*
14218 fi
14219
14220 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14221   echo "$ac_t""yes" 1>&6
14222     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14223   cat >> confdefs.h <<EOF
14224 #define $ac_tr_func 1
14225 EOF
14226
14227 else
14228   echo "$ac_t""no" 1>&6
14229 fi
14230 done
14231
14232   fi
14233
14234
14235
14236   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
14237 echo "configure:14238: checking for _isnanl declaration" >&5
14238   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
14239   echo $ac_n "(cached) $ac_c" 1>&6
14240 else
14241
14242
14243     ac_ext=C
14244 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14245 ac_cpp='$CXXCPP $CPPFLAGS'
14246 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14247 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14248 cross_compiling=$ac_cv_prog_cxx_cross
14249
14250     cat > conftest.$ac_ext <<EOF
14251 #line 14252 "configure"
14252 #include "confdefs.h"
14253 #include <math.h>
14254 int main() {
14255  _isnanl(0);
14256 ; return 0; }
14257 EOF
14258 if { (eval echo configure:14259: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14259   rm -rf conftest*
14260   glibcpp_cv_func__isnanl_use=yes
14261 else
14262   echo "configure: failed program was:" >&5
14263   cat conftest.$ac_ext >&5
14264   rm -rf conftest*
14265   glibcpp_cv_func__isnanl_use=no
14266 fi
14267 rm -f conftest*
14268     ac_ext=c
14269 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14270 ac_cpp='$CPP $CPPFLAGS'
14271 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14272 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14273 cross_compiling=$ac_cv_prog_cc_cross
14274
14275
14276 fi
14277
14278   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
14279   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
14280     for ac_func in _isnanl
14281 do
14282 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14283 echo "configure:14284: checking for $ac_func" >&5
14284 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14285   echo $ac_n "(cached) $ac_c" 1>&6
14286 else
14287   cat > conftest.$ac_ext <<EOF
14288 #line 14289 "configure"
14289 #include "confdefs.h"
14290 /* System header to define __stub macros and hopefully few prototypes,
14291     which can conflict with char $ac_func(); below.  */
14292 #include <assert.h>
14293 /* Override any gcc2 internal prototype to avoid an error.  */
14294 /* We use char because int might match the return type of a gcc2
14295     builtin and then its argument prototype would still apply.  */
14296 char $ac_func();
14297
14298 int main() {
14299
14300 /* The GNU C library defines this for functions which it implements
14301     to always fail with ENOSYS.  Some functions are actually named
14302     something starting with __ and the normal name is an alias.  */
14303 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14304 choke me
14305 #else
14306 $ac_func();
14307 #endif
14308
14309 ; return 0; }
14310 EOF
14311 if { (eval echo configure:14312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14312   rm -rf conftest*
14313   eval "ac_cv_func_$ac_func=yes"
14314 else
14315   echo "configure: failed program was:" >&5
14316   cat conftest.$ac_ext >&5
14317   rm -rf conftest*
14318   eval "ac_cv_func_$ac_func=no"
14319 fi
14320 rm -f conftest*
14321 fi
14322
14323 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14324   echo "$ac_t""yes" 1>&6
14325     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14326   cat >> confdefs.h <<EOF
14327 #define $ac_tr_func 1
14328 EOF
14329
14330 else
14331   echo "$ac_t""no" 1>&6
14332 fi
14333 done
14334
14335   fi
14336
14337
14338   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
14339 echo "configure:14340: checking for _isinfl declaration" >&5
14340   if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
14341   echo $ac_n "(cached) $ac_c" 1>&6
14342 else
14343
14344
14345     ac_ext=C
14346 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14347 ac_cpp='$CXXCPP $CPPFLAGS'
14348 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14349 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14350 cross_compiling=$ac_cv_prog_cxx_cross
14351
14352     cat > conftest.$ac_ext <<EOF
14353 #line 14354 "configure"
14354 #include "confdefs.h"
14355 #include <math.h>
14356 int main() {
14357  _isinfl(0);
14358 ; return 0; }
14359 EOF
14360 if { (eval echo configure:14361: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14361   rm -rf conftest*
14362   glibcpp_cv_func__isinfl_use=yes
14363 else
14364   echo "configure: failed program was:" >&5
14365   cat conftest.$ac_ext >&5
14366   rm -rf conftest*
14367   glibcpp_cv_func__isinfl_use=no
14368 fi
14369 rm -f conftest*
14370     ac_ext=c
14371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14372 ac_cpp='$CPP $CPPFLAGS'
14373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14375 cross_compiling=$ac_cv_prog_cc_cross
14376
14377
14378 fi
14379
14380   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
14381   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
14382     for ac_func in _isinfl
14383 do
14384 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14385 echo "configure:14386: checking for $ac_func" >&5
14386 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14387   echo $ac_n "(cached) $ac_c" 1>&6
14388 else
14389   cat > conftest.$ac_ext <<EOF
14390 #line 14391 "configure"
14391 #include "confdefs.h"
14392 /* System header to define __stub macros and hopefully few prototypes,
14393     which can conflict with char $ac_func(); below.  */
14394 #include <assert.h>
14395 /* Override any gcc2 internal prototype to avoid an error.  */
14396 /* We use char because int might match the return type of a gcc2
14397     builtin and then its argument prototype would still apply.  */
14398 char $ac_func();
14399
14400 int main() {
14401
14402 /* The GNU C library defines this for functions which it implements
14403     to always fail with ENOSYS.  Some functions are actually named
14404     something starting with __ and the normal name is an alias.  */
14405 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14406 choke me
14407 #else
14408 $ac_func();
14409 #endif
14410
14411 ; return 0; }
14412 EOF
14413 if { (eval echo configure:14414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14414   rm -rf conftest*
14415   eval "ac_cv_func_$ac_func=yes"
14416 else
14417   echo "configure: failed program was:" >&5
14418   cat conftest.$ac_ext >&5
14419   rm -rf conftest*
14420   eval "ac_cv_func_$ac_func=no"
14421 fi
14422 rm -f conftest*
14423 fi
14424
14425 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14426   echo "$ac_t""yes" 1>&6
14427     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14428   cat >> confdefs.h <<EOF
14429 #define $ac_tr_func 1
14430 EOF
14431
14432 else
14433   echo "$ac_t""no" 1>&6
14434 fi
14435 done
14436
14437   fi
14438
14439
14440   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
14441 echo "configure:14442: checking for _copysignl declaration" >&5
14442   if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
14443   echo $ac_n "(cached) $ac_c" 1>&6
14444 else
14445
14446
14447     ac_ext=C
14448 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14449 ac_cpp='$CXXCPP $CPPFLAGS'
14450 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14451 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14452 cross_compiling=$ac_cv_prog_cxx_cross
14453
14454     cat > conftest.$ac_ext <<EOF
14455 #line 14456 "configure"
14456 #include "confdefs.h"
14457 #include <math.h>
14458 int main() {
14459  _copysignl(0, 0);
14460 ; return 0; }
14461 EOF
14462 if { (eval echo configure:14463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14463   rm -rf conftest*
14464   glibcpp_cv_func__copysignl_use=yes
14465 else
14466   echo "configure: failed program was:" >&5
14467   cat conftest.$ac_ext >&5
14468   rm -rf conftest*
14469   glibcpp_cv_func__copysignl_use=no
14470 fi
14471 rm -f conftest*
14472     ac_ext=c
14473 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14474 ac_cpp='$CPP $CPPFLAGS'
14475 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14476 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14477 cross_compiling=$ac_cv_prog_cc_cross
14478
14479
14480 fi
14481
14482   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
14483   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
14484     for ac_func in _copysignl
14485 do
14486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14487 echo "configure:14488: checking for $ac_func" >&5
14488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14489   echo $ac_n "(cached) $ac_c" 1>&6
14490 else
14491   cat > conftest.$ac_ext <<EOF
14492 #line 14493 "configure"
14493 #include "confdefs.h"
14494 /* System header to define __stub macros and hopefully few prototypes,
14495     which can conflict with char $ac_func(); below.  */
14496 #include <assert.h>
14497 /* Override any gcc2 internal prototype to avoid an error.  */
14498 /* We use char because int might match the return type of a gcc2
14499     builtin and then its argument prototype would still apply.  */
14500 char $ac_func();
14501
14502 int main() {
14503
14504 /* The GNU C library defines this for functions which it implements
14505     to always fail with ENOSYS.  Some functions are actually named
14506     something starting with __ and the normal name is an alias.  */
14507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14508 choke me
14509 #else
14510 $ac_func();
14511 #endif
14512
14513 ; return 0; }
14514 EOF
14515 if { (eval echo configure:14516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14516   rm -rf conftest*
14517   eval "ac_cv_func_$ac_func=yes"
14518 else
14519   echo "configure: failed program was:" >&5
14520   cat conftest.$ac_ext >&5
14521   rm -rf conftest*
14522   eval "ac_cv_func_$ac_func=no"
14523 fi
14524 rm -f conftest*
14525 fi
14526
14527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14528   echo "$ac_t""yes" 1>&6
14529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14530   cat >> confdefs.h <<EOF
14531 #define $ac_tr_func 1
14532 EOF
14533
14534 else
14535   echo "$ac_t""no" 1>&6
14536 fi
14537 done
14538
14539   fi
14540
14541
14542   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14543 echo "configure:14544: checking for _acosl declaration" >&5
14544   if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
14545   echo $ac_n "(cached) $ac_c" 1>&6
14546 else
14547
14548
14549     ac_ext=C
14550 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14551 ac_cpp='$CXXCPP $CPPFLAGS'
14552 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14553 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14554 cross_compiling=$ac_cv_prog_cxx_cross
14555
14556     cat > conftest.$ac_ext <<EOF
14557 #line 14558 "configure"
14558 #include "confdefs.h"
14559 #include <math.h>
14560 int main() {
14561  _acosl(0);
14562 ; return 0; }
14563 EOF
14564 if { (eval echo configure:14565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14565   rm -rf conftest*
14566   glibcpp_cv_func__acosl_use=yes
14567 else
14568   echo "configure: failed program was:" >&5
14569   cat conftest.$ac_ext >&5
14570   rm -rf conftest*
14571   glibcpp_cv_func__acosl_use=no
14572 fi
14573 rm -f conftest*
14574     ac_ext=c
14575 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14576 ac_cpp='$CPP $CPPFLAGS'
14577 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14578 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14579 cross_compiling=$ac_cv_prog_cc_cross
14580
14581
14582 fi
14583
14584   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
14585   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
14586     for ac_func in _acosl
14587 do
14588 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14589 echo "configure:14590: checking for $ac_func" >&5
14590 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14591   echo $ac_n "(cached) $ac_c" 1>&6
14592 else
14593   cat > conftest.$ac_ext <<EOF
14594 #line 14595 "configure"
14595 #include "confdefs.h"
14596 /* System header to define __stub macros and hopefully few prototypes,
14597     which can conflict with char $ac_func(); below.  */
14598 #include <assert.h>
14599 /* Override any gcc2 internal prototype to avoid an error.  */
14600 /* We use char because int might match the return type of a gcc2
14601     builtin and then its argument prototype would still apply.  */
14602 char $ac_func();
14603
14604 int main() {
14605
14606 /* The GNU C library defines this for functions which it implements
14607     to always fail with ENOSYS.  Some functions are actually named
14608     something starting with __ and the normal name is an alias.  */
14609 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14610 choke me
14611 #else
14612 $ac_func();
14613 #endif
14614
14615 ; return 0; }
14616 EOF
14617 if { (eval echo configure:14618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14618   rm -rf conftest*
14619   eval "ac_cv_func_$ac_func=yes"
14620 else
14621   echo "configure: failed program was:" >&5
14622   cat conftest.$ac_ext >&5
14623   rm -rf conftest*
14624   eval "ac_cv_func_$ac_func=no"
14625 fi
14626 rm -f conftest*
14627 fi
14628
14629 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14630   echo "$ac_t""yes" 1>&6
14631     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14632   cat >> confdefs.h <<EOF
14633 #define $ac_tr_func 1
14634 EOF
14635
14636 else
14637   echo "$ac_t""no" 1>&6
14638 fi
14639 done
14640
14641   fi
14642
14643
14644   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14645 echo "configure:14646: checking for _asinl declaration" >&5
14646   if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
14647   echo $ac_n "(cached) $ac_c" 1>&6
14648 else
14649
14650
14651     ac_ext=C
14652 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14653 ac_cpp='$CXXCPP $CPPFLAGS'
14654 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14655 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14656 cross_compiling=$ac_cv_prog_cxx_cross
14657
14658     cat > conftest.$ac_ext <<EOF
14659 #line 14660 "configure"
14660 #include "confdefs.h"
14661 #include <math.h>
14662 int main() {
14663  _asinl(0);
14664 ; return 0; }
14665 EOF
14666 if { (eval echo configure:14667: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14667   rm -rf conftest*
14668   glibcpp_cv_func__asinl_use=yes
14669 else
14670   echo "configure: failed program was:" >&5
14671   cat conftest.$ac_ext >&5
14672   rm -rf conftest*
14673   glibcpp_cv_func__asinl_use=no
14674 fi
14675 rm -f conftest*
14676     ac_ext=c
14677 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14678 ac_cpp='$CPP $CPPFLAGS'
14679 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14680 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14681 cross_compiling=$ac_cv_prog_cc_cross
14682
14683
14684 fi
14685
14686   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
14687   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
14688     for ac_func in _asinl
14689 do
14690 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14691 echo "configure:14692: checking for $ac_func" >&5
14692 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14693   echo $ac_n "(cached) $ac_c" 1>&6
14694 else
14695   cat > conftest.$ac_ext <<EOF
14696 #line 14697 "configure"
14697 #include "confdefs.h"
14698 /* System header to define __stub macros and hopefully few prototypes,
14699     which can conflict with char $ac_func(); below.  */
14700 #include <assert.h>
14701 /* Override any gcc2 internal prototype to avoid an error.  */
14702 /* We use char because int might match the return type of a gcc2
14703     builtin and then its argument prototype would still apply.  */
14704 char $ac_func();
14705
14706 int main() {
14707
14708 /* The GNU C library defines this for functions which it implements
14709     to always fail with ENOSYS.  Some functions are actually named
14710     something starting with __ and the normal name is an alias.  */
14711 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14712 choke me
14713 #else
14714 $ac_func();
14715 #endif
14716
14717 ; return 0; }
14718 EOF
14719 if { (eval echo configure:14720: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14720   rm -rf conftest*
14721   eval "ac_cv_func_$ac_func=yes"
14722 else
14723   echo "configure: failed program was:" >&5
14724   cat conftest.$ac_ext >&5
14725   rm -rf conftest*
14726   eval "ac_cv_func_$ac_func=no"
14727 fi
14728 rm -f conftest*
14729 fi
14730
14731 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14732   echo "$ac_t""yes" 1>&6
14733     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14734   cat >> confdefs.h <<EOF
14735 #define $ac_tr_func 1
14736 EOF
14737
14738 else
14739   echo "$ac_t""no" 1>&6
14740 fi
14741 done
14742
14743   fi
14744
14745
14746   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14747 echo "configure:14748: checking for _atanl declaration" >&5
14748   if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
14749   echo $ac_n "(cached) $ac_c" 1>&6
14750 else
14751
14752
14753     ac_ext=C
14754 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14755 ac_cpp='$CXXCPP $CPPFLAGS'
14756 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14757 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14758 cross_compiling=$ac_cv_prog_cxx_cross
14759
14760     cat > conftest.$ac_ext <<EOF
14761 #line 14762 "configure"
14762 #include "confdefs.h"
14763 #include <math.h>
14764 int main() {
14765  _atanl(0);
14766 ; return 0; }
14767 EOF
14768 if { (eval echo configure:14769: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14769   rm -rf conftest*
14770   glibcpp_cv_func__atanl_use=yes
14771 else
14772   echo "configure: failed program was:" >&5
14773   cat conftest.$ac_ext >&5
14774   rm -rf conftest*
14775   glibcpp_cv_func__atanl_use=no
14776 fi
14777 rm -f conftest*
14778     ac_ext=c
14779 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14780 ac_cpp='$CPP $CPPFLAGS'
14781 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14782 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14783 cross_compiling=$ac_cv_prog_cc_cross
14784
14785
14786 fi
14787
14788   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
14789   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
14790     for ac_func in _atanl
14791 do
14792 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14793 echo "configure:14794: checking for $ac_func" >&5
14794 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14795   echo $ac_n "(cached) $ac_c" 1>&6
14796 else
14797   cat > conftest.$ac_ext <<EOF
14798 #line 14799 "configure"
14799 #include "confdefs.h"
14800 /* System header to define __stub macros and hopefully few prototypes,
14801     which can conflict with char $ac_func(); below.  */
14802 #include <assert.h>
14803 /* Override any gcc2 internal prototype to avoid an error.  */
14804 /* We use char because int might match the return type of a gcc2
14805     builtin and then its argument prototype would still apply.  */
14806 char $ac_func();
14807
14808 int main() {
14809
14810 /* The GNU C library defines this for functions which it implements
14811     to always fail with ENOSYS.  Some functions are actually named
14812     something starting with __ and the normal name is an alias.  */
14813 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14814 choke me
14815 #else
14816 $ac_func();
14817 #endif
14818
14819 ; return 0; }
14820 EOF
14821 if { (eval echo configure:14822: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14822   rm -rf conftest*
14823   eval "ac_cv_func_$ac_func=yes"
14824 else
14825   echo "configure: failed program was:" >&5
14826   cat conftest.$ac_ext >&5
14827   rm -rf conftest*
14828   eval "ac_cv_func_$ac_func=no"
14829 fi
14830 rm -f conftest*
14831 fi
14832
14833 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14834   echo "$ac_t""yes" 1>&6
14835     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14836   cat >> confdefs.h <<EOF
14837 #define $ac_tr_func 1
14838 EOF
14839
14840 else
14841   echo "$ac_t""no" 1>&6
14842 fi
14843 done
14844
14845   fi
14846
14847
14848   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14849 echo "configure:14850: checking for _atan2l declaration" >&5
14850   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
14851   echo $ac_n "(cached) $ac_c" 1>&6
14852 else
14853
14854
14855     ac_ext=C
14856 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14857 ac_cpp='$CXXCPP $CPPFLAGS'
14858 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14859 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14860 cross_compiling=$ac_cv_prog_cxx_cross
14861
14862     cat > conftest.$ac_ext <<EOF
14863 #line 14864 "configure"
14864 #include "confdefs.h"
14865 #include <math.h>
14866 int main() {
14867  _atan2l(0, 0);
14868 ; return 0; }
14869 EOF
14870 if { (eval echo configure:14871: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14871   rm -rf conftest*
14872   glibcpp_cv_func__atan2l_use=yes
14873 else
14874   echo "configure: failed program was:" >&5
14875   cat conftest.$ac_ext >&5
14876   rm -rf conftest*
14877   glibcpp_cv_func__atan2l_use=no
14878 fi
14879 rm -f conftest*
14880     ac_ext=c
14881 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14882 ac_cpp='$CPP $CPPFLAGS'
14883 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14884 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14885 cross_compiling=$ac_cv_prog_cc_cross
14886
14887
14888 fi
14889
14890   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
14891   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
14892     for ac_func in _atan2l
14893 do
14894 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14895 echo "configure:14896: checking for $ac_func" >&5
14896 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14897   echo $ac_n "(cached) $ac_c" 1>&6
14898 else
14899   cat > conftest.$ac_ext <<EOF
14900 #line 14901 "configure"
14901 #include "confdefs.h"
14902 /* System header to define __stub macros and hopefully few prototypes,
14903     which can conflict with char $ac_func(); below.  */
14904 #include <assert.h>
14905 /* Override any gcc2 internal prototype to avoid an error.  */
14906 /* We use char because int might match the return type of a gcc2
14907     builtin and then its argument prototype would still apply.  */
14908 char $ac_func();
14909
14910 int main() {
14911
14912 /* The GNU C library defines this for functions which it implements
14913     to always fail with ENOSYS.  Some functions are actually named
14914     something starting with __ and the normal name is an alias.  */
14915 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14916 choke me
14917 #else
14918 $ac_func();
14919 #endif
14920
14921 ; return 0; }
14922 EOF
14923 if { (eval echo configure:14924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14924   rm -rf conftest*
14925   eval "ac_cv_func_$ac_func=yes"
14926 else
14927   echo "configure: failed program was:" >&5
14928   cat conftest.$ac_ext >&5
14929   rm -rf conftest*
14930   eval "ac_cv_func_$ac_func=no"
14931 fi
14932 rm -f conftest*
14933 fi
14934
14935 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14936   echo "$ac_t""yes" 1>&6
14937     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14938   cat >> confdefs.h <<EOF
14939 #define $ac_tr_func 1
14940 EOF
14941
14942 else
14943   echo "$ac_t""no" 1>&6
14944 fi
14945 done
14946
14947   fi
14948
14949
14950   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
14951 echo "configure:14952: checking for _ceill declaration" >&5
14952   if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
14953   echo $ac_n "(cached) $ac_c" 1>&6
14954 else
14955
14956
14957     ac_ext=C
14958 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14959 ac_cpp='$CXXCPP $CPPFLAGS'
14960 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14961 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14962 cross_compiling=$ac_cv_prog_cxx_cross
14963
14964     cat > conftest.$ac_ext <<EOF
14965 #line 14966 "configure"
14966 #include "confdefs.h"
14967 #include <math.h>
14968 int main() {
14969  _ceill(0);
14970 ; return 0; }
14971 EOF
14972 if { (eval echo configure:14973: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14973   rm -rf conftest*
14974   glibcpp_cv_func__ceill_use=yes
14975 else
14976   echo "configure: failed program was:" >&5
14977   cat conftest.$ac_ext >&5
14978   rm -rf conftest*
14979   glibcpp_cv_func__ceill_use=no
14980 fi
14981 rm -f conftest*
14982     ac_ext=c
14983 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14984 ac_cpp='$CPP $CPPFLAGS'
14985 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14986 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14987 cross_compiling=$ac_cv_prog_cc_cross
14988
14989
14990 fi
14991
14992   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
14993   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
14994     for ac_func in _ceill
14995 do
14996 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14997 echo "configure:14998: checking for $ac_func" >&5
14998 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14999   echo $ac_n "(cached) $ac_c" 1>&6
15000 else
15001   cat > conftest.$ac_ext <<EOF
15002 #line 15003 "configure"
15003 #include "confdefs.h"
15004 /* System header to define __stub macros and hopefully few prototypes,
15005     which can conflict with char $ac_func(); below.  */
15006 #include <assert.h>
15007 /* Override any gcc2 internal prototype to avoid an error.  */
15008 /* We use char because int might match the return type of a gcc2
15009     builtin and then its argument prototype would still apply.  */
15010 char $ac_func();
15011
15012 int main() {
15013
15014 /* The GNU C library defines this for functions which it implements
15015     to always fail with ENOSYS.  Some functions are actually named
15016     something starting with __ and the normal name is an alias.  */
15017 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15018 choke me
15019 #else
15020 $ac_func();
15021 #endif
15022
15023 ; return 0; }
15024 EOF
15025 if { (eval echo configure:15026: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15026   rm -rf conftest*
15027   eval "ac_cv_func_$ac_func=yes"
15028 else
15029   echo "configure: failed program was:" >&5
15030   cat conftest.$ac_ext >&5
15031   rm -rf conftest*
15032   eval "ac_cv_func_$ac_func=no"
15033 fi
15034 rm -f conftest*
15035 fi
15036
15037 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15038   echo "$ac_t""yes" 1>&6
15039     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15040   cat >> confdefs.h <<EOF
15041 #define $ac_tr_func 1
15042 EOF
15043
15044 else
15045   echo "$ac_t""no" 1>&6
15046 fi
15047 done
15048
15049   fi
15050
15051
15052   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
15053 echo "configure:15054: checking for _cosl declaration" >&5
15054   if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
15055   echo $ac_n "(cached) $ac_c" 1>&6
15056 else
15057
15058
15059     ac_ext=C
15060 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15061 ac_cpp='$CXXCPP $CPPFLAGS'
15062 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15063 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15064 cross_compiling=$ac_cv_prog_cxx_cross
15065
15066     cat > conftest.$ac_ext <<EOF
15067 #line 15068 "configure"
15068 #include "confdefs.h"
15069 #include <math.h>
15070 int main() {
15071  _cosl(0);
15072 ; return 0; }
15073 EOF
15074 if { (eval echo configure:15075: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15075   rm -rf conftest*
15076   glibcpp_cv_func__cosl_use=yes
15077 else
15078   echo "configure: failed program was:" >&5
15079   cat conftest.$ac_ext >&5
15080   rm -rf conftest*
15081   glibcpp_cv_func__cosl_use=no
15082 fi
15083 rm -f conftest*
15084     ac_ext=c
15085 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15086 ac_cpp='$CPP $CPPFLAGS'
15087 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15088 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15089 cross_compiling=$ac_cv_prog_cc_cross
15090
15091
15092 fi
15093
15094   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
15095   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
15096     for ac_func in _cosl
15097 do
15098 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15099 echo "configure:15100: checking for $ac_func" >&5
15100 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15101   echo $ac_n "(cached) $ac_c" 1>&6
15102 else
15103   cat > conftest.$ac_ext <<EOF
15104 #line 15105 "configure"
15105 #include "confdefs.h"
15106 /* System header to define __stub macros and hopefully few prototypes,
15107     which can conflict with char $ac_func(); below.  */
15108 #include <assert.h>
15109 /* Override any gcc2 internal prototype to avoid an error.  */
15110 /* We use char because int might match the return type of a gcc2
15111     builtin and then its argument prototype would still apply.  */
15112 char $ac_func();
15113
15114 int main() {
15115
15116 /* The GNU C library defines this for functions which it implements
15117     to always fail with ENOSYS.  Some functions are actually named
15118     something starting with __ and the normal name is an alias.  */
15119 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15120 choke me
15121 #else
15122 $ac_func();
15123 #endif
15124
15125 ; return 0; }
15126 EOF
15127 if { (eval echo configure:15128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15128   rm -rf conftest*
15129   eval "ac_cv_func_$ac_func=yes"
15130 else
15131   echo "configure: failed program was:" >&5
15132   cat conftest.$ac_ext >&5
15133   rm -rf conftest*
15134   eval "ac_cv_func_$ac_func=no"
15135 fi
15136 rm -f conftest*
15137 fi
15138
15139 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15140   echo "$ac_t""yes" 1>&6
15141     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15142   cat >> confdefs.h <<EOF
15143 #define $ac_tr_func 1
15144 EOF
15145
15146 else
15147   echo "$ac_t""no" 1>&6
15148 fi
15149 done
15150
15151   fi
15152
15153
15154   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
15155 echo "configure:15156: checking for _coshl declaration" >&5
15156   if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
15157   echo $ac_n "(cached) $ac_c" 1>&6
15158 else
15159
15160
15161     ac_ext=C
15162 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15163 ac_cpp='$CXXCPP $CPPFLAGS'
15164 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15165 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15166 cross_compiling=$ac_cv_prog_cxx_cross
15167
15168     cat > conftest.$ac_ext <<EOF
15169 #line 15170 "configure"
15170 #include "confdefs.h"
15171 #include <math.h>
15172 int main() {
15173  _coshl(0);
15174 ; return 0; }
15175 EOF
15176 if { (eval echo configure:15177: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15177   rm -rf conftest*
15178   glibcpp_cv_func__coshl_use=yes
15179 else
15180   echo "configure: failed program was:" >&5
15181   cat conftest.$ac_ext >&5
15182   rm -rf conftest*
15183   glibcpp_cv_func__coshl_use=no
15184 fi
15185 rm -f conftest*
15186     ac_ext=c
15187 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15188 ac_cpp='$CPP $CPPFLAGS'
15189 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15190 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15191 cross_compiling=$ac_cv_prog_cc_cross
15192
15193
15194 fi
15195
15196   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
15197   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
15198     for ac_func in _coshl
15199 do
15200 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15201 echo "configure:15202: checking for $ac_func" >&5
15202 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15203   echo $ac_n "(cached) $ac_c" 1>&6
15204 else
15205   cat > conftest.$ac_ext <<EOF
15206 #line 15207 "configure"
15207 #include "confdefs.h"
15208 /* System header to define __stub macros and hopefully few prototypes,
15209     which can conflict with char $ac_func(); below.  */
15210 #include <assert.h>
15211 /* Override any gcc2 internal prototype to avoid an error.  */
15212 /* We use char because int might match the return type of a gcc2
15213     builtin and then its argument prototype would still apply.  */
15214 char $ac_func();
15215
15216 int main() {
15217
15218 /* The GNU C library defines this for functions which it implements
15219     to always fail with ENOSYS.  Some functions are actually named
15220     something starting with __ and the normal name is an alias.  */
15221 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15222 choke me
15223 #else
15224 $ac_func();
15225 #endif
15226
15227 ; return 0; }
15228 EOF
15229 if { (eval echo configure:15230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15230   rm -rf conftest*
15231   eval "ac_cv_func_$ac_func=yes"
15232 else
15233   echo "configure: failed program was:" >&5
15234   cat conftest.$ac_ext >&5
15235   rm -rf conftest*
15236   eval "ac_cv_func_$ac_func=no"
15237 fi
15238 rm -f conftest*
15239 fi
15240
15241 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15242   echo "$ac_t""yes" 1>&6
15243     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15244   cat >> confdefs.h <<EOF
15245 #define $ac_tr_func 1
15246 EOF
15247
15248 else
15249   echo "$ac_t""no" 1>&6
15250 fi
15251 done
15252
15253   fi
15254
15255
15256   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
15257 echo "configure:15258: checking for _expl declaration" >&5
15258   if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
15259   echo $ac_n "(cached) $ac_c" 1>&6
15260 else
15261
15262
15263     ac_ext=C
15264 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15265 ac_cpp='$CXXCPP $CPPFLAGS'
15266 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15267 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15268 cross_compiling=$ac_cv_prog_cxx_cross
15269
15270     cat > conftest.$ac_ext <<EOF
15271 #line 15272 "configure"
15272 #include "confdefs.h"
15273 #include <math.h>
15274 int main() {
15275  _expl(0);
15276 ; return 0; }
15277 EOF
15278 if { (eval echo configure:15279: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15279   rm -rf conftest*
15280   glibcpp_cv_func__expl_use=yes
15281 else
15282   echo "configure: failed program was:" >&5
15283   cat conftest.$ac_ext >&5
15284   rm -rf conftest*
15285   glibcpp_cv_func__expl_use=no
15286 fi
15287 rm -f conftest*
15288     ac_ext=c
15289 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15290 ac_cpp='$CPP $CPPFLAGS'
15291 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15292 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15293 cross_compiling=$ac_cv_prog_cc_cross
15294
15295
15296 fi
15297
15298   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
15299   if test x$glibcpp_cv_func__expl_use = x"yes"; then
15300     for ac_func in _expl
15301 do
15302 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15303 echo "configure:15304: checking for $ac_func" >&5
15304 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15305   echo $ac_n "(cached) $ac_c" 1>&6
15306 else
15307   cat > conftest.$ac_ext <<EOF
15308 #line 15309 "configure"
15309 #include "confdefs.h"
15310 /* System header to define __stub macros and hopefully few prototypes,
15311     which can conflict with char $ac_func(); below.  */
15312 #include <assert.h>
15313 /* Override any gcc2 internal prototype to avoid an error.  */
15314 /* We use char because int might match the return type of a gcc2
15315     builtin and then its argument prototype would still apply.  */
15316 char $ac_func();
15317
15318 int main() {
15319
15320 /* The GNU C library defines this for functions which it implements
15321     to always fail with ENOSYS.  Some functions are actually named
15322     something starting with __ and the normal name is an alias.  */
15323 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15324 choke me
15325 #else
15326 $ac_func();
15327 #endif
15328
15329 ; return 0; }
15330 EOF
15331 if { (eval echo configure:15332: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15332   rm -rf conftest*
15333   eval "ac_cv_func_$ac_func=yes"
15334 else
15335   echo "configure: failed program was:" >&5
15336   cat conftest.$ac_ext >&5
15337   rm -rf conftest*
15338   eval "ac_cv_func_$ac_func=no"
15339 fi
15340 rm -f conftest*
15341 fi
15342
15343 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15344   echo "$ac_t""yes" 1>&6
15345     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15346   cat >> confdefs.h <<EOF
15347 #define $ac_tr_func 1
15348 EOF
15349
15350 else
15351   echo "$ac_t""no" 1>&6
15352 fi
15353 done
15354
15355   fi
15356
15357
15358   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
15359 echo "configure:15360: checking for _fabsl declaration" >&5
15360   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
15361   echo $ac_n "(cached) $ac_c" 1>&6
15362 else
15363
15364
15365     ac_ext=C
15366 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15367 ac_cpp='$CXXCPP $CPPFLAGS'
15368 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15369 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15370 cross_compiling=$ac_cv_prog_cxx_cross
15371
15372     cat > conftest.$ac_ext <<EOF
15373 #line 15374 "configure"
15374 #include "confdefs.h"
15375 #include <math.h>
15376 int main() {
15377  _fabsl(0);
15378 ; return 0; }
15379 EOF
15380 if { (eval echo configure:15381: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15381   rm -rf conftest*
15382   glibcpp_cv_func__fabsl_use=yes
15383 else
15384   echo "configure: failed program was:" >&5
15385   cat conftest.$ac_ext >&5
15386   rm -rf conftest*
15387   glibcpp_cv_func__fabsl_use=no
15388 fi
15389 rm -f conftest*
15390     ac_ext=c
15391 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15392 ac_cpp='$CPP $CPPFLAGS'
15393 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15394 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15395 cross_compiling=$ac_cv_prog_cc_cross
15396
15397
15398 fi
15399
15400   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
15401   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
15402     for ac_func in _fabsl
15403 do
15404 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15405 echo "configure:15406: checking for $ac_func" >&5
15406 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15407   echo $ac_n "(cached) $ac_c" 1>&6
15408 else
15409   cat > conftest.$ac_ext <<EOF
15410 #line 15411 "configure"
15411 #include "confdefs.h"
15412 /* System header to define __stub macros and hopefully few prototypes,
15413     which can conflict with char $ac_func(); below.  */
15414 #include <assert.h>
15415 /* Override any gcc2 internal prototype to avoid an error.  */
15416 /* We use char because int might match the return type of a gcc2
15417     builtin and then its argument prototype would still apply.  */
15418 char $ac_func();
15419
15420 int main() {
15421
15422 /* The GNU C library defines this for functions which it implements
15423     to always fail with ENOSYS.  Some functions are actually named
15424     something starting with __ and the normal name is an alias.  */
15425 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15426 choke me
15427 #else
15428 $ac_func();
15429 #endif
15430
15431 ; return 0; }
15432 EOF
15433 if { (eval echo configure:15434: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15434   rm -rf conftest*
15435   eval "ac_cv_func_$ac_func=yes"
15436 else
15437   echo "configure: failed program was:" >&5
15438   cat conftest.$ac_ext >&5
15439   rm -rf conftest*
15440   eval "ac_cv_func_$ac_func=no"
15441 fi
15442 rm -f conftest*
15443 fi
15444
15445 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15446   echo "$ac_t""yes" 1>&6
15447     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15448   cat >> confdefs.h <<EOF
15449 #define $ac_tr_func 1
15450 EOF
15451
15452 else
15453   echo "$ac_t""no" 1>&6
15454 fi
15455 done
15456
15457   fi
15458
15459
15460   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
15461 echo "configure:15462: checking for _floorl declaration" >&5
15462   if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
15463   echo $ac_n "(cached) $ac_c" 1>&6
15464 else
15465
15466
15467     ac_ext=C
15468 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15469 ac_cpp='$CXXCPP $CPPFLAGS'
15470 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15471 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15472 cross_compiling=$ac_cv_prog_cxx_cross
15473
15474     cat > conftest.$ac_ext <<EOF
15475 #line 15476 "configure"
15476 #include "confdefs.h"
15477 #include <math.h>
15478 int main() {
15479  _floorl(0);
15480 ; return 0; }
15481 EOF
15482 if { (eval echo configure:15483: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15483   rm -rf conftest*
15484   glibcpp_cv_func__floorl_use=yes
15485 else
15486   echo "configure: failed program was:" >&5
15487   cat conftest.$ac_ext >&5
15488   rm -rf conftest*
15489   glibcpp_cv_func__floorl_use=no
15490 fi
15491 rm -f conftest*
15492     ac_ext=c
15493 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15494 ac_cpp='$CPP $CPPFLAGS'
15495 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15496 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15497 cross_compiling=$ac_cv_prog_cc_cross
15498
15499
15500 fi
15501
15502   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
15503   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
15504     for ac_func in _floorl
15505 do
15506 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15507 echo "configure:15508: checking for $ac_func" >&5
15508 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15509   echo $ac_n "(cached) $ac_c" 1>&6
15510 else
15511   cat > conftest.$ac_ext <<EOF
15512 #line 15513 "configure"
15513 #include "confdefs.h"
15514 /* System header to define __stub macros and hopefully few prototypes,
15515     which can conflict with char $ac_func(); below.  */
15516 #include <assert.h>
15517 /* Override any gcc2 internal prototype to avoid an error.  */
15518 /* We use char because int might match the return type of a gcc2
15519     builtin and then its argument prototype would still apply.  */
15520 char $ac_func();
15521
15522 int main() {
15523
15524 /* The GNU C library defines this for functions which it implements
15525     to always fail with ENOSYS.  Some functions are actually named
15526     something starting with __ and the normal name is an alias.  */
15527 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15528 choke me
15529 #else
15530 $ac_func();
15531 #endif
15532
15533 ; return 0; }
15534 EOF
15535 if { (eval echo configure:15536: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15536   rm -rf conftest*
15537   eval "ac_cv_func_$ac_func=yes"
15538 else
15539   echo "configure: failed program was:" >&5
15540   cat conftest.$ac_ext >&5
15541   rm -rf conftest*
15542   eval "ac_cv_func_$ac_func=no"
15543 fi
15544 rm -f conftest*
15545 fi
15546
15547 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15548   echo "$ac_t""yes" 1>&6
15549     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15550   cat >> confdefs.h <<EOF
15551 #define $ac_tr_func 1
15552 EOF
15553
15554 else
15555   echo "$ac_t""no" 1>&6
15556 fi
15557 done
15558
15559   fi
15560
15561
15562   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
15563 echo "configure:15564: checking for _fmodl declaration" >&5
15564   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
15565   echo $ac_n "(cached) $ac_c" 1>&6
15566 else
15567
15568
15569     ac_ext=C
15570 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15571 ac_cpp='$CXXCPP $CPPFLAGS'
15572 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15573 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15574 cross_compiling=$ac_cv_prog_cxx_cross
15575
15576     cat > conftest.$ac_ext <<EOF
15577 #line 15578 "configure"
15578 #include "confdefs.h"
15579 #include <math.h>
15580 int main() {
15581  _fmodl(0, 0);
15582 ; return 0; }
15583 EOF
15584 if { (eval echo configure:15585: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15585   rm -rf conftest*
15586   glibcpp_cv_func__fmodl_use=yes
15587 else
15588   echo "configure: failed program was:" >&5
15589   cat conftest.$ac_ext >&5
15590   rm -rf conftest*
15591   glibcpp_cv_func__fmodl_use=no
15592 fi
15593 rm -f conftest*
15594     ac_ext=c
15595 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15596 ac_cpp='$CPP $CPPFLAGS'
15597 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15598 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15599 cross_compiling=$ac_cv_prog_cc_cross
15600
15601
15602 fi
15603
15604   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
15605   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
15606     for ac_func in _fmodl
15607 do
15608 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15609 echo "configure:15610: checking for $ac_func" >&5
15610 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15611   echo $ac_n "(cached) $ac_c" 1>&6
15612 else
15613   cat > conftest.$ac_ext <<EOF
15614 #line 15615 "configure"
15615 #include "confdefs.h"
15616 /* System header to define __stub macros and hopefully few prototypes,
15617     which can conflict with char $ac_func(); below.  */
15618 #include <assert.h>
15619 /* Override any gcc2 internal prototype to avoid an error.  */
15620 /* We use char because int might match the return type of a gcc2
15621     builtin and then its argument prototype would still apply.  */
15622 char $ac_func();
15623
15624 int main() {
15625
15626 /* The GNU C library defines this for functions which it implements
15627     to always fail with ENOSYS.  Some functions are actually named
15628     something starting with __ and the normal name is an alias.  */
15629 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15630 choke me
15631 #else
15632 $ac_func();
15633 #endif
15634
15635 ; return 0; }
15636 EOF
15637 if { (eval echo configure:15638: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15638   rm -rf conftest*
15639   eval "ac_cv_func_$ac_func=yes"
15640 else
15641   echo "configure: failed program was:" >&5
15642   cat conftest.$ac_ext >&5
15643   rm -rf conftest*
15644   eval "ac_cv_func_$ac_func=no"
15645 fi
15646 rm -f conftest*
15647 fi
15648
15649 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15650   echo "$ac_t""yes" 1>&6
15651     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15652   cat >> confdefs.h <<EOF
15653 #define $ac_tr_func 1
15654 EOF
15655
15656 else
15657   echo "$ac_t""no" 1>&6
15658 fi
15659 done
15660
15661   fi
15662
15663
15664   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15665 echo "configure:15666: checking for _frexpl declaration" >&5
15666   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
15667   echo $ac_n "(cached) $ac_c" 1>&6
15668 else
15669
15670
15671     ac_ext=C
15672 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15673 ac_cpp='$CXXCPP $CPPFLAGS'
15674 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15675 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15676 cross_compiling=$ac_cv_prog_cxx_cross
15677
15678     cat > conftest.$ac_ext <<EOF
15679 #line 15680 "configure"
15680 #include "confdefs.h"
15681 #include <math.h>
15682 int main() {
15683  _frexpl(0, 0);
15684 ; return 0; }
15685 EOF
15686 if { (eval echo configure:15687: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15687   rm -rf conftest*
15688   glibcpp_cv_func__frexpl_use=yes
15689 else
15690   echo "configure: failed program was:" >&5
15691   cat conftest.$ac_ext >&5
15692   rm -rf conftest*
15693   glibcpp_cv_func__frexpl_use=no
15694 fi
15695 rm -f conftest*
15696     ac_ext=c
15697 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15698 ac_cpp='$CPP $CPPFLAGS'
15699 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15700 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15701 cross_compiling=$ac_cv_prog_cc_cross
15702
15703
15704 fi
15705
15706   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
15707   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
15708     for ac_func in _frexpl
15709 do
15710 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15711 echo "configure:15712: checking for $ac_func" >&5
15712 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15713   echo $ac_n "(cached) $ac_c" 1>&6
15714 else
15715   cat > conftest.$ac_ext <<EOF
15716 #line 15717 "configure"
15717 #include "confdefs.h"
15718 /* System header to define __stub macros and hopefully few prototypes,
15719     which can conflict with char $ac_func(); below.  */
15720 #include <assert.h>
15721 /* Override any gcc2 internal prototype to avoid an error.  */
15722 /* We use char because int might match the return type of a gcc2
15723     builtin and then its argument prototype would still apply.  */
15724 char $ac_func();
15725
15726 int main() {
15727
15728 /* The GNU C library defines this for functions which it implements
15729     to always fail with ENOSYS.  Some functions are actually named
15730     something starting with __ and the normal name is an alias.  */
15731 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15732 choke me
15733 #else
15734 $ac_func();
15735 #endif
15736
15737 ; return 0; }
15738 EOF
15739 if { (eval echo configure:15740: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15740   rm -rf conftest*
15741   eval "ac_cv_func_$ac_func=yes"
15742 else
15743   echo "configure: failed program was:" >&5
15744   cat conftest.$ac_ext >&5
15745   rm -rf conftest*
15746   eval "ac_cv_func_$ac_func=no"
15747 fi
15748 rm -f conftest*
15749 fi
15750
15751 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15752   echo "$ac_t""yes" 1>&6
15753     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15754   cat >> confdefs.h <<EOF
15755 #define $ac_tr_func 1
15756 EOF
15757
15758 else
15759   echo "$ac_t""no" 1>&6
15760 fi
15761 done
15762
15763   fi
15764
15765
15766   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15767 echo "configure:15768: checking for _ldexpl declaration" >&5
15768   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
15769   echo $ac_n "(cached) $ac_c" 1>&6
15770 else
15771
15772
15773     ac_ext=C
15774 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15775 ac_cpp='$CXXCPP $CPPFLAGS'
15776 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15777 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15778 cross_compiling=$ac_cv_prog_cxx_cross
15779
15780     cat > conftest.$ac_ext <<EOF
15781 #line 15782 "configure"
15782 #include "confdefs.h"
15783 #include <math.h>
15784 int main() {
15785  _ldexpl(0, 0);
15786 ; return 0; }
15787 EOF
15788 if { (eval echo configure:15789: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15789   rm -rf conftest*
15790   glibcpp_cv_func__ldexpl_use=yes
15791 else
15792   echo "configure: failed program was:" >&5
15793   cat conftest.$ac_ext >&5
15794   rm -rf conftest*
15795   glibcpp_cv_func__ldexpl_use=no
15796 fi
15797 rm -f conftest*
15798     ac_ext=c
15799 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15800 ac_cpp='$CPP $CPPFLAGS'
15801 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15802 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15803 cross_compiling=$ac_cv_prog_cc_cross
15804
15805
15806 fi
15807
15808   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
15809   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
15810     for ac_func in _ldexpl
15811 do
15812 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15813 echo "configure:15814: checking for $ac_func" >&5
15814 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15815   echo $ac_n "(cached) $ac_c" 1>&6
15816 else
15817   cat > conftest.$ac_ext <<EOF
15818 #line 15819 "configure"
15819 #include "confdefs.h"
15820 /* System header to define __stub macros and hopefully few prototypes,
15821     which can conflict with char $ac_func(); below.  */
15822 #include <assert.h>
15823 /* Override any gcc2 internal prototype to avoid an error.  */
15824 /* We use char because int might match the return type of a gcc2
15825     builtin and then its argument prototype would still apply.  */
15826 char $ac_func();
15827
15828 int main() {
15829
15830 /* The GNU C library defines this for functions which it implements
15831     to always fail with ENOSYS.  Some functions are actually named
15832     something starting with __ and the normal name is an alias.  */
15833 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15834 choke me
15835 #else
15836 $ac_func();
15837 #endif
15838
15839 ; return 0; }
15840 EOF
15841 if { (eval echo configure:15842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15842   rm -rf conftest*
15843   eval "ac_cv_func_$ac_func=yes"
15844 else
15845   echo "configure: failed program was:" >&5
15846   cat conftest.$ac_ext >&5
15847   rm -rf conftest*
15848   eval "ac_cv_func_$ac_func=no"
15849 fi
15850 rm -f conftest*
15851 fi
15852
15853 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15854   echo "$ac_t""yes" 1>&6
15855     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15856   cat >> confdefs.h <<EOF
15857 #define $ac_tr_func 1
15858 EOF
15859
15860 else
15861   echo "$ac_t""no" 1>&6
15862 fi
15863 done
15864
15865   fi
15866
15867
15868   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15869 echo "configure:15870: checking for _logl declaration" >&5
15870   if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
15871   echo $ac_n "(cached) $ac_c" 1>&6
15872 else
15873
15874
15875     ac_ext=C
15876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15877 ac_cpp='$CXXCPP $CPPFLAGS'
15878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15880 cross_compiling=$ac_cv_prog_cxx_cross
15881
15882     cat > conftest.$ac_ext <<EOF
15883 #line 15884 "configure"
15884 #include "confdefs.h"
15885 #include <math.h>
15886 int main() {
15887  _logl(0);
15888 ; return 0; }
15889 EOF
15890 if { (eval echo configure:15891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15891   rm -rf conftest*
15892   glibcpp_cv_func__logl_use=yes
15893 else
15894   echo "configure: failed program was:" >&5
15895   cat conftest.$ac_ext >&5
15896   rm -rf conftest*
15897   glibcpp_cv_func__logl_use=no
15898 fi
15899 rm -f conftest*
15900     ac_ext=c
15901 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15902 ac_cpp='$CPP $CPPFLAGS'
15903 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15904 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15905 cross_compiling=$ac_cv_prog_cc_cross
15906
15907
15908 fi
15909
15910   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
15911   if test x$glibcpp_cv_func__logl_use = x"yes"; then
15912     for ac_func in _logl
15913 do
15914 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15915 echo "configure:15916: checking for $ac_func" >&5
15916 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15917   echo $ac_n "(cached) $ac_c" 1>&6
15918 else
15919   cat > conftest.$ac_ext <<EOF
15920 #line 15921 "configure"
15921 #include "confdefs.h"
15922 /* System header to define __stub macros and hopefully few prototypes,
15923     which can conflict with char $ac_func(); below.  */
15924 #include <assert.h>
15925 /* Override any gcc2 internal prototype to avoid an error.  */
15926 /* We use char because int might match the return type of a gcc2
15927     builtin and then its argument prototype would still apply.  */
15928 char $ac_func();
15929
15930 int main() {
15931
15932 /* The GNU C library defines this for functions which it implements
15933     to always fail with ENOSYS.  Some functions are actually named
15934     something starting with __ and the normal name is an alias.  */
15935 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15936 choke me
15937 #else
15938 $ac_func();
15939 #endif
15940
15941 ; return 0; }
15942 EOF
15943 if { (eval echo configure:15944: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15944   rm -rf conftest*
15945   eval "ac_cv_func_$ac_func=yes"
15946 else
15947   echo "configure: failed program was:" >&5
15948   cat conftest.$ac_ext >&5
15949   rm -rf conftest*
15950   eval "ac_cv_func_$ac_func=no"
15951 fi
15952 rm -f conftest*
15953 fi
15954
15955 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15956   echo "$ac_t""yes" 1>&6
15957     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15958   cat >> confdefs.h <<EOF
15959 #define $ac_tr_func 1
15960 EOF
15961
15962 else
15963   echo "$ac_t""no" 1>&6
15964 fi
15965 done
15966
15967   fi
15968
15969
15970   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
15971 echo "configure:15972: checking for _log10l declaration" >&5
15972   if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
15973   echo $ac_n "(cached) $ac_c" 1>&6
15974 else
15975
15976
15977     ac_ext=C
15978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15979 ac_cpp='$CXXCPP $CPPFLAGS'
15980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15982 cross_compiling=$ac_cv_prog_cxx_cross
15983
15984     cat > conftest.$ac_ext <<EOF
15985 #line 15986 "configure"
15986 #include "confdefs.h"
15987 #include <math.h>
15988 int main() {
15989  _log10l(0);
15990 ; return 0; }
15991 EOF
15992 if { (eval echo configure:15993: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15993   rm -rf conftest*
15994   glibcpp_cv_func__log10l_use=yes
15995 else
15996   echo "configure: failed program was:" >&5
15997   cat conftest.$ac_ext >&5
15998   rm -rf conftest*
15999   glibcpp_cv_func__log10l_use=no
16000 fi
16001 rm -f conftest*
16002     ac_ext=c
16003 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16004 ac_cpp='$CPP $CPPFLAGS'
16005 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16006 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16007 cross_compiling=$ac_cv_prog_cc_cross
16008
16009
16010 fi
16011
16012   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16013   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16014     for ac_func in _log10l
16015 do
16016 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16017 echo "configure:16018: checking for $ac_func" >&5
16018 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16019   echo $ac_n "(cached) $ac_c" 1>&6
16020 else
16021   cat > conftest.$ac_ext <<EOF
16022 #line 16023 "configure"
16023 #include "confdefs.h"
16024 /* System header to define __stub macros and hopefully few prototypes,
16025     which can conflict with char $ac_func(); below.  */
16026 #include <assert.h>
16027 /* Override any gcc2 internal prototype to avoid an error.  */
16028 /* We use char because int might match the return type of a gcc2
16029     builtin and then its argument prototype would still apply.  */
16030 char $ac_func();
16031
16032 int main() {
16033
16034 /* The GNU C library defines this for functions which it implements
16035     to always fail with ENOSYS.  Some functions are actually named
16036     something starting with __ and the normal name is an alias.  */
16037 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16038 choke me
16039 #else
16040 $ac_func();
16041 #endif
16042
16043 ; return 0; }
16044 EOF
16045 if { (eval echo configure:16046: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16046   rm -rf conftest*
16047   eval "ac_cv_func_$ac_func=yes"
16048 else
16049   echo "configure: failed program was:" >&5
16050   cat conftest.$ac_ext >&5
16051   rm -rf conftest*
16052   eval "ac_cv_func_$ac_func=no"
16053 fi
16054 rm -f conftest*
16055 fi
16056
16057 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16058   echo "$ac_t""yes" 1>&6
16059     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16060   cat >> confdefs.h <<EOF
16061 #define $ac_tr_func 1
16062 EOF
16063
16064 else
16065   echo "$ac_t""no" 1>&6
16066 fi
16067 done
16068
16069   fi
16070
16071
16072   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
16073 echo "configure:16074: checking for _modfl declaration" >&5
16074   if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
16075   echo $ac_n "(cached) $ac_c" 1>&6
16076 else
16077
16078
16079     ac_ext=C
16080 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16081 ac_cpp='$CXXCPP $CPPFLAGS'
16082 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16083 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16084 cross_compiling=$ac_cv_prog_cxx_cross
16085
16086     cat > conftest.$ac_ext <<EOF
16087 #line 16088 "configure"
16088 #include "confdefs.h"
16089 #include <math.h>
16090 int main() {
16091  _modfl(0, 0);
16092 ; return 0; }
16093 EOF
16094 if { (eval echo configure:16095: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16095   rm -rf conftest*
16096   glibcpp_cv_func__modfl_use=yes
16097 else
16098   echo "configure: failed program was:" >&5
16099   cat conftest.$ac_ext >&5
16100   rm -rf conftest*
16101   glibcpp_cv_func__modfl_use=no
16102 fi
16103 rm -f conftest*
16104     ac_ext=c
16105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16106 ac_cpp='$CPP $CPPFLAGS'
16107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16109 cross_compiling=$ac_cv_prog_cc_cross
16110
16111
16112 fi
16113
16114   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
16115   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
16116     for ac_func in _modfl
16117 do
16118 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16119 echo "configure:16120: checking for $ac_func" >&5
16120 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16121   echo $ac_n "(cached) $ac_c" 1>&6
16122 else
16123   cat > conftest.$ac_ext <<EOF
16124 #line 16125 "configure"
16125 #include "confdefs.h"
16126 /* System header to define __stub macros and hopefully few prototypes,
16127     which can conflict with char $ac_func(); below.  */
16128 #include <assert.h>
16129 /* Override any gcc2 internal prototype to avoid an error.  */
16130 /* We use char because int might match the return type of a gcc2
16131     builtin and then its argument prototype would still apply.  */
16132 char $ac_func();
16133
16134 int main() {
16135
16136 /* The GNU C library defines this for functions which it implements
16137     to always fail with ENOSYS.  Some functions are actually named
16138     something starting with __ and the normal name is an alias.  */
16139 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16140 choke me
16141 #else
16142 $ac_func();
16143 #endif
16144
16145 ; return 0; }
16146 EOF
16147 if { (eval echo configure:16148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16148   rm -rf conftest*
16149   eval "ac_cv_func_$ac_func=yes"
16150 else
16151   echo "configure: failed program was:" >&5
16152   cat conftest.$ac_ext >&5
16153   rm -rf conftest*
16154   eval "ac_cv_func_$ac_func=no"
16155 fi
16156 rm -f conftest*
16157 fi
16158
16159 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16160   echo "$ac_t""yes" 1>&6
16161     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16162   cat >> confdefs.h <<EOF
16163 #define $ac_tr_func 1
16164 EOF
16165
16166 else
16167   echo "$ac_t""no" 1>&6
16168 fi
16169 done
16170
16171   fi
16172
16173
16174   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
16175 echo "configure:16176: checking for _powl declaration" >&5
16176   if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
16177   echo $ac_n "(cached) $ac_c" 1>&6
16178 else
16179
16180
16181     ac_ext=C
16182 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16183 ac_cpp='$CXXCPP $CPPFLAGS'
16184 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16185 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16186 cross_compiling=$ac_cv_prog_cxx_cross
16187
16188     cat > conftest.$ac_ext <<EOF
16189 #line 16190 "configure"
16190 #include "confdefs.h"
16191 #include <math.h>
16192 int main() {
16193  _powl(0, 0);
16194 ; return 0; }
16195 EOF
16196 if { (eval echo configure:16197: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16197   rm -rf conftest*
16198   glibcpp_cv_func__powl_use=yes
16199 else
16200   echo "configure: failed program was:" >&5
16201   cat conftest.$ac_ext >&5
16202   rm -rf conftest*
16203   glibcpp_cv_func__powl_use=no
16204 fi
16205 rm -f conftest*
16206     ac_ext=c
16207 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16208 ac_cpp='$CPP $CPPFLAGS'
16209 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16210 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16211 cross_compiling=$ac_cv_prog_cc_cross
16212
16213
16214 fi
16215
16216   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
16217   if test x$glibcpp_cv_func__powl_use = x"yes"; then
16218     for ac_func in _powl
16219 do
16220 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16221 echo "configure:16222: checking for $ac_func" >&5
16222 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16223   echo $ac_n "(cached) $ac_c" 1>&6
16224 else
16225   cat > conftest.$ac_ext <<EOF
16226 #line 16227 "configure"
16227 #include "confdefs.h"
16228 /* System header to define __stub macros and hopefully few prototypes,
16229     which can conflict with char $ac_func(); below.  */
16230 #include <assert.h>
16231 /* Override any gcc2 internal prototype to avoid an error.  */
16232 /* We use char because int might match the return type of a gcc2
16233     builtin and then its argument prototype would still apply.  */
16234 char $ac_func();
16235
16236 int main() {
16237
16238 /* The GNU C library defines this for functions which it implements
16239     to always fail with ENOSYS.  Some functions are actually named
16240     something starting with __ and the normal name is an alias.  */
16241 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16242 choke me
16243 #else
16244 $ac_func();
16245 #endif
16246
16247 ; return 0; }
16248 EOF
16249 if { (eval echo configure:16250: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16250   rm -rf conftest*
16251   eval "ac_cv_func_$ac_func=yes"
16252 else
16253   echo "configure: failed program was:" >&5
16254   cat conftest.$ac_ext >&5
16255   rm -rf conftest*
16256   eval "ac_cv_func_$ac_func=no"
16257 fi
16258 rm -f conftest*
16259 fi
16260
16261 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16262   echo "$ac_t""yes" 1>&6
16263     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16264   cat >> confdefs.h <<EOF
16265 #define $ac_tr_func 1
16266 EOF
16267
16268 else
16269   echo "$ac_t""no" 1>&6
16270 fi
16271 done
16272
16273   fi
16274
16275
16276   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
16277 echo "configure:16278: checking for _sinl declaration" >&5
16278   if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
16279   echo $ac_n "(cached) $ac_c" 1>&6
16280 else
16281
16282
16283     ac_ext=C
16284 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16285 ac_cpp='$CXXCPP $CPPFLAGS'
16286 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16287 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16288 cross_compiling=$ac_cv_prog_cxx_cross
16289
16290     cat > conftest.$ac_ext <<EOF
16291 #line 16292 "configure"
16292 #include "confdefs.h"
16293 #include <math.h>
16294 int main() {
16295  _sinl(0);
16296 ; return 0; }
16297 EOF
16298 if { (eval echo configure:16299: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16299   rm -rf conftest*
16300   glibcpp_cv_func__sinl_use=yes
16301 else
16302   echo "configure: failed program was:" >&5
16303   cat conftest.$ac_ext >&5
16304   rm -rf conftest*
16305   glibcpp_cv_func__sinl_use=no
16306 fi
16307 rm -f conftest*
16308     ac_ext=c
16309 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16310 ac_cpp='$CPP $CPPFLAGS'
16311 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16312 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16313 cross_compiling=$ac_cv_prog_cc_cross
16314
16315
16316 fi
16317
16318   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
16319   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
16320     for ac_func in _sinl
16321 do
16322 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16323 echo "configure:16324: checking for $ac_func" >&5
16324 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16325   echo $ac_n "(cached) $ac_c" 1>&6
16326 else
16327   cat > conftest.$ac_ext <<EOF
16328 #line 16329 "configure"
16329 #include "confdefs.h"
16330 /* System header to define __stub macros and hopefully few prototypes,
16331     which can conflict with char $ac_func(); below.  */
16332 #include <assert.h>
16333 /* Override any gcc2 internal prototype to avoid an error.  */
16334 /* We use char because int might match the return type of a gcc2
16335     builtin and then its argument prototype would still apply.  */
16336 char $ac_func();
16337
16338 int main() {
16339
16340 /* The GNU C library defines this for functions which it implements
16341     to always fail with ENOSYS.  Some functions are actually named
16342     something starting with __ and the normal name is an alias.  */
16343 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16344 choke me
16345 #else
16346 $ac_func();
16347 #endif
16348
16349 ; return 0; }
16350 EOF
16351 if { (eval echo configure:16352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16352   rm -rf conftest*
16353   eval "ac_cv_func_$ac_func=yes"
16354 else
16355   echo "configure: failed program was:" >&5
16356   cat conftest.$ac_ext >&5
16357   rm -rf conftest*
16358   eval "ac_cv_func_$ac_func=no"
16359 fi
16360 rm -f conftest*
16361 fi
16362
16363 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16364   echo "$ac_t""yes" 1>&6
16365     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16366   cat >> confdefs.h <<EOF
16367 #define $ac_tr_func 1
16368 EOF
16369
16370 else
16371   echo "$ac_t""no" 1>&6
16372 fi
16373 done
16374
16375   fi
16376
16377
16378   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
16379 echo "configure:16380: checking for _sinhl declaration" >&5
16380   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
16381   echo $ac_n "(cached) $ac_c" 1>&6
16382 else
16383
16384
16385     ac_ext=C
16386 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16387 ac_cpp='$CXXCPP $CPPFLAGS'
16388 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16389 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16390 cross_compiling=$ac_cv_prog_cxx_cross
16391
16392     cat > conftest.$ac_ext <<EOF
16393 #line 16394 "configure"
16394 #include "confdefs.h"
16395 #include <math.h>
16396 int main() {
16397  _sinhl(0);
16398 ; return 0; }
16399 EOF
16400 if { (eval echo configure:16401: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16401   rm -rf conftest*
16402   glibcpp_cv_func__sinhl_use=yes
16403 else
16404   echo "configure: failed program was:" >&5
16405   cat conftest.$ac_ext >&5
16406   rm -rf conftest*
16407   glibcpp_cv_func__sinhl_use=no
16408 fi
16409 rm -f conftest*
16410     ac_ext=c
16411 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16412 ac_cpp='$CPP $CPPFLAGS'
16413 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16414 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16415 cross_compiling=$ac_cv_prog_cc_cross
16416
16417
16418 fi
16419
16420   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
16421   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
16422     for ac_func in _sinhl
16423 do
16424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16425 echo "configure:16426: checking for $ac_func" >&5
16426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16427   echo $ac_n "(cached) $ac_c" 1>&6
16428 else
16429   cat > conftest.$ac_ext <<EOF
16430 #line 16431 "configure"
16431 #include "confdefs.h"
16432 /* System header to define __stub macros and hopefully few prototypes,
16433     which can conflict with char $ac_func(); below.  */
16434 #include <assert.h>
16435 /* Override any gcc2 internal prototype to avoid an error.  */
16436 /* We use char because int might match the return type of a gcc2
16437     builtin and then its argument prototype would still apply.  */
16438 char $ac_func();
16439
16440 int main() {
16441
16442 /* The GNU C library defines this for functions which it implements
16443     to always fail with ENOSYS.  Some functions are actually named
16444     something starting with __ and the normal name is an alias.  */
16445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16446 choke me
16447 #else
16448 $ac_func();
16449 #endif
16450
16451 ; return 0; }
16452 EOF
16453 if { (eval echo configure:16454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16454   rm -rf conftest*
16455   eval "ac_cv_func_$ac_func=yes"
16456 else
16457   echo "configure: failed program was:" >&5
16458   cat conftest.$ac_ext >&5
16459   rm -rf conftest*
16460   eval "ac_cv_func_$ac_func=no"
16461 fi
16462 rm -f conftest*
16463 fi
16464
16465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16466   echo "$ac_t""yes" 1>&6
16467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16468   cat >> confdefs.h <<EOF
16469 #define $ac_tr_func 1
16470 EOF
16471
16472 else
16473   echo "$ac_t""no" 1>&6
16474 fi
16475 done
16476
16477   fi
16478
16479
16480   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
16481 echo "configure:16482: checking for _sqrtl declaration" >&5
16482   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
16483   echo $ac_n "(cached) $ac_c" 1>&6
16484 else
16485
16486
16487     ac_ext=C
16488 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16489 ac_cpp='$CXXCPP $CPPFLAGS'
16490 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16491 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16492 cross_compiling=$ac_cv_prog_cxx_cross
16493
16494     cat > conftest.$ac_ext <<EOF
16495 #line 16496 "configure"
16496 #include "confdefs.h"
16497 #include <math.h>
16498 int main() {
16499  _sqrtl(0);
16500 ; return 0; }
16501 EOF
16502 if { (eval echo configure:16503: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16503   rm -rf conftest*
16504   glibcpp_cv_func__sqrtl_use=yes
16505 else
16506   echo "configure: failed program was:" >&5
16507   cat conftest.$ac_ext >&5
16508   rm -rf conftest*
16509   glibcpp_cv_func__sqrtl_use=no
16510 fi
16511 rm -f conftest*
16512     ac_ext=c
16513 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16514 ac_cpp='$CPP $CPPFLAGS'
16515 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16516 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16517 cross_compiling=$ac_cv_prog_cc_cross
16518
16519
16520 fi
16521
16522   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
16523   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
16524     for ac_func in _sqrtl
16525 do
16526 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16527 echo "configure:16528: checking for $ac_func" >&5
16528 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16529   echo $ac_n "(cached) $ac_c" 1>&6
16530 else
16531   cat > conftest.$ac_ext <<EOF
16532 #line 16533 "configure"
16533 #include "confdefs.h"
16534 /* System header to define __stub macros and hopefully few prototypes,
16535     which can conflict with char $ac_func(); below.  */
16536 #include <assert.h>
16537 /* Override any gcc2 internal prototype to avoid an error.  */
16538 /* We use char because int might match the return type of a gcc2
16539     builtin and then its argument prototype would still apply.  */
16540 char $ac_func();
16541
16542 int main() {
16543
16544 /* The GNU C library defines this for functions which it implements
16545     to always fail with ENOSYS.  Some functions are actually named
16546     something starting with __ and the normal name is an alias.  */
16547 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16548 choke me
16549 #else
16550 $ac_func();
16551 #endif
16552
16553 ; return 0; }
16554 EOF
16555 if { (eval echo configure:16556: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16556   rm -rf conftest*
16557   eval "ac_cv_func_$ac_func=yes"
16558 else
16559   echo "configure: failed program was:" >&5
16560   cat conftest.$ac_ext >&5
16561   rm -rf conftest*
16562   eval "ac_cv_func_$ac_func=no"
16563 fi
16564 rm -f conftest*
16565 fi
16566
16567 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16568   echo "$ac_t""yes" 1>&6
16569     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16570   cat >> confdefs.h <<EOF
16571 #define $ac_tr_func 1
16572 EOF
16573
16574 else
16575   echo "$ac_t""no" 1>&6
16576 fi
16577 done
16578
16579   fi
16580
16581
16582   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
16583 echo "configure:16584: checking for _tanl declaration" >&5
16584   if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
16585   echo $ac_n "(cached) $ac_c" 1>&6
16586 else
16587
16588
16589     ac_ext=C
16590 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16591 ac_cpp='$CXXCPP $CPPFLAGS'
16592 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16593 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16594 cross_compiling=$ac_cv_prog_cxx_cross
16595
16596     cat > conftest.$ac_ext <<EOF
16597 #line 16598 "configure"
16598 #include "confdefs.h"
16599 #include <math.h>
16600 int main() {
16601  _tanl(0);
16602 ; return 0; }
16603 EOF
16604 if { (eval echo configure:16605: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16605   rm -rf conftest*
16606   glibcpp_cv_func__tanl_use=yes
16607 else
16608   echo "configure: failed program was:" >&5
16609   cat conftest.$ac_ext >&5
16610   rm -rf conftest*
16611   glibcpp_cv_func__tanl_use=no
16612 fi
16613 rm -f conftest*
16614     ac_ext=c
16615 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16616 ac_cpp='$CPP $CPPFLAGS'
16617 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16618 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16619 cross_compiling=$ac_cv_prog_cc_cross
16620
16621
16622 fi
16623
16624   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
16625   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
16626     for ac_func in _tanl
16627 do
16628 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16629 echo "configure:16630: checking for $ac_func" >&5
16630 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16631   echo $ac_n "(cached) $ac_c" 1>&6
16632 else
16633   cat > conftest.$ac_ext <<EOF
16634 #line 16635 "configure"
16635 #include "confdefs.h"
16636 /* System header to define __stub macros and hopefully few prototypes,
16637     which can conflict with char $ac_func(); below.  */
16638 #include <assert.h>
16639 /* Override any gcc2 internal prototype to avoid an error.  */
16640 /* We use char because int might match the return type of a gcc2
16641     builtin and then its argument prototype would still apply.  */
16642 char $ac_func();
16643
16644 int main() {
16645
16646 /* The GNU C library defines this for functions which it implements
16647     to always fail with ENOSYS.  Some functions are actually named
16648     something starting with __ and the normal name is an alias.  */
16649 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16650 choke me
16651 #else
16652 $ac_func();
16653 #endif
16654
16655 ; return 0; }
16656 EOF
16657 if { (eval echo configure:16658: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16658   rm -rf conftest*
16659   eval "ac_cv_func_$ac_func=yes"
16660 else
16661   echo "configure: failed program was:" >&5
16662   cat conftest.$ac_ext >&5
16663   rm -rf conftest*
16664   eval "ac_cv_func_$ac_func=no"
16665 fi
16666 rm -f conftest*
16667 fi
16668
16669 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16670   echo "$ac_t""yes" 1>&6
16671     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16672   cat >> confdefs.h <<EOF
16673 #define $ac_tr_func 1
16674 EOF
16675
16676 else
16677   echo "$ac_t""no" 1>&6
16678 fi
16679 done
16680
16681   fi
16682
16683
16684   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16685 echo "configure:16686: checking for _tanhl declaration" >&5
16686   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
16687   echo $ac_n "(cached) $ac_c" 1>&6
16688 else
16689
16690
16691     ac_ext=C
16692 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16693 ac_cpp='$CXXCPP $CPPFLAGS'
16694 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16695 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16696 cross_compiling=$ac_cv_prog_cxx_cross
16697
16698     cat > conftest.$ac_ext <<EOF
16699 #line 16700 "configure"
16700 #include "confdefs.h"
16701 #include <math.h>
16702 int main() {
16703  _tanhl(0);
16704 ; return 0; }
16705 EOF
16706 if { (eval echo configure:16707: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16707   rm -rf conftest*
16708   glibcpp_cv_func__tanhl_use=yes
16709 else
16710   echo "configure: failed program was:" >&5
16711   cat conftest.$ac_ext >&5
16712   rm -rf conftest*
16713   glibcpp_cv_func__tanhl_use=no
16714 fi
16715 rm -f conftest*
16716     ac_ext=c
16717 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16718 ac_cpp='$CPP $CPPFLAGS'
16719 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16720 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16721 cross_compiling=$ac_cv_prog_cc_cross
16722
16723
16724 fi
16725
16726   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
16727   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
16728     for ac_func in _tanhl
16729 do
16730 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16731 echo "configure:16732: checking for $ac_func" >&5
16732 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16733   echo $ac_n "(cached) $ac_c" 1>&6
16734 else
16735   cat > conftest.$ac_ext <<EOF
16736 #line 16737 "configure"
16737 #include "confdefs.h"
16738 /* System header to define __stub macros and hopefully few prototypes,
16739     which can conflict with char $ac_func(); below.  */
16740 #include <assert.h>
16741 /* Override any gcc2 internal prototype to avoid an error.  */
16742 /* We use char because int might match the return type of a gcc2
16743     builtin and then its argument prototype would still apply.  */
16744 char $ac_func();
16745
16746 int main() {
16747
16748 /* The GNU C library defines this for functions which it implements
16749     to always fail with ENOSYS.  Some functions are actually named
16750     something starting with __ and the normal name is an alias.  */
16751 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16752 choke me
16753 #else
16754 $ac_func();
16755 #endif
16756
16757 ; return 0; }
16758 EOF
16759 if { (eval echo configure:16760: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16760   rm -rf conftest*
16761   eval "ac_cv_func_$ac_func=yes"
16762 else
16763   echo "configure: failed program was:" >&5
16764   cat conftest.$ac_ext >&5
16765   rm -rf conftest*
16766   eval "ac_cv_func_$ac_func=no"
16767 fi
16768 rm -f conftest*
16769 fi
16770
16771 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16772   echo "$ac_t""yes" 1>&6
16773     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16774   cat >> confdefs.h <<EOF
16775 #define $ac_tr_func 1
16776 EOF
16777
16778 else
16779   echo "$ac_t""no" 1>&6
16780 fi
16781 done
16782
16783   fi
16784
16785
16786   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16787 echo "configure:16788: checking for _sincosl declaration" >&5
16788   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
16789   echo $ac_n "(cached) $ac_c" 1>&6
16790 else
16791
16792
16793     ac_ext=C
16794 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16795 ac_cpp='$CXXCPP $CPPFLAGS'
16796 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16797 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16798 cross_compiling=$ac_cv_prog_cxx_cross
16799
16800     cat > conftest.$ac_ext <<EOF
16801 #line 16802 "configure"
16802 #include "confdefs.h"
16803 #include <math.h>
16804 int main() {
16805  _sincosl(0, 0, 0);
16806 ; return 0; }
16807 EOF
16808 if { (eval echo configure:16809: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16809   rm -rf conftest*
16810   glibcpp_cv_func__sincosl_use=yes
16811 else
16812   echo "configure: failed program was:" >&5
16813   cat conftest.$ac_ext >&5
16814   rm -rf conftest*
16815   glibcpp_cv_func__sincosl_use=no
16816 fi
16817 rm -f conftest*
16818     ac_ext=c
16819 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16820 ac_cpp='$CPP $CPPFLAGS'
16821 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16822 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16823 cross_compiling=$ac_cv_prog_cc_cross
16824
16825
16826 fi
16827
16828   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
16829   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
16830     for ac_func in _sincosl
16831 do
16832 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16833 echo "configure:16834: checking for $ac_func" >&5
16834 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16835   echo $ac_n "(cached) $ac_c" 1>&6
16836 else
16837   cat > conftest.$ac_ext <<EOF
16838 #line 16839 "configure"
16839 #include "confdefs.h"
16840 /* System header to define __stub macros and hopefully few prototypes,
16841     which can conflict with char $ac_func(); below.  */
16842 #include <assert.h>
16843 /* Override any gcc2 internal prototype to avoid an error.  */
16844 /* We use char because int might match the return type of a gcc2
16845     builtin and then its argument prototype would still apply.  */
16846 char $ac_func();
16847
16848 int main() {
16849
16850 /* The GNU C library defines this for functions which it implements
16851     to always fail with ENOSYS.  Some functions are actually named
16852     something starting with __ and the normal name is an alias.  */
16853 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16854 choke me
16855 #else
16856 $ac_func();
16857 #endif
16858
16859 ; return 0; }
16860 EOF
16861 if { (eval echo configure:16862: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16862   rm -rf conftest*
16863   eval "ac_cv_func_$ac_func=yes"
16864 else
16865   echo "configure: failed program was:" >&5
16866   cat conftest.$ac_ext >&5
16867   rm -rf conftest*
16868   eval "ac_cv_func_$ac_func=no"
16869 fi
16870 rm -f conftest*
16871 fi
16872
16873 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16874   echo "$ac_t""yes" 1>&6
16875     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16876   cat >> confdefs.h <<EOF
16877 #define $ac_tr_func 1
16878 EOF
16879
16880 else
16881   echo "$ac_t""no" 1>&6
16882 fi
16883 done
16884
16885   fi
16886
16887
16888   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16889 echo "configure:16890: checking for _finitel declaration" >&5
16890   if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
16891   echo $ac_n "(cached) $ac_c" 1>&6
16892 else
16893
16894
16895     ac_ext=C
16896 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16897 ac_cpp='$CXXCPP $CPPFLAGS'
16898 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16899 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16900 cross_compiling=$ac_cv_prog_cxx_cross
16901
16902     cat > conftest.$ac_ext <<EOF
16903 #line 16904 "configure"
16904 #include "confdefs.h"
16905 #include <math.h>
16906 int main() {
16907  _finitel(0);
16908 ; return 0; }
16909 EOF
16910 if { (eval echo configure:16911: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16911   rm -rf conftest*
16912   glibcpp_cv_func__finitel_use=yes
16913 else
16914   echo "configure: failed program was:" >&5
16915   cat conftest.$ac_ext >&5
16916   rm -rf conftest*
16917   glibcpp_cv_func__finitel_use=no
16918 fi
16919 rm -f conftest*
16920     ac_ext=c
16921 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16922 ac_cpp='$CPP $CPPFLAGS'
16923 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16924 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16925 cross_compiling=$ac_cv_prog_cc_cross
16926
16927
16928 fi
16929
16930   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
16931   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
16932     for ac_func in _finitel
16933 do
16934 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16935 echo "configure:16936: checking for $ac_func" >&5
16936 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16937   echo $ac_n "(cached) $ac_c" 1>&6
16938 else
16939   cat > conftest.$ac_ext <<EOF
16940 #line 16941 "configure"
16941 #include "confdefs.h"
16942 /* System header to define __stub macros and hopefully few prototypes,
16943     which can conflict with char $ac_func(); below.  */
16944 #include <assert.h>
16945 /* Override any gcc2 internal prototype to avoid an error.  */
16946 /* We use char because int might match the return type of a gcc2
16947     builtin and then its argument prototype would still apply.  */
16948 char $ac_func();
16949
16950 int main() {
16951
16952 /* The GNU C library defines this for functions which it implements
16953     to always fail with ENOSYS.  Some functions are actually named
16954     something starting with __ and the normal name is an alias.  */
16955 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16956 choke me
16957 #else
16958 $ac_func();
16959 #endif
16960
16961 ; return 0; }
16962 EOF
16963 if { (eval echo configure:16964: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16964   rm -rf conftest*
16965   eval "ac_cv_func_$ac_func=yes"
16966 else
16967   echo "configure: failed program was:" >&5
16968   cat conftest.$ac_ext >&5
16969   rm -rf conftest*
16970   eval "ac_cv_func_$ac_func=no"
16971 fi
16972 rm -f conftest*
16973 fi
16974
16975 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16976   echo "$ac_t""yes" 1>&6
16977     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16978   cat >> confdefs.h <<EOF
16979 #define $ac_tr_func 1
16980 EOF
16981
16982 else
16983   echo "$ac_t""no" 1>&6
16984 fi
16985 done
16986
16987   fi
16988
16989
16990   LIBS="$ac_save_LIBS"
16991   CXXFLAGS="$ac_save_CXXFLAGS"
16992
16993
16994     for ac_hdr in complex.h
16995 do
16996 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16997 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16998 echo "configure:16999: checking for $ac_hdr" >&5
16999 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17000   echo $ac_n "(cached) $ac_c" 1>&6
17001 else
17002   cat > conftest.$ac_ext <<EOF
17003 #line 17004 "configure"
17004 #include "confdefs.h"
17005 #include <$ac_hdr>
17006 EOF
17007 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17008 { (eval echo configure:17009: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17009 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17010 if test -z "$ac_err"; then
17011   rm -rf conftest*
17012   eval "ac_cv_header_$ac_safe=yes"
17013 else
17014   echo "$ac_err" >&5
17015   echo "configure: failed program was:" >&5
17016   cat conftest.$ac_ext >&5
17017   rm -rf conftest*
17018   eval "ac_cv_header_$ac_safe=no"
17019 fi
17020 rm -f conftest*
17021 fi
17022 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17023   echo "$ac_t""yes" 1>&6
17024     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17025   cat >> confdefs.h <<EOF
17026 #define $ac_tr_hdr 1
17027 EOF
17028
17029 else
17030   echo "$ac_t""no" 1>&6
17031 fi
17032 done
17033
17034   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17035 echo "configure:17036: checking for main in -lm" >&5
17036 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17037 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17038   echo $ac_n "(cached) $ac_c" 1>&6
17039 else
17040   ac_save_LIBS="$LIBS"
17041 LIBS="-lm  $LIBS"
17042 cat > conftest.$ac_ext <<EOF
17043 #line 17044 "configure"
17044 #include "confdefs.h"
17045
17046 int main() {
17047 main()
17048 ; return 0; }
17049 EOF
17050 if { (eval echo configure:17051: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17051   rm -rf conftest*
17052   eval "ac_cv_lib_$ac_lib_var=yes"
17053 else
17054   echo "configure: failed program was:" >&5
17055   cat conftest.$ac_ext >&5
17056   rm -rf conftest*
17057   eval "ac_cv_lib_$ac_lib_var=no"
17058 fi
17059 rm -f conftest*
17060 LIBS="$ac_save_LIBS"
17061
17062 fi
17063 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17064   echo "$ac_t""yes" 1>&6
17065     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
17066     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
17067   cat >> confdefs.h <<EOF
17068 #define $ac_tr_lib 1
17069 EOF
17070
17071   LIBS="-lm $LIBS"
17072
17073 else
17074   echo "$ac_t""no" 1>&6
17075 fi
17076
17077   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf \
17078   csin csinf csinh csinhf csqrt \
17079   csqrtf ctan ctanf ctanh ctanhf nan hypot hypotf atan2f expf \
17080   copysignf
17081 do
17082 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17083 echo "configure:17084: checking for $ac_func" >&5
17084 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17085   echo $ac_n "(cached) $ac_c" 1>&6
17086 else
17087   cat > conftest.$ac_ext <<EOF
17088 #line 17089 "configure"
17089 #include "confdefs.h"
17090 /* System header to define __stub macros and hopefully few prototypes,
17091     which can conflict with char $ac_func(); below.  */
17092 #include <assert.h>
17093 /* Override any gcc2 internal prototype to avoid an error.  */
17094 /* We use char because int might match the return type of a gcc2
17095     builtin and then its argument prototype would still apply.  */
17096 char $ac_func();
17097
17098 int main() {
17099
17100 /* The GNU C library defines this for functions which it implements
17101     to always fail with ENOSYS.  Some functions are actually named
17102     something starting with __ and the normal name is an alias.  */
17103 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17104 choke me
17105 #else
17106 $ac_func();
17107 #endif
17108
17109 ; return 0; }
17110 EOF
17111 if { (eval echo configure:17112: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17112   rm -rf conftest*
17113   eval "ac_cv_func_$ac_func=yes"
17114 else
17115   echo "configure: failed program was:" >&5
17116   cat conftest.$ac_ext >&5
17117   rm -rf conftest*
17118   eval "ac_cv_func_$ac_func=no"
17119 fi
17120 rm -f conftest*
17121 fi
17122
17123 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17124   echo "$ac_t""yes" 1>&6
17125     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17126   cat >> confdefs.h <<EOF
17127 #define $ac_tr_func 1
17128 EOF
17129
17130 else
17131   echo "$ac_t""no" 1>&6
17132 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17133 fi
17134 done
17135
17136
17137
17138           USE_COMPLEX_LONG_DOUBLE=no
17139   if test x$ac_cv_func_atan2l = x"yes" \
17140      && test x$ac_cv_func_copysignl = x"yes"; then
17141     USE_COMPLEX_LONG_DOUBLE=yes
17142     for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
17143     csqrtl ctanhl ctanl hypotl signbitl clog10l
17144 do
17145 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17146 echo "configure:17147: checking for $ac_func" >&5
17147 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17148   echo $ac_n "(cached) $ac_c" 1>&6
17149 else
17150   cat > conftest.$ac_ext <<EOF
17151 #line 17152 "configure"
17152 #include "confdefs.h"
17153 /* System header to define __stub macros and hopefully few prototypes,
17154     which can conflict with char $ac_func(); below.  */
17155 #include <assert.h>
17156 /* Override any gcc2 internal prototype to avoid an error.  */
17157 /* We use char because int might match the return type of a gcc2
17158     builtin and then its argument prototype would still apply.  */
17159 char $ac_func();
17160
17161 int main() {
17162
17163 /* The GNU C library defines this for functions which it implements
17164     to always fail with ENOSYS.  Some functions are actually named
17165     something starting with __ and the normal name is an alias.  */
17166 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17167 choke me
17168 #else
17169 $ac_func();
17170 #endif
17171
17172 ; return 0; }
17173 EOF
17174 if { (eval echo configure:17175: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17175   rm -rf conftest*
17176   eval "ac_cv_func_$ac_func=yes"
17177 else
17178   echo "configure: failed program was:" >&5
17179   cat conftest.$ac_ext >&5
17180   rm -rf conftest*
17181   eval "ac_cv_func_$ac_func=no"
17182 fi
17183 rm -f conftest*
17184 fi
17185
17186 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17187   echo "$ac_t""yes" 1>&6
17188     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17189   cat >> confdefs.h <<EOF
17190 #define $ac_tr_func 1
17191 EOF
17192
17193 else
17194   echo "$ac_t""no" 1>&6
17195 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17196 fi
17197 done
17198
17199
17200   fi
17201
17202
17203
17204
17205
17206
17207   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
17208 echo "configure:17209: checking for GNU C++ __complex__ support" >&5
17209   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
17210   echo $ac_n "(cached) $ac_c" 1>&6
17211 else
17212
17213
17214     ac_ext=C
17215 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17216 ac_cpp='$CXXCPP $CPPFLAGS'
17217 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17218 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17219 cross_compiling=$ac_cv_prog_cxx_cross
17220
17221     cat > conftest.$ac_ext <<EOF
17222 #line 17223 "configure"
17223 #include "confdefs.h"
17224 struct dcomplex { __complex__ double x; }; \
17225                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
17226 int main() {
17227 \
17228                      dcomplex x; f(x);
17229 ; return 0; }
17230 EOF
17231 if { (eval echo configure:17232: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17232   rm -rf conftest*
17233   glibcpp_cv_complex=ok
17234 else
17235   echo "configure: failed program was:" >&5
17236   cat conftest.$ac_ext >&5
17237   rm -rf conftest*
17238   glibcpp_cv_complex=buggy
17239
17240 fi
17241 rm -f conftest*
17242     ac_ext=c
17243 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17244 ac_cpp='$CPP $CPPFLAGS'
17245 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17246 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17247 cross_compiling=$ac_cv_prog_cc_cross
17248
17249
17250 fi
17251
17252   echo "$ac_t""$glibcpp_cv_complex" 1>&6
17253   if test $glibcpp_cv_complex = buggy; then
17254     cat >> confdefs.h <<\EOF
17255 #define _GLIBCPP_BUGGY_COMPLEX 1
17256 EOF
17257
17258   fi
17259
17260   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
17261 echo "configure:17262: checking for GNU C++ __complex__ float support" >&5
17262   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
17263   echo $ac_n "(cached) $ac_c" 1>&6
17264 else
17265
17266
17267     ac_ext=C
17268 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17269 ac_cpp='$CXXCPP $CPPFLAGS'
17270 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17271 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17272 cross_compiling=$ac_cv_prog_cxx_cross
17273
17274     rm -f conftest.h
17275     cat > conftest.h <<EOB
17276       //
17277       // Check for buggy __complex__ that causes ICE in most versions of egcs
17278       // and gcc-2.95.x on certain platforms (eg., x86-win32).
17279       //
17280       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
17281       // more info on the bug itself.
17282       //
17283       struct
17284       float_complex
17285       {
17286        __complex__ float m_value;
17287        float_complex (float = 0.0f, float = 0.0f);
17288        float_complex (__complex__ float val) : m_value (val) {}
17289        float_complex foo (const float_complex &val)
17290          { return float_complex (~val.m_value); }
17291       };
17292 EOB
17293     cat > conftest.$ac_ext <<EOF
17294 #line 17295 "configure"
17295 #include "confdefs.h"
17296 #include "conftest.h"
17297 int main() {
17298
17299 ; return 0; }
17300 EOF
17301 if { (eval echo configure:17302: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17302   rm -rf conftest*
17303   glibcpp_cv_float_complex=ok
17304 else
17305   echo "configure: failed program was:" >&5
17306   cat conftest.$ac_ext >&5
17307   rm -rf conftest*
17308   glibcpp_cv_float_complex=buggy
17309
17310 fi
17311 rm -f conftest*
17312     ac_ext=c
17313 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17314 ac_cpp='$CPP $CPPFLAGS'
17315 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17316 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17317 cross_compiling=$ac_cv_prog_cc_cross
17318
17319
17320 fi
17321
17322   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
17323   if test $glibcpp_cv_float_complex = buggy; then
17324     cat >> confdefs.h <<\EOF
17325 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
17326 EOF
17327
17328   fi
17329
17330
17331   if test x$enable_c_mbchar != xno; then
17332
17333         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
17334 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
17335 echo "configure:17336: checking for wchar.h" >&5
17336 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17337   echo $ac_n "(cached) $ac_c" 1>&6
17338 else
17339   cat > conftest.$ac_ext <<EOF
17340 #line 17341 "configure"
17341 #include "confdefs.h"
17342 #include <wchar.h>
17343 EOF
17344 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17345 { (eval echo configure:17346: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17346 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17347 if test -z "$ac_err"; then
17348   rm -rf conftest*
17349   eval "ac_cv_header_$ac_safe=yes"
17350 else
17351   echo "$ac_err" >&5
17352   echo "configure: failed program was:" >&5
17353   cat conftest.$ac_ext >&5
17354   rm -rf conftest*
17355   eval "ac_cv_header_$ac_safe=no"
17356 fi
17357 rm -f conftest*
17358 fi
17359 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17360   echo "$ac_t""yes" 1>&6
17361   ac_has_wchar_h=yes
17362 else
17363   echo "$ac_t""no" 1>&6
17364 ac_has_wchar_h=no
17365 fi
17366
17367     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
17368 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
17369 echo "configure:17370: checking for wctype.h" >&5
17370 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17371   echo $ac_n "(cached) $ac_c" 1>&6
17372 else
17373   cat > conftest.$ac_ext <<EOF
17374 #line 17375 "configure"
17375 #include "confdefs.h"
17376 #include <wctype.h>
17377 EOF
17378 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17379 { (eval echo configure:17380: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17380 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17381 if test -z "$ac_err"; then
17382   rm -rf conftest*
17383   eval "ac_cv_header_$ac_safe=yes"
17384 else
17385   echo "$ac_err" >&5
17386   echo "configure: failed program was:" >&5
17387   cat conftest.$ac_ext >&5
17388   rm -rf conftest*
17389   eval "ac_cv_header_$ac_safe=no"
17390 fi
17391 rm -f conftest*
17392 fi
17393 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17394   echo "$ac_t""yes" 1>&6
17395   ac_has_wctype_h=yes
17396 else
17397   echo "$ac_t""no" 1>&6
17398 ac_has_wctype_h=no
17399 fi
17400
17401
17402         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
17403
17404                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
17405 echo "configure:17406: checking for mbstate_t" >&5
17406       cat > conftest.$ac_ext <<EOF
17407 #line 17408 "configure"
17408 #include "confdefs.h"
17409 #include <wchar.h>
17410 int main() {
17411 mbstate_t teststate;
17412 ; return 0; }
17413 EOF
17414 if { (eval echo configure:17415: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17415   rm -rf conftest*
17416   use_native_mbstatet=yes
17417 else
17418   echo "configure: failed program was:" >&5
17419   cat conftest.$ac_ext >&5
17420   rm -rf conftest*
17421   use_native_mbstatet=no
17422 fi
17423 rm -f conftest*
17424       echo "$ac_t""$use_native_mbstatet" 1>&6
17425       if test x"$use_native_mbstatet" = xno; then
17426         cat >> confdefs.h <<\EOF
17427 #define _GLIBCPP_NEED_MBSTATE_T 1
17428 EOF
17429
17430       fi
17431
17432                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
17433 echo "configure:17434: checking for WCHAR_MIN and WCHAR_MAX" >&5
17434       cat > conftest.$ac_ext <<EOF
17435 #line 17436 "configure"
17436 #include "confdefs.h"
17437 #include <wchar.h>
17438 int main() {
17439 int i = WCHAR_MIN; int j = WCHAR_MAX;
17440 ; return 0; }
17441 EOF
17442 if { (eval echo configure:17443: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17443   rm -rf conftest*
17444   has_wchar_minmax=yes
17445 else
17446   echo "configure: failed program was:" >&5
17447   cat conftest.$ac_ext >&5
17448   rm -rf conftest*
17449   has_wchar_minmax=no
17450 fi
17451 rm -f conftest*
17452       echo "$ac_t""$has_wchar_minmax" 1>&6
17453
17454                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
17455 echo "configure:17456: checking for WEOF" >&5
17456       cat > conftest.$ac_ext <<EOF
17457 #line 17458 "configure"
17458 #include "confdefs.h"
17459
17460         #include <wchar.h>
17461         #include <stddef.h>
17462 int main() {
17463 wint_t i = WEOF;
17464 ; return 0; }
17465 EOF
17466 if { (eval echo configure:17467: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17467   rm -rf conftest*
17468   has_weof=yes
17469 else
17470   echo "configure: failed program was:" >&5
17471   cat conftest.$ac_ext >&5
17472   rm -rf conftest*
17473   has_weof=no
17474 fi
17475 rm -f conftest*
17476       echo "$ac_t""$has_weof" 1>&6
17477
17478             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
17479       wcsrtombs mbsrtowcs
17480 do
17481 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17482 echo "configure:17483: checking for $ac_func" >&5
17483 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17484   echo $ac_n "(cached) $ac_c" 1>&6
17485 else
17486   cat > conftest.$ac_ext <<EOF
17487 #line 17488 "configure"
17488 #include "confdefs.h"
17489 /* System header to define __stub macros and hopefully few prototypes,
17490     which can conflict with char $ac_func(); below.  */
17491 #include <assert.h>
17492 /* Override any gcc2 internal prototype to avoid an error.  */
17493 /* We use char because int might match the return type of a gcc2
17494     builtin and then its argument prototype would still apply.  */
17495 char $ac_func();
17496
17497 int main() {
17498
17499 /* The GNU C library defines this for functions which it implements
17500     to always fail with ENOSYS.  Some functions are actually named
17501     something starting with __ and the normal name is an alias.  */
17502 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17503 choke me
17504 #else
17505 $ac_func();
17506 #endif
17507
17508 ; return 0; }
17509 EOF
17510 if { (eval echo configure:17511: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17511   rm -rf conftest*
17512   eval "ac_cv_func_$ac_func=yes"
17513 else
17514   echo "configure: failed program was:" >&5
17515   cat conftest.$ac_ext >&5
17516   rm -rf conftest*
17517   eval "ac_cv_func_$ac_func=no"
17518 fi
17519 rm -f conftest*
17520 fi
17521
17522 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17523   echo "$ac_t""yes" 1>&6
17524     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17525   cat >> confdefs.h <<EOF
17526 #define $ac_tr_func 1
17527 EOF
17528  ac_wfuncs=yes
17529 else
17530   echo "$ac_t""no" 1>&6
17531 ac_wfuncs=no
17532 fi
17533 done
17534
17535
17536       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
17537 echo "configure:17538: checking for ISO C99 wchar_t support" >&5
17538       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
17539          && test x"$ac_wfuncs" = xyes; then
17540         ac_isoC99_wchar_t=yes
17541       else
17542         ac_isoC99_wchar_t=no
17543       fi
17544       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
17545
17546                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
17547 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
17548 echo "configure:17549: checking for iconv.h" >&5
17549 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17550   echo $ac_n "(cached) $ac_c" 1>&6
17551 else
17552   cat > conftest.$ac_ext <<EOF
17553 #line 17554 "configure"
17554 #include "confdefs.h"
17555 #include <iconv.h>
17556 EOF
17557 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17558 { (eval echo configure:17559: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17559 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17560 if test -z "$ac_err"; then
17561   rm -rf conftest*
17562   eval "ac_cv_header_$ac_safe=yes"
17563 else
17564   echo "$ac_err" >&5
17565   echo "configure: failed program was:" >&5
17566   cat conftest.$ac_ext >&5
17567   rm -rf conftest*
17568   eval "ac_cv_header_$ac_safe=no"
17569 fi
17570 rm -f conftest*
17571 fi
17572 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17573   echo "$ac_t""yes" 1>&6
17574   ac_has_iconv_h=yes
17575 else
17576   echo "$ac_t""no" 1>&6
17577 ac_has_iconv_h=no
17578 fi
17579
17580       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
17581 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
17582 echo "configure:17583: checking for langinfo.h" >&5
17583 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17584   echo $ac_n "(cached) $ac_c" 1>&6
17585 else
17586   cat > conftest.$ac_ext <<EOF
17587 #line 17588 "configure"
17588 #include "confdefs.h"
17589 #include <langinfo.h>
17590 EOF
17591 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17592 { (eval echo configure:17593: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17593 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17594 if test -z "$ac_err"; then
17595   rm -rf conftest*
17596   eval "ac_cv_header_$ac_safe=yes"
17597 else
17598   echo "$ac_err" >&5
17599   echo "configure: failed program was:" >&5
17600   cat conftest.$ac_ext >&5
17601   rm -rf conftest*
17602   eval "ac_cv_header_$ac_safe=no"
17603 fi
17604 rm -f conftest*
17605 fi
17606 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17607   echo "$ac_t""yes" 1>&6
17608   ac_has_langinfo_h=yes
17609 else
17610   echo "$ac_t""no" 1>&6
17611 ac_has_langinfo_h=no
17612 fi
17613
17614
17615             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
17616 echo "configure:17617: checking for iconv in -liconv" >&5
17617 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
17618 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17619   echo $ac_n "(cached) $ac_c" 1>&6
17620 else
17621   ac_save_LIBS="$LIBS"
17622 LIBS="-liconv  $LIBS"
17623 cat > conftest.$ac_ext <<EOF
17624 #line 17625 "configure"
17625 #include "confdefs.h"
17626 /* Override any gcc2 internal prototype to avoid an error.  */
17627 /* We use char because int might match the return type of a gcc2
17628     builtin and then its argument prototype would still apply.  */
17629 char iconv();
17630
17631 int main() {
17632 iconv()
17633 ; return 0; }
17634 EOF
17635 if { (eval echo configure:17636: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17636   rm -rf conftest*
17637   eval "ac_cv_lib_$ac_lib_var=yes"
17638 else
17639   echo "configure: failed program was:" >&5
17640   cat conftest.$ac_ext >&5
17641   rm -rf conftest*
17642   eval "ac_cv_lib_$ac_lib_var=no"
17643 fi
17644 rm -f conftest*
17645 LIBS="$ac_save_LIBS"
17646
17647 fi
17648 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17649   echo "$ac_t""yes" 1>&6
17650   libiconv="-liconv"
17651 else
17652   echo "$ac_t""no" 1>&6
17653 fi
17654
17655       ac_save_LIBS="$LIBS"
17656       LIBS="$LIBS $libiconv"
17657
17658       for ac_func in iconv_open iconv_close iconv nl_langinfo
17659 do
17660 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17661 echo "configure:17662: checking for $ac_func" >&5
17662 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17663   echo $ac_n "(cached) $ac_c" 1>&6
17664 else
17665   cat > conftest.$ac_ext <<EOF
17666 #line 17667 "configure"
17667 #include "confdefs.h"
17668 /* System header to define __stub macros and hopefully few prototypes,
17669     which can conflict with char $ac_func(); below.  */
17670 #include <assert.h>
17671 /* Override any gcc2 internal prototype to avoid an error.  */
17672 /* We use char because int might match the return type of a gcc2
17673     builtin and then its argument prototype would still apply.  */
17674 char $ac_func();
17675
17676 int main() {
17677
17678 /* The GNU C library defines this for functions which it implements
17679     to always fail with ENOSYS.  Some functions are actually named
17680     something starting with __ and the normal name is an alias.  */
17681 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17682 choke me
17683 #else
17684 $ac_func();
17685 #endif
17686
17687 ; return 0; }
17688 EOF
17689 if { (eval echo configure:17690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17690   rm -rf conftest*
17691   eval "ac_cv_func_$ac_func=yes"
17692 else
17693   echo "configure: failed program was:" >&5
17694   cat conftest.$ac_ext >&5
17695   rm -rf conftest*
17696   eval "ac_cv_func_$ac_func=no"
17697 fi
17698 rm -f conftest*
17699 fi
17700
17701 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17702   echo "$ac_t""yes" 1>&6
17703     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17704   cat >> confdefs.h <<EOF
17705 #define $ac_tr_func 1
17706 EOF
17707  \
17708       ac_XPG2funcs=yes
17709 else
17710   echo "$ac_t""no" 1>&6
17711 ac_XPG2funcs=no
17712 fi
17713 done
17714
17715
17716       LIBS="$ac_save_LIBS"
17717
17718       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
17719 echo "configure:17720: checking for XPG2 wchar_t support" >&5
17720       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
17721          && test x"$ac_XPG2funcs" = xyes; then
17722         ac_XPG2_wchar_t=yes
17723       else
17724         ac_XPG2_wchar_t=no
17725       fi
17726       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
17727
17728                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
17729 echo "configure:17730: checking for enabled wchar_t specializations" >&5
17730       if test x"$ac_isoC99_wchar_t" = xyes \
17731          && test x"$ac_XPG2_wchar_t" = xyes; then
17732         libinst_wstring_la="libinst-wstring.la"
17733         cat >> confdefs.h <<\EOF
17734 #define _GLIBCPP_USE_WCHAR_T 1
17735 EOF
17736
17737         echo "$ac_t"""yes"" 1>&6
17738       else
17739         libinst_wstring_la=""
17740         echo "$ac_t"""no"" 1>&6
17741       fi
17742
17743
17744     else
17745       echo "configure: warning: <wchar.h> not found" 1>&2
17746       cat >> confdefs.h <<\EOF
17747 #define _GLIBCPP_NEED_MBSTATE_T 1
17748 EOF
17749
17750     fi
17751
17752   else
17753         :
17754   fi
17755
17756
17757   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
17758 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
17759 echo "configure:17760: checking for ctype.h" >&5
17760 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17761   echo $ac_n "(cached) $ac_c" 1>&6
17762 else
17763   cat > conftest.$ac_ext <<EOF
17764 #line 17765 "configure"
17765 #include "confdefs.h"
17766 #include <ctype.h>
17767 EOF
17768 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17769 { (eval echo configure:17770: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17770 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17771 if test -z "$ac_err"; then
17772   rm -rf conftest*
17773   eval "ac_cv_header_$ac_safe=yes"
17774 else
17775   echo "$ac_err" >&5
17776   echo "configure: failed program was:" >&5
17777   cat conftest.$ac_ext >&5
17778   rm -rf conftest*
17779   eval "ac_cv_header_$ac_safe=no"
17780 fi
17781 rm -f conftest*
17782 fi
17783 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17784   echo "$ac_t""yes" 1>&6
17785
17786
17787         ctype_default=yes
17788
17789         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
17790 echo "configure:17791: checking <ctype> for GNU/Linux" >&5
17791     cat > conftest.$ac_ext <<EOF
17792 #line 17793 "configure"
17793 #include "confdefs.h"
17794 #include <ctype.h>
17795 int main() {
17796 int
17797     foo (int a)
17798     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
17799         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
17800         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17801 ; return 0; }
17802 EOF
17803 if { (eval echo configure:17804: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17804   rm -rf conftest*
17805   \
17806     ctype_linux=yes
17807 else
17808   echo "configure: failed program was:" >&5
17809   cat conftest.$ac_ext >&5
17810   rm -rf conftest*
17811   ctype_linux=no
17812 fi
17813 rm -f conftest*
17814     echo "$ac_t""$ctype_linux" 1>&6
17815     if test $ctype_linux = "yes"; then
17816       ctype_include_dir="config/os/gnu-linux"
17817       ctype_default=no
17818     fi
17819
17820         if test $ctype_default = "yes"; then
17821     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
17822 echo "configure:17823: checking <ctype> for FreeBSD 4.0" >&5
17823     cat > conftest.$ac_ext <<EOF
17824 #line 17825 "configure"
17825 #include "confdefs.h"
17826 #include <ctype.h>
17827 int main() {
17828 int
17829     foo (int a)
17830     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17831         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17832 ; return 0; }
17833 EOF
17834 if { (eval echo configure:17835: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17835   rm -rf conftest*
17836   \
17837     ctype_bsd=yes
17838 else
17839   echo "configure: failed program was:" >&5
17840   cat conftest.$ac_ext >&5
17841   rm -rf conftest*
17842   ctype_bsd=no
17843 fi
17844 rm -f conftest*
17845     echo "$ac_t""$ctype_bsd" 1>&6
17846     if test $ctype_bsd = "yes"; then
17847       ctype_include_dir="config/os/freebsd"
17848       ctype_default=no
17849     fi
17850     fi
17851
17852         if test $ctype_default = "yes"; then
17853     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
17854 echo "configure:17855: checking <ctype> for FreeBSD 3.4" >&5
17855     cat > conftest.$ac_ext <<EOF
17856 #line 17857 "configure"
17857 #include "confdefs.h"
17858 #include <ctype.h>
17859 int main() {
17860 int
17861     foo (int a)
17862     { return _S + _R + _C + _U + _L + _A \
17863       + _D + _P + _X + _G + __istype (a, 0);}
17864 ; return 0; }
17865 EOF
17866 if { (eval echo configure:17867: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17867   rm -rf conftest*
17868   \
17869     ctype_freebsd34=yes
17870 else
17871   echo "configure: failed program was:" >&5
17872   cat conftest.$ac_ext >&5
17873   rm -rf conftest*
17874   ctype_freebsd34=no
17875 fi
17876 rm -f conftest*
17877     echo "$ac_t""$ctype_freebsd34" 1>&6
17878     if test $ctype_freebsd34 = "yes"; then
17879       ctype_include_dir="config/os/freebsd"
17880       ctype_default=no
17881     fi
17882     fi
17883
17884         if test $ctype_default = "yes"; then
17885     echo $ac_n "checking <ctype> for NetBSD""... $ac_c" 1>&6
17886 echo "configure:17887: checking <ctype> for NetBSD" >&5
17887     cat > conftest.$ac_ext <<EOF
17888 #line 17889 "configure"
17889 #include "confdefs.h"
17890 #include <ctype.h>
17891 int main() {
17892 int
17893     foo (int a)
17894     { return _S + _C + _U + _L \
17895       + _N + _P + _X + _tolower_tab_[a] + _toupper_tab_[a];}
17896 ; return 0; }
17897 EOF
17898 if { (eval echo configure:17899: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17899   rm -rf conftest*
17900   \
17901     ctype_netbsd=yes
17902 else
17903   echo "configure: failed program was:" >&5
17904   cat conftest.$ac_ext >&5
17905   rm -rf conftest*
17906   ctype_netbsd=no
17907 fi
17908 rm -f conftest*
17909     echo "$ac_t""$ctype_netbsd" 1>&6
17910     if test $ctype_netbsd = "yes"; then
17911       ctype_include_dir="config/os/netbsd"
17912       ctype_default=no
17913     fi
17914     fi
17915
17916         if test $ctype_default = "yes"; then
17917     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
17918 echo "configure:17919: checking <ctype> for Solaris 2.6,7,8" >&5
17919     cat > conftest.$ac_ext <<EOF
17920 #line 17921 "configure"
17921 #include "confdefs.h"
17922 #include <ctype.h>
17923 int main() {
17924 int
17925     foo (int a)
17926     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17927         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17928         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17929 ; return 0; }
17930 EOF
17931 if { (eval echo configure:17932: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17932   rm -rf conftest*
17933   \
17934     ctype_solaris=yes
17935 else
17936   echo "configure: failed program was:" >&5
17937   cat conftest.$ac_ext >&5
17938   rm -rf conftest*
17939   ctype_solaris=no
17940 fi
17941 rm -f conftest*
17942     echo "$ac_t""$ctype_solaris" 1>&6
17943
17944     if test $ctype_solaris = "yes"; then
17945       echo $ac_n "checking   for version""... $ac_c" 1>&6
17946 echo "configure:17947: checking   for version" >&5
17947       ac_ext=C
17948 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17949 ac_cpp='$CXXCPP $CPPFLAGS'
17950 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17951 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17952 cross_compiling=$ac_cv_prog_cxx_cross
17953
17954       cat > conftest.$ac_ext <<EOF
17955 #line 17956 "configure"
17956 #include "confdefs.h"
17957 #include <ctype.h>
17958 int main() {
17959 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17960 ; return 0; }
17961 EOF
17962 if { (eval echo configure:17963: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17963   rm -rf conftest*
17964   \
17965       ctype_solaris26=yes
17966 else
17967   echo "configure: failed program was:" >&5
17968   cat conftest.$ac_ext >&5
17969   rm -rf conftest*
17970   ctype_solaris26=no
17971 fi
17972 rm -f conftest*
17973       ac_ext=c
17974 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17975 ac_cpp='$CPP $CPPFLAGS'
17976 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17977 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17978 cross_compiling=$ac_cv_prog_cc_cross
17979
17980       if test $ctype_solaris26 = "yes"; then
17981         ctype_include_dir="config/os/solaris/solaris2.6"
17982         echo "$ac_t""Solaris 2.6" 1>&6
17983         ctype_default=no
17984       else
17985         ctype_include_dir="config/os/solaris/solaris2.7"
17986         echo "$ac_t""Solaris 7,8" 1>&6
17987         ctype_default=no
17988       fi
17989     fi
17990     fi
17991
17992         if test $ctype_default = "yes"; then
17993     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
17994 echo "configure:17995: checking <ctype> for Solaris 2.5.1" >&5
17995     cat > conftest.$ac_ext <<EOF
17996 #line 17997 "configure"
17997 #include "confdefs.h"
17998 #include <ctype.h>
17999 int main() {
18000 int
18001     foo (int a)
18002     { return _U + _L + _N + _S + _P + _C + _X + _B \
18003         + __ctype[a];}
18004 ; return 0; }
18005 EOF
18006 if { (eval echo configure:18007: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18007   rm -rf conftest*
18008   \
18009     ctype_solaris25=yes
18010 else
18011   echo "configure: failed program was:" >&5
18012   cat conftest.$ac_ext >&5
18013   rm -rf conftest*
18014   ctype_solaris25=no
18015 fi
18016 rm -f conftest*
18017     echo "$ac_t""$ctype_solaris25" 1>&6
18018     if test $ctype_solaris25 = "yes"; then
18019       ctype_include_dir="config/os/solaris/solaris2.5"
18020       ctype_default=no
18021     fi
18022     fi
18023
18024         if test $ctype_default = "yes"; then
18025     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
18026 echo "configure:18027: checking <ctype> for AIX" >&5
18027     cat > conftest.$ac_ext <<EOF
18028 #line 18029 "configure"
18029 #include "confdefs.h"
18030 #include <ctype.h>
18031 int main() {
18032 int
18033     foo (int a)
18034     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18035         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18036         + _VALC('a') + _IS('c', 0);}
18037 ; return 0; }
18038 EOF
18039 if { (eval echo configure:18040: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18040   rm -rf conftest*
18041   \
18042     ctype_aix=yes
18043 else
18044   echo "configure: failed program was:" >&5
18045   cat conftest.$ac_ext >&5
18046   rm -rf conftest*
18047   ctype_aix=no
18048 fi
18049 rm -f conftest*
18050     echo "$ac_t""$ctype_aix" 1>&6
18051     if test $ctype_aix = "yes"; then
18052       ctype_include_dir="config/os/aix"
18053       ctype_default=no
18054     fi
18055     fi
18056
18057         if test $ctype_default = "yes"; then
18058     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18059 echo "configure:18060: checking <ctype> for IRIX" >&5
18060     cat > conftest.$ac_ext <<EOF
18061 #line 18062 "configure"
18062 #include "confdefs.h"
18063 #include <ctype.h>
18064 int main() {
18065 int
18066     foo (int a)
18067     { return _U + _L + _N + _S + _P + _C + _B + _X + \
18068              _A + _PR + _G + _BL;}
18069 ; return 0; }
18070 EOF
18071 if { (eval echo configure:18072: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18072   rm -rf conftest*
18073   \
18074     ctype_irix=yes
18075 else
18076   echo "configure: failed program was:" >&5
18077   cat conftest.$ac_ext >&5
18078   rm -rf conftest*
18079   ctype_irix=no
18080 fi
18081 rm -f conftest*
18082     echo "$ac_t""$ctype_irix" 1>&6
18083     if test $ctype_irix = "yes"; then
18084       ctype_include_dir="config/os/irix"
18085       ctype_default=no
18086     fi
18087     fi
18088
18089         if test $ctype_default = "yes"; then
18090     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
18091 echo "configure:18092: checking <ctype> for newlib" >&5
18092     cat > conftest.$ac_ext <<EOF
18093 #line 18094 "configure"
18094 #include "confdefs.h"
18095 #include <ctype.h>
18096 int main() {
18097 int
18098     foo (int a)
18099     { return _U + _L + _N + _S + _P + _C + _X + _B \
18100         + _ctype_[a];}
18101 ; return 0; }
18102 EOF
18103 if { (eval echo configure:18104: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18104   rm -rf conftest*
18105   \
18106     ctype_newlib=yes
18107 else
18108   echo "configure: failed program was:" >&5
18109   cat conftest.$ac_ext >&5
18110   rm -rf conftest*
18111   ctype_newlib=no
18112 fi
18113 rm -f conftest*
18114     echo "$ac_t""$ctype_newlib" 1>&6
18115     if test $ctype_newlib = "yes"; then
18116       ctype_include_dir="config/os/newlib"
18117       ctype_default=no
18118     fi
18119     fi
18120
18121     if test $ctype_default = "yes"; then
18122       ctype_include_dir="config/os/generic"
18123       echo "configure: warning: "Using default ctype headers."" 1>&2
18124     fi
18125
18126
18127
18128
18129
18130 else
18131   echo "$ac_t""no" 1>&6
18132 fi
18133
18134
18135
18136   ac_test_CXXFLAGS="${CXXFLAGS+set}"
18137   ac_save_CXXFLAGS="$CXXFLAGS"
18138   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
18139
18140   for ac_func in strtof
18141 do
18142 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18143 echo "configure:18144: checking for $ac_func" >&5
18144 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18145   echo $ac_n "(cached) $ac_c" 1>&6
18146 else
18147   cat > conftest.$ac_ext <<EOF
18148 #line 18149 "configure"
18149 #include "confdefs.h"
18150 /* System header to define __stub macros and hopefully few prototypes,
18151     which can conflict with char $ac_func(); below.  */
18152 #include <assert.h>
18153 /* Override any gcc2 internal prototype to avoid an error.  */
18154 /* We use char because int might match the return type of a gcc2
18155     builtin and then its argument prototype would still apply.  */
18156 char $ac_func();
18157
18158 int main() {
18159
18160 /* The GNU C library defines this for functions which it implements
18161     to always fail with ENOSYS.  Some functions are actually named
18162     something starting with __ and the normal name is an alias.  */
18163 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18164 choke me
18165 #else
18166 $ac_func();
18167 #endif
18168
18169 ; return 0; }
18170 EOF
18171 if { (eval echo configure:18172: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18172   rm -rf conftest*
18173   eval "ac_cv_func_$ac_func=yes"
18174 else
18175   echo "configure: failed program was:" >&5
18176   cat conftest.$ac_ext >&5
18177   rm -rf conftest*
18178   eval "ac_cv_func_$ac_func=no"
18179 fi
18180 rm -f conftest*
18181 fi
18182
18183 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18184   echo "$ac_t""yes" 1>&6
18185     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18186   cat >> confdefs.h <<EOF
18187 #define $ac_tr_func 1
18188 EOF
18189
18190 else
18191   echo "$ac_t""no" 1>&6
18192 fi
18193 done
18194
18195
18196   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
18197 echo "configure:18198: checking for strtold declaration" >&5
18198   if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
18199   echo $ac_n "(cached) $ac_c" 1>&6
18200 else
18201
18202
18203     ac_ext=C
18204 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18205 ac_cpp='$CXXCPP $CPPFLAGS'
18206 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18207 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18208 cross_compiling=$ac_cv_prog_cxx_cross
18209
18210     cat > conftest.$ac_ext <<EOF
18211 #line 18212 "configure"
18212 #include "confdefs.h"
18213 #include <stdlib.h>
18214 int main() {
18215  strtold(0, 0);
18216 ; return 0; }
18217 EOF
18218 if { (eval echo configure:18219: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18219   rm -rf conftest*
18220   glibcpp_cv_func_strtold_use=yes
18221 else
18222   echo "configure: failed program was:" >&5
18223   cat conftest.$ac_ext >&5
18224   rm -rf conftest*
18225   glibcpp_cv_func_strtold_use=no
18226 fi
18227 rm -f conftest*
18228     ac_ext=c
18229 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18230 ac_cpp='$CPP $CPPFLAGS'
18231 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18232 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18233 cross_compiling=$ac_cv_prog_cc_cross
18234
18235
18236 fi
18237
18238   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
18239   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
18240     for ac_func in strtold
18241 do
18242 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18243 echo "configure:18244: checking for $ac_func" >&5
18244 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18245   echo $ac_n "(cached) $ac_c" 1>&6
18246 else
18247   cat > conftest.$ac_ext <<EOF
18248 #line 18249 "configure"
18249 #include "confdefs.h"
18250 /* System header to define __stub macros and hopefully few prototypes,
18251     which can conflict with char $ac_func(); below.  */
18252 #include <assert.h>
18253 /* Override any gcc2 internal prototype to avoid an error.  */
18254 /* We use char because int might match the return type of a gcc2
18255     builtin and then its argument prototype would still apply.  */
18256 char $ac_func();
18257
18258 int main() {
18259
18260 /* The GNU C library defines this for functions which it implements
18261     to always fail with ENOSYS.  Some functions are actually named
18262     something starting with __ and the normal name is an alias.  */
18263 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18264 choke me
18265 #else
18266 $ac_func();
18267 #endif
18268
18269 ; return 0; }
18270 EOF
18271 if { (eval echo configure:18272: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18272   rm -rf conftest*
18273   eval "ac_cv_func_$ac_func=yes"
18274 else
18275   echo "configure: failed program was:" >&5
18276   cat conftest.$ac_ext >&5
18277   rm -rf conftest*
18278   eval "ac_cv_func_$ac_func=no"
18279 fi
18280 rm -f conftest*
18281 fi
18282
18283 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18284   echo "$ac_t""yes" 1>&6
18285     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18286   cat >> confdefs.h <<EOF
18287 #define $ac_tr_func 1
18288 EOF
18289
18290 else
18291   echo "$ac_t""no" 1>&6
18292 fi
18293 done
18294
18295   fi
18296
18297
18298   CXXFLAGS="$ac_save_CXXFLAGS"
18299
18300
18301   for ac_hdr in unistd.h
18302 do
18303 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18304 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18305 echo "configure:18306: checking for $ac_hdr" >&5
18306 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18307   echo $ac_n "(cached) $ac_c" 1>&6
18308 else
18309   cat > conftest.$ac_ext <<EOF
18310 #line 18311 "configure"
18311 #include "confdefs.h"
18312 #include <$ac_hdr>
18313 EOF
18314 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18315 { (eval echo configure:18316: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18316 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18317 if test -z "$ac_err"; then
18318   rm -rf conftest*
18319   eval "ac_cv_header_$ac_safe=yes"
18320 else
18321   echo "$ac_err" >&5
18322   echo "configure: failed program was:" >&5
18323   cat conftest.$ac_ext >&5
18324   rm -rf conftest*
18325   eval "ac_cv_header_$ac_safe=no"
18326 fi
18327 rm -f conftest*
18328 fi
18329 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18330   echo "$ac_t""yes" 1>&6
18331     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18332   cat >> confdefs.h <<EOF
18333 #define $ac_tr_hdr 1
18334 EOF
18335
18336 else
18337   echo "$ac_t""no" 1>&6
18338 fi
18339 done
18340
18341 for ac_func in getpagesize
18342 do
18343 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18344 echo "configure:18345: checking for $ac_func" >&5
18345 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18346   echo $ac_n "(cached) $ac_c" 1>&6
18347 else
18348   cat > conftest.$ac_ext <<EOF
18349 #line 18350 "configure"
18350 #include "confdefs.h"
18351 /* System header to define __stub macros and hopefully few prototypes,
18352     which can conflict with char $ac_func(); below.  */
18353 #include <assert.h>
18354 /* Override any gcc2 internal prototype to avoid an error.  */
18355 /* We use char because int might match the return type of a gcc2
18356     builtin and then its argument prototype would still apply.  */
18357 char $ac_func();
18358
18359 int main() {
18360
18361 /* The GNU C library defines this for functions which it implements
18362     to always fail with ENOSYS.  Some functions are actually named
18363     something starting with __ and the normal name is an alias.  */
18364 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18365 choke me
18366 #else
18367 $ac_func();
18368 #endif
18369
18370 ; return 0; }
18371 EOF
18372 if { (eval echo configure:18373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18373   rm -rf conftest*
18374   eval "ac_cv_func_$ac_func=yes"
18375 else
18376   echo "configure: failed program was:" >&5
18377   cat conftest.$ac_ext >&5
18378   rm -rf conftest*
18379   eval "ac_cv_func_$ac_func=no"
18380 fi
18381 rm -f conftest*
18382 fi
18383
18384 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18385   echo "$ac_t""yes" 1>&6
18386     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18387   cat >> confdefs.h <<EOF
18388 #define $ac_tr_func 1
18389 EOF
18390
18391 else
18392   echo "$ac_t""no" 1>&6
18393 fi
18394 done
18395
18396 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
18397 echo "configure:18398: checking for working mmap" >&5
18398 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
18399   echo $ac_n "(cached) $ac_c" 1>&6
18400 else
18401   if test "$cross_compiling" = yes; then
18402   ac_cv_func_mmap_fixed_mapped=no
18403 else
18404   cat > conftest.$ac_ext <<EOF
18405 #line 18406 "configure"
18406 #include "confdefs.h"
18407
18408 /* Thanks to Mike Haertel and Jim Avera for this test.
18409    Here is a matrix of mmap possibilities:
18410         mmap private not fixed
18411         mmap private fixed at somewhere currently unmapped
18412         mmap private fixed at somewhere already mapped
18413         mmap shared not fixed
18414         mmap shared fixed at somewhere currently unmapped
18415         mmap shared fixed at somewhere already mapped
18416    For private mappings, we should verify that changes cannot be read()
18417    back from the file, nor mmap's back from the file at a different
18418    address.  (There have been systems where private was not correctly
18419    implemented like the infamous i386 svr4.0, and systems where the
18420    VM page cache was not coherent with the filesystem buffer cache
18421    like early versions of FreeBSD and possibly contemporary NetBSD.)
18422    For shared mappings, we should conversely verify that changes get
18423    propogated back to all the places they're supposed to be.
18424
18425    Grep wants private fixed already mapped.
18426    The main things grep needs to know about mmap are:
18427    * does it exist and is it safe to write into the mmap'd area
18428    * how to use it (BSD variants)  */
18429 #include <sys/types.h>
18430 #include <fcntl.h>
18431 #include <sys/mman.h>
18432
18433 /* This mess was copied from the GNU getpagesize.h.  */
18434 #ifndef HAVE_GETPAGESIZE
18435 # ifdef HAVE_UNISTD_H
18436 #  include <unistd.h>
18437 # endif
18438
18439 /* Assume that all systems that can run configure have sys/param.h.  */
18440 # ifndef HAVE_SYS_PARAM_H
18441 #  define HAVE_SYS_PARAM_H 1
18442 # endif
18443
18444 # ifdef _SC_PAGESIZE
18445 #  define getpagesize() sysconf(_SC_PAGESIZE)
18446 # else /* no _SC_PAGESIZE */
18447 #  ifdef HAVE_SYS_PARAM_H
18448 #   include <sys/param.h>
18449 #   ifdef EXEC_PAGESIZE
18450 #    define getpagesize() EXEC_PAGESIZE
18451 #   else /* no EXEC_PAGESIZE */
18452 #    ifdef NBPG
18453 #     define getpagesize() NBPG * CLSIZE
18454 #     ifndef CLSIZE
18455 #      define CLSIZE 1
18456 #     endif /* no CLSIZE */
18457 #    else /* no NBPG */
18458 #     ifdef NBPC
18459 #      define getpagesize() NBPC
18460 #     else /* no NBPC */
18461 #      ifdef PAGESIZE
18462 #       define getpagesize() PAGESIZE
18463 #      endif /* PAGESIZE */
18464 #     endif /* no NBPC */
18465 #    endif /* no NBPG */
18466 #   endif /* no EXEC_PAGESIZE */
18467 #  else /* no HAVE_SYS_PARAM_H */
18468 #   define getpagesize() 8192   /* punt totally */
18469 #  endif /* no HAVE_SYS_PARAM_H */
18470 # endif /* no _SC_PAGESIZE */
18471
18472 #endif /* no HAVE_GETPAGESIZE */
18473
18474 #ifdef __cplusplus
18475 extern "C" { void *malloc(unsigned); }
18476 #else
18477 char *malloc();
18478 #endif
18479
18480 int
18481 main()
18482 {
18483         char *data, *data2, *data3;
18484         int i, pagesize;
18485         int fd;
18486
18487         pagesize = getpagesize();
18488
18489         /*
18490          * First, make a file with some known garbage in it.
18491          */
18492         data = malloc(pagesize);
18493         if (!data)
18494                 exit(1);
18495         for (i = 0; i < pagesize; ++i)
18496                 *(data + i) = rand();
18497         umask(0);
18498         fd = creat("conftestmmap", 0600);
18499         if (fd < 0)
18500                 exit(1);
18501         if (write(fd, data, pagesize) != pagesize)
18502                 exit(1);
18503         close(fd);
18504
18505         /*
18506          * Next, try to mmap the file at a fixed address which
18507          * already has something else allocated at it.  If we can,
18508          * also make sure that we see the same garbage.
18509          */
18510         fd = open("conftestmmap", O_RDWR);
18511         if (fd < 0)
18512                 exit(1);
18513         data2 = malloc(2 * pagesize);
18514         if (!data2)
18515                 exit(1);
18516         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
18517         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
18518             MAP_PRIVATE | MAP_FIXED, fd, 0L))
18519                 exit(1);
18520         for (i = 0; i < pagesize; ++i)
18521                 if (*(data + i) != *(data2 + i))
18522                         exit(1);
18523
18524         /*
18525          * Finally, make sure that changes to the mapped area
18526          * do not percolate back to the file as seen by read().
18527          * (This is a bug on some variants of i386 svr4.0.)
18528          */
18529         for (i = 0; i < pagesize; ++i)
18530                 *(data2 + i) = *(data2 + i) + 1;
18531         data3 = malloc(pagesize);
18532         if (!data3)
18533                 exit(1);
18534         if (read(fd, data3, pagesize) != pagesize)
18535                 exit(1);
18536         for (i = 0; i < pagesize; ++i)
18537                 if (*(data + i) != *(data3 + i))
18538                         exit(1);
18539         close(fd);
18540         unlink("conftestmmap");
18541         exit(0);
18542 }
18543
18544 EOF
18545 if { (eval echo configure:18546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
18546 then
18547   ac_cv_func_mmap_fixed_mapped=yes
18548 else
18549   echo "configure: failed program was:" >&5
18550   cat conftest.$ac_ext >&5
18551   rm -fr conftest*
18552   ac_cv_func_mmap_fixed_mapped=no
18553 fi
18554 rm -fr conftest*
18555 fi
18556
18557 fi
18558
18559 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
18560 if test $ac_cv_func_mmap_fixed_mapped = yes; then
18561   cat >> confdefs.h <<\EOF
18562 #define HAVE_MMAP 1
18563 EOF
18564
18565 fi
18566
18567 fi
18568
18569
18570
18571 if test "$CANADIAN" = yes; then
18572   CANADIAN_TRUE=
18573   CANADIAN_FALSE='#'
18574 else
18575   CANADIAN_TRUE='#'
18576   CANADIAN_FALSE=
18577 fi
18578
18579
18580 if test "$NULL_TARGET" = yes; then
18581   NULL_TARGET_TRUE=
18582   NULL_TARGET_FALSE='#'
18583 else
18584   NULL_TARGET_TRUE='#'
18585   NULL_TARGET_FALSE=
18586 fi
18587
18588
18589 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
18590   NATIVE_TRUE=
18591   NATIVE_FALSE='#'
18592 else
18593   NATIVE_TRUE='#'
18594   NATIVE_FALSE=
18595 fi
18596
18597
18598 if test -z "$with_cross_host"; then
18599   USE_LIBDIR_TRUE=
18600   USE_LIBDIR_FALSE='#'
18601 else
18602   USE_LIBDIR_TRUE='#'
18603   USE_LIBDIR_FALSE=
18604 fi
18605
18606 cat > confcache <<\EOF
18607 # This file is a shell script that caches the results of configure
18608 # tests run on this system so they can be shared between configure
18609 # scripts and configure runs.  It is not useful on other systems.
18610 # If it contains results you don't want to keep, you may remove or edit it.
18611 #
18612 # By default, configure uses ./config.cache as the cache file,
18613 # creating it if it does not exist already.  You can give configure
18614 # the --cache-file=FILE option to use a different cache file; that is
18615 # what configure does when it calls configure scripts in
18616 # subdirectories, so they share the cache.
18617 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18618 # config.status only pays attention to the cache file if you give it the
18619 # --recheck option to rerun configure.
18620 #
18621 EOF
18622 # The following way of writing the cache mishandles newlines in values,
18623 # but we know of no workaround that is simple, portable, and efficient.
18624 # So, don't put newlines in cache variables' values.
18625 # Ultrix sh set writes to stderr and can't be redirected directly,
18626 # and sets the high bit in the cache file unless we assign to the vars.
18627 (set) 2>&1 |
18628   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18629   *ac_space=\ *)
18630     # `set' does not quote correctly, so add quotes (double-quote substitution
18631     # turns \\\\ into \\, and sed turns \\ into \).
18632     sed -n \
18633       -e "s/'/'\\\\''/g" \
18634       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18635     ;;
18636   *)
18637     # `set' quotes correctly as required by POSIX, so do not add quotes.
18638     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18639     ;;
18640   esac >> confcache
18641 if cmp -s $cache_file confcache; then
18642   :
18643 else
18644   if test -w $cache_file; then
18645     echo "updating cache $cache_file"
18646     cat confcache > $cache_file
18647   else
18648     echo "not updating unwritable cache $cache_file"
18649   fi
18650 fi
18651 rm -f confcache
18652
18653
18654   ac_safe=`echo "locale.h" | sed 'y%./+-%__p_%'`
18655 echo $ac_n "checking for locale.h""... $ac_c" 1>&6
18656 echo "configure:18657: checking for locale.h" >&5
18657 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18658   echo $ac_n "(cached) $ac_c" 1>&6
18659 else
18660   cat > conftest.$ac_ext <<EOF
18661 #line 18662 "configure"
18662 #include "confdefs.h"
18663 #include <locale.h>
18664 EOF
18665 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18666 { (eval echo configure:18667: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18667 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18668 if test -z "$ac_err"; then
18669   rm -rf conftest*
18670   eval "ac_cv_header_$ac_safe=yes"
18671 else
18672   echo "$ac_err" >&5
18673   echo "configure: failed program was:" >&5
18674   cat conftest.$ac_ext >&5
18675   rm -rf conftest*
18676   eval "ac_cv_header_$ac_safe=no"
18677 fi
18678 rm -f conftest*
18679 fi
18680 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18681   echo "$ac_t""yes" 1>&6
18682
18683     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
18684 echo "configure:18685: checking for LC_MESSAGES" >&5
18685 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
18686   echo $ac_n "(cached) $ac_c" 1>&6
18687 else
18688   cat > conftest.$ac_ext <<EOF
18689 #line 18690 "configure"
18690 #include "confdefs.h"
18691 #include <locale.h>
18692 int main() {
18693 return LC_MESSAGES
18694 ; return 0; }
18695 EOF
18696 if { (eval echo configure:18697: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18697   rm -rf conftest*
18698   ac_cv_val_LC_MESSAGES=yes
18699 else
18700   echo "configure: failed program was:" >&5
18701   cat conftest.$ac_ext >&5
18702   rm -rf conftest*
18703   ac_cv_val_LC_MESSAGES=no
18704 fi
18705 rm -f conftest*
18706 fi
18707
18708 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
18709     if test $ac_cv_val_LC_MESSAGES = yes; then
18710       cat >> confdefs.h <<\EOF
18711 #define HAVE_LC_MESSAGES 1
18712 EOF
18713
18714     fi
18715
18716 else
18717   echo "$ac_t""no" 1>&6
18718 fi
18719
18720
18721
18722 if test "${multilib}" = "yes"; then
18723   multilib_arg="--enable-multilib"
18724 else
18725   multilib_arg=
18726 fi
18727
18728
18729 # Generate the various Makefiles, include files, and scripts.
18730
18731 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
18732 # Needed so that g++ can find the correct include subdir automatically.
18733 INTERFACE=v3
18734
18735 # Check for the interface version number for specifying where header
18736 # files are installed, if a version number is provided.
18737 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
18738 echo "configure:18739: checking for interface version number" >&5
18739 libstdcxx_interface=$INTERFACE
18740 echo "$ac_t""$libstdcxx_interface" 1>&6
18741
18742
18743 # Process the option --with-gxx-include-dir=<path to include-files directory>
18744 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
18745 echo "configure:18746: checking for --with-gxx-include-dir" >&5
18746 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
18747 if test "${with_gxx_include_dir+set}" = set; then
18748   withval="$with_gxx_include_dir"
18749   case "${withval}" in
18750   yes)
18751     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
18752     gxx_include_dir=no
18753     ;;
18754   no)
18755     gxx_include_dir=no
18756     ;;
18757   *)
18758     gxx_include_dir=${withval}
18759     ;;
18760 esac
18761 else
18762   gxx_include_dir=no
18763 fi
18764
18765 echo "$ac_t""$gxx_include_dir" 1>&6
18766
18767
18768
18769 if test x${gxx_include_dir} != xno; then
18770   GXX_INCLUDE_DIR_TRUE=
18771   GXX_INCLUDE_DIR_FALSE='#'
18772 else
18773   GXX_INCLUDE_DIR_TRUE='#'
18774   GXX_INCLUDE_DIR_FALSE=
18775 fi
18776
18777 # Process the option "--enable-version-specific-runtime-libs"
18778 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
18779 echo "configure:18780: checking for --enable-version-specific-runtime-libs" >&5
18780 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
18781 if test "${enable_version_specific_runtime_libs+set}" = set; then
18782   enableval="$enable_version_specific_runtime_libs"
18783     version_specific_libs=yes
18784 # Need the gcc compiler version to know where to install libraries
18785 # and header files if --enable-version-specific-runtime-libs option
18786 # is selected.
18787 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
18788 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
18789 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
18790 #gcc_version=$gcc_num-$gcc_date
18791 gcc_version=$gcc_num
18792
18793
18794 else
18795   version_specific_libs=no
18796 fi
18797
18798 echo "$ac_t""$version_specific_libs" 1>&6
18799 if test x${version_specific_libs} = xyes; then
18800
18801
18802 if test x${version_specific_libs} = xyes; then
18803   VERSION_SPECIFIC_LIBS_TRUE=
18804   VERSION_SPECIFIC_LIBS_FALSE='#'
18805 else
18806   VERSION_SPECIFIC_LIBS_TRUE='#'
18807   VERSION_SPECIFIC_LIBS_FALSE=
18808 fi
18809   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
18810 fi
18811
18812
18813
18814 # Export all the include and flag information to makefiles.
18815
18816   # Root level of the include sources.
18817   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
18818
18819   # Can either use include/c or include/c_std to grab "C" headers. This
18820   # variable is set to the include directory currently in use.
18821   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
18822
18823   # Passed down for canadian crosses.
18824   if  test x"$CANADIAN" = xyes; then
18825     TOPLEVEL_INCLUDES='-I$(includedir)'
18826   fi
18827
18828   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
18829
18830   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
18831
18832   #if GLIBCPP_NEED_LIBIO
18833   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
18834   #else
18835   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
18836   #endif
18837
18838   #if GLIBCPP_USE_CSHADOW
18839   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
18840   #                   -I$(top_blddir)/cshadow'
18841   #else
18842   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
18843   #endif
18844
18845   # Now, export this to all the little Makefiles....
18846
18847
18848
18849
18850
18851
18852
18853
18854   # Optimization flags that are probably a good idea for thrill-seekers. Just
18855   # uncomment the lines below and make, everything else is ready to go...
18856   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
18857   OPTIMIZE_CXXFLAGS=
18858
18859
18860   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
18861
18862
18863
18864 # This should be done by mkincludedir, but hack around it now.
18865 blddir=`pwd`
18866 echo "checking for $blddir/include"
18867
18868 if test ! -d "$blddir/include"; then
18869   mkdir "$blddir/include"
18870 fi
18871
18872 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
18873 # so that multilib installs will end up installed in the correct
18874 # place. To work around this not being passed down from config-ml.in
18875 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
18876 # append it here.
18877 trap '' 1 2 15
18878 cat > confcache <<\EOF
18879 # This file is a shell script that caches the results of configure
18880 # tests run on this system so they can be shared between configure
18881 # scripts and configure runs.  It is not useful on other systems.
18882 # If it contains results you don't want to keep, you may remove or edit it.
18883 #
18884 # By default, configure uses ./config.cache as the cache file,
18885 # creating it if it does not exist already.  You can give configure
18886 # the --cache-file=FILE option to use a different cache file; that is
18887 # what configure does when it calls configure scripts in
18888 # subdirectories, so they share the cache.
18889 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18890 # config.status only pays attention to the cache file if you give it the
18891 # --recheck option to rerun configure.
18892 #
18893 EOF
18894 # The following way of writing the cache mishandles newlines in values,
18895 # but we know of no workaround that is simple, portable, and efficient.
18896 # So, don't put newlines in cache variables' values.
18897 # Ultrix sh set writes to stderr and can't be redirected directly,
18898 # and sets the high bit in the cache file unless we assign to the vars.
18899 (set) 2>&1 |
18900   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18901   *ac_space=\ *)
18902     # `set' does not quote correctly, so add quotes (double-quote substitution
18903     # turns \\\\ into \\, and sed turns \\ into \).
18904     sed -n \
18905       -e "s/'/'\\\\''/g" \
18906       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18907     ;;
18908   *)
18909     # `set' quotes correctly as required by POSIX, so do not add quotes.
18910     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18911     ;;
18912   esac >> confcache
18913 if cmp -s $cache_file confcache; then
18914   :
18915 else
18916   if test -w $cache_file; then
18917     echo "updating cache $cache_file"
18918     cat confcache > $cache_file
18919   else
18920     echo "not updating unwritable cache $cache_file"
18921   fi
18922 fi
18923 rm -f confcache
18924
18925 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
18926
18927 test "x$prefix" = xNONE && prefix=$ac_default_prefix
18928 # Let make expand exec_prefix.
18929 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
18930
18931 # Any assignment to VPATH causes Sun make to only execute
18932 # the first set of double-colon rules, so remove it if not needed.
18933 # If there is a colon in the path, we need to keep it.
18934 if test "x$srcdir" = x.; then
18935   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
18936 fi
18937
18938 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
18939
18940 DEFS=-DHAVE_CONFIG_H
18941
18942 # Without the "./", some shells look in PATH for config.status.
18943 : ${CONFIG_STATUS=./config.status}
18944
18945 echo creating $CONFIG_STATUS
18946 rm -f $CONFIG_STATUS
18947 cat > $CONFIG_STATUS <<EOF
18948 #! /bin/sh
18949 # Generated automatically by configure.
18950 # Run this file to recreate the current configuration.
18951 # This directory was configured as follows,
18952 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
18953 #
18954 # $0 $ac_configure_args
18955 #
18956 # Compiler output produced by configure, useful for debugging
18957 # configure, is in ./config.log if it exists.
18958
18959 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
18960 for ac_option
18961 do
18962   case "\$ac_option" in
18963   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
18964     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
18965     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
18966   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
18967     echo "$CONFIG_STATUS generated by autoconf version 2.13"
18968     exit 0 ;;
18969   -help | --help | --hel | --he | --h)
18970     echo "\$ac_cs_usage"; exit 0 ;;
18971   *) echo "\$ac_cs_usage"; exit 1 ;;
18972   esac
18973 done
18974
18975 ac_given_srcdir=$srcdir
18976 ac_given_INSTALL="$INSTALL"
18977
18978 trap 'rm -fr `echo "tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
18979 EOF
18980 cat >> $CONFIG_STATUS <<EOF
18981
18982 # Protect against being on the right side of a sed subst in config.status.
18983 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
18984  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
18985 $ac_vpsub
18986 $extrasub
18987 s%@SHELL@%$SHELL%g
18988 s%@CFLAGS@%$CFLAGS%g
18989 s%@CPPFLAGS@%$CPPFLAGS%g
18990 s%@CXXFLAGS@%$CXXFLAGS%g
18991 s%@FFLAGS@%$FFLAGS%g
18992 s%@DEFS@%$DEFS%g
18993 s%@LDFLAGS@%$LDFLAGS%g
18994 s%@LIBS@%$LIBS%g
18995 s%@exec_prefix@%$exec_prefix%g
18996 s%@prefix@%$prefix%g
18997 s%@program_transform_name@%$program_transform_name%g
18998 s%@bindir@%$bindir%g
18999 s%@sbindir@%$sbindir%g
19000 s%@libexecdir@%$libexecdir%g
19001 s%@datadir@%$datadir%g
19002 s%@sysconfdir@%$sysconfdir%g
19003 s%@sharedstatedir@%$sharedstatedir%g
19004 s%@localstatedir@%$localstatedir%g
19005 s%@libdir@%$libdir%g
19006 s%@includedir@%$includedir%g
19007 s%@oldincludedir@%$oldincludedir%g
19008 s%@infodir@%$infodir%g
19009 s%@mandir@%$mandir%g
19010 s%@host@%$host%g
19011 s%@host_alias@%$host_alias%g
19012 s%@host_cpu@%$host_cpu%g
19013 s%@host_vendor@%$host_vendor%g
19014 s%@host_os@%$host_os%g
19015 s%@target@%$target%g
19016 s%@target_alias@%$target_alias%g
19017 s%@target_cpu@%$target_cpu%g
19018 s%@target_vendor@%$target_vendor%g
19019 s%@target_os@%$target_os%g
19020 s%@build@%$build%g
19021 s%@build_alias@%$build_alias%g
19022 s%@build_cpu@%$build_cpu%g
19023 s%@build_vendor@%$build_vendor%g
19024 s%@build_os@%$build_os%g
19025 s%@glibcpp_basedir@%$glibcpp_basedir%g
19026 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
19027 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
19028 s%@INSTALL_DATA@%$INSTALL_DATA%g
19029 s%@PACKAGE@%$PACKAGE%g
19030 s%@VERSION@%$VERSION%g
19031 s%@ACLOCAL@%$ACLOCAL%g
19032 s%@AUTOCONF@%$AUTOCONF%g
19033 s%@AUTOMAKE@%$AUTOMAKE%g
19034 s%@AUTOHEADER@%$AUTOHEADER%g
19035 s%@MAKEINFO@%$MAKEINFO%g
19036 s%@SET_MAKE@%$SET_MAKE%g
19037 s%@CC@%$CC%g
19038 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
19039 s%@CXX@%$CXX%g
19040 s%@AS@%$AS%g
19041 s%@AR@%$AR%g
19042 s%@RANLIB@%$RANLIB%g
19043 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
19044 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
19045 s%@MAINT@%$MAINT%g
19046 s%@EXEEXT@%$EXEEXT%g
19047 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
19048 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
19049 s%@LN_S@%$LN_S%g
19050 s%@OBJEXT@%$OBJEXT%g
19051 s%@STRIP@%$STRIP%g
19052 s%@LIBTOOL@%$LIBTOOL%g
19053 s%@CXXCPP@%$CXXCPP%g
19054 s%@enable_shared@%$enable_shared%g
19055 s%@enable_static@%$enable_static%g
19056 s%@ifGNUmake@%$ifGNUmake%g
19057 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
19058 s%@CPP@%$CPP%g
19059 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
19060 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
19061 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
19062 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
19063 s%@libio_la@%$libio_la%g
19064 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
19065 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
19066 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
19067 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
19068 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
19069 s%@WERROR@%$WERROR%g
19070 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
19071 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
19072 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
19073 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
19074 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
19075 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
19076 s%@libinst_wstring_la@%$libinst_wstring_la%g
19077 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
19078 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
19079 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
19080 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
19081 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
19082 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
19083 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
19084 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
19085 s%@libstdcxx_interface@%$libstdcxx_interface%g
19086 s%@gxx_include_dir@%$gxx_include_dir%g
19087 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
19088 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
19089 s%@gcc_version@%$gcc_version%g
19090 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
19091 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
19092 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
19093 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
19094 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
19095 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
19096 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
19097 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
19098 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
19099 s%@WARN_FLAGS@%$WARN_FLAGS%g
19100
19101 CEOF
19102 EOF
19103
19104 cat >> $CONFIG_STATUS <<\EOF
19105
19106 # Split the substitutions into bite-sized pieces for seds with
19107 # small command number limits, like on Digital OSF/1 and HP-UX.
19108 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
19109 ac_file=1 # Number of current file.
19110 ac_beg=1 # First line for current file.
19111 ac_end=$ac_max_sed_cmds # Line after last line for current file.
19112 ac_more_lines=:
19113 ac_sed_cmds=""
19114 while $ac_more_lines; do
19115   if test $ac_beg -gt 1; then
19116     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
19117   else
19118     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
19119   fi
19120   if test ! -s conftest.s$ac_file; then
19121     ac_more_lines=false
19122     rm -f conftest.s$ac_file
19123   else
19124     if test -z "$ac_sed_cmds"; then
19125       ac_sed_cmds="sed -f conftest.s$ac_file"
19126     else
19127       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
19128     fi
19129     ac_file=`expr $ac_file + 1`
19130     ac_beg=$ac_end
19131     ac_end=`expr $ac_end + $ac_max_sed_cmds`
19132   fi
19133 done
19134 if test -z "$ac_sed_cmds"; then
19135   ac_sed_cmds=cat
19136 fi
19137 EOF
19138
19139 cat >> $CONFIG_STATUS <<EOF
19140
19141 CONFIG_FILES=\${CONFIG_FILES-"tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
19142 EOF
19143 cat >> $CONFIG_STATUS <<\EOF
19144 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
19145   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19146   case "$ac_file" in
19147   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19148        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19149   *) ac_file_in="${ac_file}.in" ;;
19150   esac
19151
19152   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
19153
19154   # Remove last slash and all that follows it.  Not all systems have dirname.
19155   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19156   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19157     # The file is in a subdirectory.
19158     test ! -d "$ac_dir" && mkdir "$ac_dir"
19159     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
19160     # A "../" for each directory in $ac_dir_suffix.
19161     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
19162   else
19163     ac_dir_suffix= ac_dots=
19164   fi
19165
19166   case "$ac_given_srcdir" in
19167   .)  srcdir=.
19168       if test -z "$ac_dots"; then top_srcdir=.
19169       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
19170   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
19171   *) # Relative path.
19172     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
19173     top_srcdir="$ac_dots$ac_given_srcdir" ;;
19174   esac
19175
19176   case "$ac_given_INSTALL" in
19177   [/$]*) INSTALL="$ac_given_INSTALL" ;;
19178   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
19179   esac
19180
19181   echo creating "$ac_file"
19182   rm -f "$ac_file"
19183   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
19184   case "$ac_file" in
19185   *Makefile*) ac_comsub="1i\\
19186 # $configure_input" ;;
19187   *) ac_comsub= ;;
19188   esac
19189
19190   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19191   sed -e "$ac_comsub
19192 s%@configure_input@%$configure_input%g
19193 s%@srcdir@%$srcdir%g
19194 s%@top_srcdir@%$top_srcdir%g
19195 s%@INSTALL@%$INSTALL%g
19196 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
19197 fi; done
19198 rm -f conftest.s*
19199
19200 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
19201 # NAME is the cpp macro being defined and VALUE is the value it is being given.
19202 #
19203 # ac_d sets the value in "#define NAME VALUE" lines.
19204 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
19205 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
19206 ac_dC='\3'
19207 ac_dD='%g'
19208 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
19209 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19210 ac_uB='\([      ]\)%\1#\2define\3'
19211 ac_uC=' '
19212 ac_uD='\4%g'
19213 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
19214 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19215 ac_eB='$%\1#\2define\3'
19216 ac_eC=' '
19217 ac_eD='%g'
19218
19219 if test "${CONFIG_HEADERS+set}" != set; then
19220 EOF
19221 cat >> $CONFIG_STATUS <<EOF
19222   CONFIG_HEADERS="config.h"
19223 EOF
19224 cat >> $CONFIG_STATUS <<\EOF
19225 fi
19226 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
19227   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19228   case "$ac_file" in
19229   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19230        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19231   *) ac_file_in="${ac_file}.in" ;;
19232   esac
19233
19234   echo creating $ac_file
19235
19236   rm -f conftest.frag conftest.in conftest.out
19237   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19238   cat $ac_file_inputs > conftest.in
19239
19240 EOF
19241
19242 # Transform confdefs.h into a sed script conftest.vals that substitutes
19243 # the proper values into config.h.in to produce config.h.  And first:
19244 # Protect against being on the right side of a sed subst in config.status.
19245 # Protect against being in an unquoted here document in config.status.
19246 rm -f conftest.vals
19247 cat > conftest.hdr <<\EOF
19248 s/[\\&%]/\\&/g
19249 s%[\\$`]%\\&%g
19250 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
19251 s%ac_d%ac_u%gp
19252 s%ac_u%ac_e%gp
19253 EOF
19254 sed -n -f conftest.hdr confdefs.h > conftest.vals
19255 rm -f conftest.hdr
19256
19257 # This sed command replaces #undef with comments.  This is necessary, for
19258 # example, in the case of _POSIX_SOURCE, which is predefined and required
19259 # on some systems where configure will not decide to define it.
19260 cat >> conftest.vals <<\EOF
19261 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
19262 EOF
19263
19264 # Break up conftest.vals because some shells have a limit on
19265 # the size of here documents, and old seds have small limits too.
19266
19267 rm -f conftest.tail
19268 while :
19269 do
19270   ac_lines=`grep -c . conftest.vals`
19271   # grep -c gives empty output for an empty file on some AIX systems.
19272   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
19273   # Write a limited-size here document to conftest.frag.
19274   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
19275   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
19276   echo 'CEOF
19277   sed -f conftest.frag conftest.in > conftest.out
19278   rm -f conftest.in
19279   mv conftest.out conftest.in
19280 ' >> $CONFIG_STATUS
19281   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
19282   rm -f conftest.vals
19283   mv conftest.tail conftest.vals
19284 done
19285 rm -f conftest.vals
19286
19287 cat >> $CONFIG_STATUS <<\EOF
19288   rm -f conftest.frag conftest.h
19289   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
19290   cat conftest.in >> conftest.h
19291   rm -f conftest.in
19292   if cmp -s $ac_file conftest.h 2>/dev/null; then
19293     echo "$ac_file is unchanged"
19294     rm -f conftest.h
19295   else
19296     # Remove last slash and all that follows it.  Not all systems have dirname.
19297       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19298       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19299       # The file is in a subdirectory.
19300       test ! -d "$ac_dir" && mkdir "$ac_dir"
19301     fi
19302     rm -f $ac_file
19303     mv conftest.h $ac_file
19304   fi
19305 fi; done
19306
19307 EOF
19308
19309 cat >> $CONFIG_STATUS <<EOF
19310 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"
19311 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 \
19312         include/bits/ctype_inline.h \
19313         include/bits/ctype_noninline.h include/bits/ctype_base.h \
19314         include/bits/ctype_inline.h \
19315         include/bits/ctype_noninline.h include/bits/ctype_base.h include/bits/ctype_inline.h \
19316     include/bits/ctype_noninline.h"
19317 EOF
19318
19319 cat >> $CONFIG_STATUS <<\EOF
19320 srcdir=$ac_given_srcdir
19321 while test -n "$ac_sources"; do
19322   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
19323   set $ac_sources; ac_source=$1; shift; ac_sources=$*
19324
19325   echo "linking $srcdir/$ac_source to $ac_dest"
19326
19327   if test ! -r $srcdir/$ac_source; then
19328     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
19329   fi
19330   rm -f $ac_dest
19331
19332   # Make relative symlinks.
19333   # Remove last slash and all that follows it.  Not all systems have dirname.
19334   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
19335   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
19336     # The dest file is in a subdirectory.
19337     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
19338     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
19339     # A "../" for each directory in $ac_dest_dir_suffix.
19340     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
19341   else
19342     ac_dest_dir_suffix= ac_dots=
19343   fi
19344
19345   case "$srcdir" in
19346   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
19347   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
19348   esac
19349
19350   # Make a symlink if possible; otherwise try a hard link.
19351   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
19352     ln $srcdir/$ac_source $ac_dest; then :
19353   else
19354     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
19355   fi
19356 done
19357 EOF
19358 cat >> $CONFIG_STATUS <<EOF
19359
19360 srcdir=${srcdir}
19361 host=${host}
19362 target=${target}
19363 with_multisubdir=${with_multisubdir}
19364 ac_configure_args="${multilib_arg} ${ac_configure_args}"
19365 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
19366 glibcpp_basedir=${glibcpp_basedir}
19367 CC="${CC}"
19368 CXX="${CXX}"
19369
19370 EOF
19371 cat >> $CONFIG_STATUS <<\EOF
19372 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
19373 if test -n "$CONFIG_FILES"; then
19374   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
19375   grep '^MULTISUBDIR =' Makefile >> src/Makefile
19376 fi
19377 chmod +x tests_flags
19378 chmod +x mkcheck
19379
19380 exit 0
19381 EOF
19382 chmod +x $CONFIG_STATUS
19383 rm -fr confdefs* $ac_clean_files
19384 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
19385
19386
19387
19388 # Generate bits/c++config.h
19389 # NB: This must be the first generated file as others include it. . .
19390 $srcdir/mkc++config $blddir $srcdir
19391
19392 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
19393 if test ! -f stamp-limits; then
19394   $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
19395   touch stamp-limits
19396 fi
19397
19398
19399 # Sanity checking & User-visible messages.
19400 # Checks down here, otherwise they get scrolled off before
19401 # the user will notice.
19402
19403 # Trying to get more people to read documentation.  Possibly remove
19404 # check and warn all the time. There is no "informational" AC_MSG_
19405 # macro, so these are going to be printed even when --quiet/--silent
19406 # is given.
19407 if test ! -f stamp-sanity-warned; then
19408   touch stamp-sanity-warned
19409   echo ""
19410   echo "Please make certain that you read the installation information here:"
19411   echo "  faster => ${srcdir}/docs/install.html"
19412   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
19413   echo ""
19414   echo "and the configuration information here:"
19415   echo "  faster => ${srcdir}/docs/configopts.html"
19416   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
19417   echo ""
19418   echo "before proceeding with ${_cv_gnu_make_command}."
19419   echo ""
19420 fi
19421
19422
19423
19424
19425
19426