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 GNU libio 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 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2535 echo "configure:2536: checking how to run the C preprocessor" >&5
2536 # On Suns, sometimes $CPP names a directory.
2537 if test -n "$CPP" && test -d "$CPP"; then
2538   CPP=
2539 fi
2540 if test -z "$CPP"; then
2541 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2542   echo $ac_n "(cached) $ac_c" 1>&6
2543 else
2544     # This must be in double quotes, not single quotes, because CPP may get
2545   # substituted into the Makefile and "${CC-cc}" will confuse make.
2546   CPP="${CC-cc} -E"
2547   # On the NeXT, cc -E runs the code through the compiler's parser,
2548   # not just through cpp.
2549   cat > conftest.$ac_ext <<EOF
2550 #line 2551 "configure"
2551 #include "confdefs.h"
2552 #include <assert.h>
2553 Syntax Error
2554 EOF
2555 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2556 { (eval echo configure:2557: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2557 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2558 if test -z "$ac_err"; then
2559   :
2560 else
2561   echo "$ac_err" >&5
2562   echo "configure: failed program was:" >&5
2563   cat conftest.$ac_ext >&5
2564   rm -rf conftest*
2565   CPP="${CC-cc} -E -traditional-cpp"
2566   cat > conftest.$ac_ext <<EOF
2567 #line 2568 "configure"
2568 #include "confdefs.h"
2569 #include <assert.h>
2570 Syntax Error
2571 EOF
2572 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2573 { (eval echo configure:2574: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2574 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2575 if test -z "$ac_err"; then
2576   :
2577 else
2578   echo "$ac_err" >&5
2579   echo "configure: failed program was:" >&5
2580   cat conftest.$ac_ext >&5
2581   rm -rf conftest*
2582   CPP="${CC-cc} -nologo -E"
2583   cat > conftest.$ac_ext <<EOF
2584 #line 2585 "configure"
2585 #include "confdefs.h"
2586 #include <assert.h>
2587 Syntax Error
2588 EOF
2589 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2590 { (eval echo configure:2591: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2591 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2592 if test -z "$ac_err"; then
2593   :
2594 else
2595   echo "$ac_err" >&5
2596   echo "configure: failed program was:" >&5
2597   cat conftest.$ac_ext >&5
2598   rm -rf conftest*
2599   CPP=/lib/cpp
2600 fi
2601 rm -f conftest*
2602 fi
2603 rm -f conftest*
2604 fi
2605 rm -f conftest*
2606   ac_cv_prog_CPP="$CPP"
2607 fi
2608   CPP="$ac_cv_prog_CPP"
2609 else
2610   ac_cv_prog_CPP="$CPP"
2611 fi
2612 echo "$ac_t""$CPP" 1>&6
2613
2614
2615   # Sanity check that g++ is capable of dealing with v-3.
2616   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2617 echo "configure:2618: checking for g++ that will successfully compile this code" >&5
2618   cat > conftest.$ac_ext <<EOF
2619 #line 2620 "configure"
2620 #include "confdefs.h"
2621
2622   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2623     ok
2624   #endif
2625
2626 EOF
2627 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2628   egrep "ok" >/dev/null 2>&1; then
2629   rm -rf conftest*
2630   gpp_satisfactory=yes
2631 else
2632   rm -rf conftest*
2633   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2634 fi
2635 rm -f conftest*
2636
2637   echo "$ac_t""$gpp_satisfactory" 1>&6
2638
2639
2640 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2641 # Check whether --enable-debug or --disable-debug was given.
2642 if test "${enable_debug+set}" = set; then
2643   enableval="$enable_debug"
2644   case "${enableval}" in
2645  yes) enable_debug=yes ;;
2646  no)  enable_debug=no ;;
2647  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2648  esac
2649 else
2650   enable_debug=no
2651 fi
2652
2653 case "${enable_debug}" in
2654     yes)
2655         DEBUG_FLAGS='-O0 -ggdb3'
2656         ;;
2657     no)
2658         DEBUG_FLAGS='-g'
2659         ;;
2660 esac
2661
2662
2663
2664   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2665 echo "configure:2666: checking for cstdio to use" >&5
2666   # Check whether --enable-cstdio or --disable-cstdio was given.
2667 if test "${enable_cstdio+set}" = set; then
2668   enableval="$enable_cstdio"
2669   if test x$enable_cstdio = xno; then
2670      enable_cstdio=libio
2671   fi
2672 else
2673   enable_cstdio=libio
2674 fi
2675
2676
2677   enable_cstdio_flag=$enable_cstdio
2678
2679     case x${enable_cstdio_flag} in
2680     xlibio)
2681       CSTDIO_H=config/c_io_libio.h
2682       CSTDIO_CC=config/c_io_libio.cc
2683       echo "$ac_t""libio" 1>&6
2684
2685       # see if we are on a system with libio native (ie, linux)
2686       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2687 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2688 echo "configure:2689: checking for libio.h" >&5
2689 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2690   echo $ac_n "(cached) $ac_c" 1>&6
2691 else
2692   cat > conftest.$ac_ext <<EOF
2693 #line 2694 "configure"
2694 #include "confdefs.h"
2695 #include <libio.h>
2696 EOF
2697 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2698 { (eval echo configure:2699: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2699 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2700 if test -z "$ac_err"; then
2701   rm -rf conftest*
2702   eval "ac_cv_header_$ac_safe=yes"
2703 else
2704   echo "$ac_err" >&5
2705   echo "configure: failed program was:" >&5
2706   cat conftest.$ac_ext >&5
2707   rm -rf conftest*
2708   eval "ac_cv_header_$ac_safe=no"
2709 fi
2710 rm -f conftest*
2711 fi
2712 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2713   echo "$ac_t""yes" 1>&6
2714   has_libio=yes
2715 else
2716   echo "$ac_t""no" 1>&6
2717 has_libio=no
2718 fi
2719
2720
2721       # Need to check and see what version of glibc is being used. If
2722       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2723       # compile most of libio for linux systems.
2724       if test x$has_libio = x"yes"; then
2725         case "$target" in
2726           *-*-linux*)
2727               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2728 echo "configure:2729: checking for glibc version >= 2.2" >&5
2729               cat > conftest.$ac_ext <<EOF
2730 #line 2731 "configure"
2731 #include "confdefs.h"
2732
2733             #include <features.h>
2734               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2735                     ok
2736               #endif
2737
2738 EOF
2739 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2740   egrep "ok" >/dev/null 2>&1; then
2741   rm -rf conftest*
2742   glibc_satisfactory=yes
2743 else
2744   rm -rf conftest*
2745   glibc_satisfactory=no
2746 fi
2747 rm -f conftest*
2748
2749               echo "$ac_t""$glibc_satisfactory" 1>&6
2750             ;;
2751         esac
2752
2753         # XXX at the moment, admit defeat and force the recompilation
2754         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2755         glibc_satisfactory=no
2756
2757         if test x$glibc_satisfactory = x"yes"; then
2758            need_libio=no
2759            need_wlibio=no
2760         else
2761            need_libio=yes
2762            # bkoz XXX need to add checks to enable this
2763            # pme XXX here's a first pass at such a check
2764            if test x$enable_c_mbchar != xno; then
2765               need_wlibio=yes
2766            else
2767               need_wlibio=no
2768            fi
2769         fi
2770
2771       else
2772          # Using libio, but <libio.h> doesn't exist on the target system. . .
2773          need_libio=yes
2774          # bkoz XXX need to add checks to enable this
2775          # pme XXX here's a first pass at such a check
2776          if test x$enable_c_mbchar != xno; then
2777              need_wlibio=yes
2778          else
2779              need_wlibio=no
2780          fi
2781       fi
2782       ;;
2783     xstdio | x | xno | xnone | xyes)
2784       # default
2785       CSTDIO_H=config/c_io_stdio.h
2786       CSTDIO_CC=config/c_io_stdio.cc
2787       echo "$ac_t""stdio" 1>&6
2788
2789       # We're not using stdio.
2790       need_libio=no
2791       need_wlibio=no
2792       # Wide characters are not supported with this package.
2793       enable_c_mbchar=no
2794       ;;
2795     *)
2796       echo "$enable_cstdio is an unknown io package" 1>&2
2797       exit 1
2798       ;;
2799   esac
2800
2801
2802
2803   # 2000-08-04 bkoz hack
2804   CCODECVT_C=config/c_io_libio_codecvt.c
2805
2806   # 2000-08-04 bkoz hack
2807
2808
2809
2810 if test "$need_libio" = yes; then
2811   GLIBCPP_NEED_LIBIO_TRUE=
2812   GLIBCPP_NEED_LIBIO_FALSE='#'
2813 else
2814   GLIBCPP_NEED_LIBIO_TRUE='#'
2815   GLIBCPP_NEED_LIBIO_FALSE=
2816 fi
2817
2818
2819 if test "$need_wlibio" = yes; then
2820   GLIBCPP_NEED_WLIBIO_TRUE=
2821   GLIBCPP_NEED_WLIBIO_FALSE='#'
2822 else
2823   GLIBCPP_NEED_WLIBIO_TRUE='#'
2824   GLIBCPP_NEED_WLIBIO_FALSE=
2825 fi
2826   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2827         libio_la=../libio/libio.la
2828   else
2829         libio_la=
2830   fi
2831
2832
2833 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2834 if test "${enable_c_mbchar+set}" = set; then
2835   enableval="$enable_c_mbchar"
2836   case "$enableval" in
2837  yes) enable_c_mbchar=yes ;;
2838  no)  enable_c_mbchar=no ;;
2839  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2840  esac
2841 else
2842   enable_c_mbchar=yes
2843 fi
2844
2845
2846   # Check whether --enable-long-long or --disable-long-long was given.
2847 if test "${enable_long_long+set}" = set; then
2848   enableval="$enable_long_long"
2849     case "$enableval" in
2850    yes) enable_long_long=yes ;;
2851    no)  enable_long_long=no ;;
2852    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2853    esac
2854 else
2855   enable_long_long=yes
2856 fi
2857
2858   # Check for the existance of functions used if long long is enabled.
2859   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2860 echo "configure:2861: checking for strtoll" >&5
2861 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2862   echo $ac_n "(cached) $ac_c" 1>&6
2863 else
2864   cat > conftest.$ac_ext <<EOF
2865 #line 2866 "configure"
2866 #include "confdefs.h"
2867 /* System header to define __stub macros and hopefully few prototypes,
2868     which can conflict with char strtoll(); below.  */
2869 #include <assert.h>
2870 /* Override any gcc2 internal prototype to avoid an error.  */
2871 /* We use char because int might match the return type of a gcc2
2872     builtin and then its argument prototype would still apply.  */
2873 char strtoll();
2874
2875 int main() {
2876
2877 /* The GNU C library defines this for functions which it implements
2878     to always fail with ENOSYS.  Some functions are actually named
2879     something starting with __ and the normal name is an alias.  */
2880 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2881 choke me
2882 #else
2883 strtoll();
2884 #endif
2885
2886 ; return 0; }
2887 EOF
2888 if { (eval echo configure:2889: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2889   rm -rf conftest*
2890   eval "ac_cv_func_strtoll=yes"
2891 else
2892   echo "configure: failed program was:" >&5
2893   cat conftest.$ac_ext >&5
2894   rm -rf conftest*
2895   eval "ac_cv_func_strtoll=no"
2896 fi
2897 rm -f conftest*
2898 fi
2899
2900 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2901   echo "$ac_t""yes" 1>&6
2902   :
2903 else
2904   echo "$ac_t""no" 1>&6
2905 ac_strtoll=no
2906 fi
2907
2908   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2909 echo "configure:2910: checking for strtoull" >&5
2910 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2911   echo $ac_n "(cached) $ac_c" 1>&6
2912 else
2913   cat > conftest.$ac_ext <<EOF
2914 #line 2915 "configure"
2915 #include "confdefs.h"
2916 /* System header to define __stub macros and hopefully few prototypes,
2917     which can conflict with char strtoull(); below.  */
2918 #include <assert.h>
2919 /* Override any gcc2 internal prototype to avoid an error.  */
2920 /* We use char because int might match the return type of a gcc2
2921     builtin and then its argument prototype would still apply.  */
2922 char strtoull();
2923
2924 int main() {
2925
2926 /* The GNU C library defines this for functions which it implements
2927     to always fail with ENOSYS.  Some functions are actually named
2928     something starting with __ and the normal name is an alias.  */
2929 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2930 choke me
2931 #else
2932 strtoull();
2933 #endif
2934
2935 ; return 0; }
2936 EOF
2937 if { (eval echo configure:2938: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2938   rm -rf conftest*
2939   eval "ac_cv_func_strtoull=yes"
2940 else
2941   echo "configure: failed program was:" >&5
2942   cat conftest.$ac_ext >&5
2943   rm -rf conftest*
2944   eval "ac_cv_func_strtoull=no"
2945 fi
2946 rm -f conftest*
2947 fi
2948
2949 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2950   echo "$ac_t""yes" 1>&6
2951   :
2952 else
2953   echo "$ac_t""no" 1>&6
2954 ac_strtoull=no
2955 fi
2956
2957
2958   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2959 echo "configure:2960: checking for enabled long long" >&5
2960   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2961     enable_long_long=no;
2962   fi;
2963   echo "$ac_t""$enable_long_long" 1>&6
2964
2965     if test x"$enable_long_long" = xyes; then
2966     cat >> confdefs.h <<\EOF
2967 #define _GLIBCPP_USE_LONG_LONG 1
2968 EOF
2969
2970   fi
2971
2972 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2973 echo "configure:2974: checking for enabled cshadow headers" >&5
2974 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2975 if test "${enable_cshadow_headers+set}" = set; then
2976   enableval="$enable_cshadow_headers"
2977
2978   case "$enableval" in
2979    yes) enable_cshadow_headers=yes
2980         ;;
2981    no)  enable_cshadow_headers=no
2982         ;;
2983    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
2984         ;;
2985   esac
2986 else
2987   enable_cshadow_headers=no
2988 fi
2989
2990   echo "$ac_t""$enable_cshadow_headers" 1>&6
2991
2992       case "$enable_cshadow_headers" in
2993     yes)
2994         CSHADOW_FLAGS="-fno-builtin"
2995         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
2996         cat >> confdefs.h <<\EOF
2997 #define _GLIBCPP_USE_SHADOW_HEADERS 1
2998 EOF
2999
3000         ;;
3001     no)
3002         CSHADOW_FLAGS=""
3003         C_INCLUDE_DIR='${top_srcdir}/include/c'
3004         ;;
3005   esac
3006
3007
3008
3009
3010
3011 if test "$enable_cshadow_headers" = yes; then
3012   GLIBCPP_USE_CSHADOW_TRUE=
3013   GLIBCPP_USE_CSHADOW_FALSE='#'
3014 else
3015   GLIBCPP_USE_CSHADOW_TRUE='#'
3016   GLIBCPP_USE_CSHADOW_FALSE=
3017 fi
3018
3019
3020       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3021 echo "configure:3022: checking for threads package to use" >&5
3022   # Check whether --enable-threads or --disable-threads was given.
3023 if test "${enable_threads+set}" = set; then
3024   enableval="$enable_threads"
3025   if test x$enable_threads = xno; then
3026     enable_threads=''
3027   fi
3028 else
3029   enable_threads=''
3030 fi
3031
3032
3033   enable_threads_flag=$enable_threads
3034
3035     case x${enable_threads_flag} in
3036         x | xno | xnone)
3037                 # No threads
3038                 target_thread_file='single'
3039                 ;;
3040         xyes)
3041                 # default
3042                 target_thread_file='posix'
3043                 ;;
3044         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3045         xsolaris | xwin32 | xdce | xvxworks)
3046                 target_thread_file=$enable_threads_flag
3047                 ;;
3048         *)
3049                 echo "$enable_threads is an unknown thread package" 1>&2
3050                 exit 1
3051                 ;;
3052   esac
3053
3054     THREADH=
3055   case "$target_thread_file" in
3056     no | none | single)
3057       THREADH=threads-no.h
3058       ;;
3059     posix | pthreads)
3060       THREADH=threads-posix.h
3061       ;;
3062     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3063       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3064       ;;
3065     *)
3066       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3067       ;;
3068   esac
3069   echo "$ac_t""$THREADH" 1>&6
3070
3071
3072   if test $THREADH != threads-no.h; then
3073     cat >> confdefs.h <<\EOF
3074 #define _GLIBCPP_USE_THREADS 1
3075 EOF
3076
3077   fi
3078
3079
3080     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3081 echo "configure:3082: checking for atomicity.h" >&5
3082     case "$target" in
3083       *-*-linux* | sparc*-*-* | *-*-freebsd*)
3084         ATOMICITYH=$cpu_include_dir
3085         ;;
3086       *-*-aix* | *-*-irix*)
3087         ATOMICITYH=$os_include_dir
3088         ;;
3089       *)
3090         # bit of overkill on this text...
3091         { echo "configure: error: Atomic locking requested, but $enable_threads is an unknown thread package and atomic operations are not present in the CPU" 1>&2; exit 1; }
3092         ;;
3093     esac
3094     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3095
3096
3097 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3098 if test "${enable_cxx_flags+set}" = set; then
3099   enableval="$enable_cxx_flags"
3100   case "x$enableval" in
3101  xyes)
3102         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3103  xno|x)
3104         enable_cxx_flags='' ;;
3105  *)
3106         enable_cxx_flags="$enableval" ;;
3107  esac
3108 else
3109   enable_cxx_flags='none'
3110 fi
3111
3112
3113 if test "$enable_cxx_flags" = "none"; then
3114   enable_cxx_flags='';
3115 fi
3116
3117 if test -n "$enable_cxx_flags"; then
3118     for f in $enable_cxx_flags; do
3119         case "$f" in
3120             -fhonor-std)  ;;
3121             -*)  ;;
3122             *)   # and we're trying to pass /what/ exactly?
3123                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3124         esac
3125     done
3126 fi
3127 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3128
3129
3130
3131
3132 if test -n "$with_cross_host"; then
3133
3134   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3135   # may not work correctly, because the compiler may not be able to
3136   # link executables.
3137
3138   xcompiling=1
3139   NATIVE=no
3140   # If Canadian cross, then don't pick up tools from the build
3141   # directory.
3142   if test "$build" != "$with_cross_host"; then
3143     CANADIAN=yes
3144     NULL_TARGET=yes
3145   else
3146     CANADIAN=no
3147     NULL_TARGET=no
3148   fi
3149
3150   case "$target_alias" in
3151     *-wince-*)
3152         # Configure for Microsoft Windows CE, or whatever they are
3153         # currently calling it.
3154         cat >> confdefs.h <<\EOF
3155 #define HAVE_FLOAT_H 1
3156 EOF
3157
3158
3159         cat >> confdefs.h <<\EOF
3160 #define HAVE__FINITE 1
3161 EOF
3162
3163         cat >> confdefs.h <<\EOF
3164 #define HAVE__ISNAN 1
3165 EOF
3166
3167         cat >> confdefs.h <<\EOF
3168 #define HAVE__COPYSIGN 1
3169 EOF
3170
3171         cat >> confdefs.h <<\EOF
3172 #define HAVE__FPCLASS 1
3173 EOF
3174
3175         cat >> confdefs.h <<\EOF
3176 #define HAVE_MODF 1
3177 EOF
3178
3179
3180         ctype_include_dir="config/os/wince"
3181
3182
3183
3184
3185
3186         cat >> confdefs.h <<\EOF
3187 #define _GLIBCPP_NEED_MBSTATE_T 1
3188 EOF
3189
3190
3191         cat >> confdefs.h <<\EOF
3192 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3193 EOF
3194
3195         cat >> confdefs.h <<\EOF
3196 #define _GLIBCPP_BUGGY_COMPLEX 1
3197 EOF
3198
3199         ;;
3200     *)
3201         # We assume newlib.  This lets us hard-code the functions we know
3202         # we'll have.
3203         cat >> confdefs.h <<\EOF
3204 #define HAVE_FINITE 1
3205 EOF
3206
3207         cat >> confdefs.h <<\EOF
3208 #define HAVE_ISNAN 1
3209 EOF
3210
3211         cat >> confdefs.h <<\EOF
3212 #define HAVE_ISNANF 1
3213 EOF
3214
3215         cat >> confdefs.h <<\EOF
3216 #define HAVE_ISINF 1
3217 EOF
3218
3219         cat >> confdefs.h <<\EOF
3220 #define HAVE_ISINFF 1
3221 EOF
3222
3223
3224         ctype_include_dir="config/os/newlib"
3225
3226
3227
3228
3229         cat >> confdefs.h <<\EOF
3230 #define _GLIBCPP_NEED_MBSTATE_T 1
3231 EOF
3232
3233
3234         cat >> confdefs.h <<\EOF
3235 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3236 EOF
3237
3238         cat >> confdefs.h <<\EOF
3239 #define _GLIBCPP_BUGGY_COMPLEX 1
3240 EOF
3241
3242         # need to check for faster f versions of math functions, ie sinf?
3243         ;;
3244   esac
3245 else
3246
3247   # We are being configured natively. We can do more elaborate tests
3248   # that include AC_TRY_COMPILE now, as the linker is assumed to be
3249   # working.
3250
3251   xcompiling=0
3252   NATIVE=yes
3253   CANADIAN=no
3254   NULL_TARGET=no
3255
3256   # Check for available headers.
3257   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
3258   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
3259 do
3260 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3261 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3262 echo "configure:3263: checking for $ac_hdr" >&5
3263 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3264   echo $ac_n "(cached) $ac_c" 1>&6
3265 else
3266   cat > conftest.$ac_ext <<EOF
3267 #line 3268 "configure"
3268 #include "confdefs.h"
3269 #include <$ac_hdr>
3270 EOF
3271 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3272 { (eval echo configure:3273: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3273 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3274 if test -z "$ac_err"; then
3275   rm -rf conftest*
3276   eval "ac_cv_header_$ac_safe=yes"
3277 else
3278   echo "$ac_err" >&5
3279   echo "configure: failed program was:" >&5
3280   cat conftest.$ac_ext >&5
3281   rm -rf conftest*
3282   eval "ac_cv_header_$ac_safe=no"
3283 fi
3284 rm -f conftest*
3285 fi
3286 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3287   echo "$ac_t""yes" 1>&6
3288     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3289   cat >> confdefs.h <<EOF
3290 #define $ac_tr_hdr 1
3291 EOF
3292
3293 else
3294   echo "$ac_t""no" 1>&6
3295 fi
3296 done
3297
3298
3299
3300   # All these tests are for C++; save the language and the compiler flags.
3301   # The CXXFLAGS thing is suspicious, but based on similar bits
3302   # found in GLIBCPP_CONFIGURE.
3303
3304   ac_ext=C
3305 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3306 ac_cpp='$CXXCPP $CPPFLAGS'
3307 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3308 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3309 cross_compiling=$ac_cv_prog_cxx_cross
3310
3311   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3312   ac_save_CXXFLAGS="$CXXFLAGS"
3313
3314   # Check for maintainer-mode bits.
3315   if test x"$USE_MAINTAINER_MODE" = xno; then
3316     WERROR=''
3317   else
3318     WERROR='-Werror'
3319   fi
3320
3321   # Check for more sophisticated diagnostic control.
3322   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
3323 echo "configure:3324: checking for g++ that supports -fdiagnostics-show-location=once" >&5
3324   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
3325   cat > conftest.$ac_ext <<EOF
3326 #line 3327 "configure"
3327 #include "confdefs.h"
3328
3329 int main() {
3330 int foo;
3331
3332 ; return 0; }
3333 EOF
3334 if { (eval echo configure:3335: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3335   rm -rf conftest*
3336   ac_gabydiags=yes
3337 else
3338   echo "configure: failed program was:" >&5
3339   cat conftest.$ac_ext >&5
3340   rm -rf conftest*
3341   ac_gabydiags=no
3342 fi
3343 rm -f conftest*
3344   if test "$ac_test_CXXFLAGS" = set; then
3345     CXXFLAGS="$ac_save_CXXFLAGS"
3346   else
3347     # this is the suspicious part
3348     CXXFLAGS=''
3349   fi
3350   if test "$ac_gabydiags" = "yes"; then
3351     WFMT_FLAGS='-fdiagnostics-show-location=once'
3352   fi
3353   echo "$ac_t""$ac_gabydiags" 1>&6
3354
3355   # Check for -ffunction-sections -fdata-sections
3356   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
3357 echo "configure:3358: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
3358   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
3359   cat > conftest.$ac_ext <<EOF
3360 #line 3361 "configure"
3361 #include "confdefs.h"
3362
3363 int main() {
3364 int foo;
3365
3366 ; return 0; }
3367 EOF
3368 if { (eval echo configure:3369: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3369   rm -rf conftest*
3370   ac_fdsections=yes
3371 else
3372   echo "configure: failed program was:" >&5
3373   cat conftest.$ac_ext >&5
3374   rm -rf conftest*
3375   ac_fdsections=no
3376 fi
3377 rm -f conftest*
3378   if test "$ac_test_CXXFLAGS" = set; then
3379     CXXFLAGS="$ac_save_CXXFLAGS"
3380   else
3381     # this is the suspicious part
3382     CXXFLAGS=''
3383   fi
3384   if test "$ac_fdsections" = "yes"; then
3385     SECTION_FLAGS='-ffunction-sections -fdata-sections'
3386   fi
3387   echo "$ac_t""$ac_fdsections" 1>&6
3388
3389   ac_ext=c
3390 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3391 ac_cpp='$CPP $CPPFLAGS'
3392 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3393 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3394 cross_compiling=$ac_cv_prog_cc_cross
3395
3396
3397
3398
3399
3400
3401   # If we're not using GNU ld, then there's no point in even trying these
3402   # tests.  Check for that first.  We should have already tested for gld
3403   # by now (in libtool), but require it now just to be safe...
3404   SECTION_LDFLAGS=''
3405   OPT_LDFLAGS=''
3406
3407
3408   # Set --gc-sections.
3409   if test "$ac_cv_prog_gnu_ld" = "broken"; then
3410     # GNU ld it is!  Joy and bunny rabbits!
3411
3412     # All these tests are for C++; save the language and the compiler flags.
3413     # Need to do this so that g++ won't try to link in libstdc++
3414     ac_test_CFLAGS="${CFLAGS+set}"
3415     ac_save_CFLAGS="$CFLAGS"
3416     CFLAGS='-x c++  -Wl,--gc-sections'
3417
3418     # Check for -Wl,--gc-sections
3419     # XXX This test is broken at the moment, as symbols required for
3420     # linking are now in libsupc++ (not built yet.....). In addition,
3421     # this test has cored on solaris in the past. In addition,
3422     # --gc-sections doesn't really work at the moment (keeps on discarding
3423     # used sections, first .eh_frame and now some of the glibc sections for
3424     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3425     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3426 echo "configure:3427: checking for ld that supports -Wl,--gc-sections" >&5
3427     if test "$cross_compiling" = yes; then
3428   ac_sectionLDflags=yes
3429 else
3430   cat > conftest.$ac_ext <<EOF
3431 #line 3432 "configure"
3432 #include "confdefs.h"
3433
3434      int main(void)
3435      {
3436        try { throw 1; }
3437        catch (...) { };
3438        return 0;
3439      }
3440
3441 EOF
3442 if { (eval echo configure:3443: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3443 then
3444   ac_sectionLDflags=yes
3445 else
3446   echo "configure: failed program was:" >&5
3447   cat conftest.$ac_ext >&5
3448   rm -fr conftest*
3449   ac_sectionLFflags=no
3450 fi
3451 rm -fr conftest*
3452 fi
3453
3454     if test "$ac_test_CFLAGS" = set; then
3455       CFLAGS="$ac_save_CFLAGS"
3456     else
3457       # this is the suspicious part
3458       CFLAGS=''
3459     fi
3460     if test "$ac_sectionLDflags" = "yes"; then
3461       SECTION_LDFLAGS='-Wl,--gc-sections'
3462     fi
3463     echo "$ac_t""$ac_sectionLDflags" 1>&6
3464   fi
3465
3466   # Set linker optimization flags.
3467   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3468     OPT_LDFLAGS='-Wl,-O1'
3469   fi
3470
3471
3472
3473
3474
3475
3476   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3477 echo "configure:3478: checking for __builtin_abs declaration" >&5
3478   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
3479   echo $ac_n "(cached) $ac_c" 1>&6
3480 else
3481
3482
3483     ac_ext=C
3484 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3485 ac_cpp='$CXXCPP $CPPFLAGS'
3486 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3487 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3488 cross_compiling=$ac_cv_prog_cxx_cross
3489
3490     cat > conftest.$ac_ext <<EOF
3491 #line 3492 "configure"
3492 #include "confdefs.h"
3493 #include <math.h>
3494 int main() {
3495  __builtin_abs(0);
3496 ; return 0; }
3497 EOF
3498 if { (eval echo configure:3499: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3499   rm -rf conftest*
3500   glibcpp_cv_func___builtin_abs_use=yes
3501 else
3502   echo "configure: failed program was:" >&5
3503   cat conftest.$ac_ext >&5
3504   rm -rf conftest*
3505   glibcpp_cv_func___builtin_abs_use=no
3506 fi
3507 rm -f conftest*
3508     ac_ext=c
3509 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3510 ac_cpp='$CPP $CPPFLAGS'
3511 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3512 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3513 cross_compiling=$ac_cv_prog_cc_cross
3514
3515
3516 fi
3517
3518   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
3519   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
3520     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3521 echo "configure:3522: checking for __builtin_abs linkage" >&5
3522     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
3523   echo $ac_n "(cached) $ac_c" 1>&6
3524 else
3525
3526       cat > conftest.$ac_ext <<EOF
3527 #line 3528 "configure"
3528 #include "confdefs.h"
3529 #include <math.h>
3530 int main() {
3531  __builtin_abs(0);
3532 ; return 0; }
3533 EOF
3534 if { (eval echo configure:3535: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3535   rm -rf conftest*
3536   glibcpp_cv_func___builtin_abs_link=yes
3537 else
3538   echo "configure: failed program was:" >&5
3539   cat conftest.$ac_ext >&5
3540   rm -rf conftest*
3541   glibcpp_cv_func___builtin_abs_link=no
3542 fi
3543 rm -f conftest*
3544
3545 fi
3546
3547     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
3548     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
3549       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3550       cat >> confdefs.h <<EOF
3551 #define ${ac_tr_func} 1
3552 EOF
3553
3554     fi
3555   fi
3556
3557
3558   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3559 echo "configure:3560: checking for __builtin_fabsf declaration" >&5
3560   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
3561   echo $ac_n "(cached) $ac_c" 1>&6
3562 else
3563
3564
3565     ac_ext=C
3566 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3567 ac_cpp='$CXXCPP $CPPFLAGS'
3568 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3569 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3570 cross_compiling=$ac_cv_prog_cxx_cross
3571
3572     cat > conftest.$ac_ext <<EOF
3573 #line 3574 "configure"
3574 #include "confdefs.h"
3575 #include <math.h>
3576 int main() {
3577  __builtin_fabsf(0);
3578 ; return 0; }
3579 EOF
3580 if { (eval echo configure:3581: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3581   rm -rf conftest*
3582   glibcpp_cv_func___builtin_fabsf_use=yes
3583 else
3584   echo "configure: failed program was:" >&5
3585   cat conftest.$ac_ext >&5
3586   rm -rf conftest*
3587   glibcpp_cv_func___builtin_fabsf_use=no
3588 fi
3589 rm -f conftest*
3590     ac_ext=c
3591 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3592 ac_cpp='$CPP $CPPFLAGS'
3593 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3594 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3595 cross_compiling=$ac_cv_prog_cc_cross
3596
3597
3598 fi
3599
3600   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
3601   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
3602     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3603 echo "configure:3604: checking for __builtin_fabsf linkage" >&5
3604     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
3605   echo $ac_n "(cached) $ac_c" 1>&6
3606 else
3607
3608       cat > conftest.$ac_ext <<EOF
3609 #line 3610 "configure"
3610 #include "confdefs.h"
3611 #include <math.h>
3612 int main() {
3613  __builtin_fabsf(0);
3614 ; return 0; }
3615 EOF
3616 if { (eval echo configure:3617: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3617   rm -rf conftest*
3618   glibcpp_cv_func___builtin_fabsf_link=yes
3619 else
3620   echo "configure: failed program was:" >&5
3621   cat conftest.$ac_ext >&5
3622   rm -rf conftest*
3623   glibcpp_cv_func___builtin_fabsf_link=no
3624 fi
3625 rm -f conftest*
3626
3627 fi
3628
3629     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
3630     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
3631       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3632       cat >> confdefs.h <<EOF
3633 #define ${ac_tr_func} 1
3634 EOF
3635
3636     fi
3637   fi
3638
3639
3640   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3641 echo "configure:3642: checking for __builtin_fabs declaration" >&5
3642   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
3643   echo $ac_n "(cached) $ac_c" 1>&6
3644 else
3645
3646
3647     ac_ext=C
3648 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3649 ac_cpp='$CXXCPP $CPPFLAGS'
3650 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3651 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3652 cross_compiling=$ac_cv_prog_cxx_cross
3653
3654     cat > conftest.$ac_ext <<EOF
3655 #line 3656 "configure"
3656 #include "confdefs.h"
3657 #include <math.h>
3658 int main() {
3659  __builtin_fabs(0);
3660 ; return 0; }
3661 EOF
3662 if { (eval echo configure:3663: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3663   rm -rf conftest*
3664   glibcpp_cv_func___builtin_fabs_use=yes
3665 else
3666   echo "configure: failed program was:" >&5
3667   cat conftest.$ac_ext >&5
3668   rm -rf conftest*
3669   glibcpp_cv_func___builtin_fabs_use=no
3670 fi
3671 rm -f conftest*
3672     ac_ext=c
3673 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3674 ac_cpp='$CPP $CPPFLAGS'
3675 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3676 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3677 cross_compiling=$ac_cv_prog_cc_cross
3678
3679
3680 fi
3681
3682   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
3683   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
3684     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3685 echo "configure:3686: checking for __builtin_fabs linkage" >&5
3686     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
3687   echo $ac_n "(cached) $ac_c" 1>&6
3688 else
3689
3690       cat > conftest.$ac_ext <<EOF
3691 #line 3692 "configure"
3692 #include "confdefs.h"
3693 #include <math.h>
3694 int main() {
3695  __builtin_fabs(0);
3696 ; return 0; }
3697 EOF
3698 if { (eval echo configure:3699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3699   rm -rf conftest*
3700   glibcpp_cv_func___builtin_fabs_link=yes
3701 else
3702   echo "configure: failed program was:" >&5
3703   cat conftest.$ac_ext >&5
3704   rm -rf conftest*
3705   glibcpp_cv_func___builtin_fabs_link=no
3706 fi
3707 rm -f conftest*
3708
3709 fi
3710
3711     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
3712     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
3713       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3714       cat >> confdefs.h <<EOF
3715 #define ${ac_tr_func} 1
3716 EOF
3717
3718     fi
3719   fi
3720
3721
3722   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3723 echo "configure:3724: checking for __builtin_fabsl declaration" >&5
3724   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
3725   echo $ac_n "(cached) $ac_c" 1>&6
3726 else
3727
3728
3729     ac_ext=C
3730 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3731 ac_cpp='$CXXCPP $CPPFLAGS'
3732 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3733 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3734 cross_compiling=$ac_cv_prog_cxx_cross
3735
3736     cat > conftest.$ac_ext <<EOF
3737 #line 3738 "configure"
3738 #include "confdefs.h"
3739 #include <math.h>
3740 int main() {
3741  __builtin_fabsl(0);
3742 ; return 0; }
3743 EOF
3744 if { (eval echo configure:3745: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3745   rm -rf conftest*
3746   glibcpp_cv_func___builtin_fabsl_use=yes
3747 else
3748   echo "configure: failed program was:" >&5
3749   cat conftest.$ac_ext >&5
3750   rm -rf conftest*
3751   glibcpp_cv_func___builtin_fabsl_use=no
3752 fi
3753 rm -f conftest*
3754     ac_ext=c
3755 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3756 ac_cpp='$CPP $CPPFLAGS'
3757 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3758 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3759 cross_compiling=$ac_cv_prog_cc_cross
3760
3761
3762 fi
3763
3764   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
3765   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
3766     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3767 echo "configure:3768: checking for __builtin_fabsl linkage" >&5
3768     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
3769   echo $ac_n "(cached) $ac_c" 1>&6
3770 else
3771
3772       cat > conftest.$ac_ext <<EOF
3773 #line 3774 "configure"
3774 #include "confdefs.h"
3775 #include <math.h>
3776 int main() {
3777  __builtin_fabsl(0);
3778 ; return 0; }
3779 EOF
3780 if { (eval echo configure:3781: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3781   rm -rf conftest*
3782   glibcpp_cv_func___builtin_fabsl_link=yes
3783 else
3784   echo "configure: failed program was:" >&5
3785   cat conftest.$ac_ext >&5
3786   rm -rf conftest*
3787   glibcpp_cv_func___builtin_fabsl_link=no
3788 fi
3789 rm -f conftest*
3790
3791 fi
3792
3793     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
3794     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
3795       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3796       cat >> confdefs.h <<EOF
3797 #define ${ac_tr_func} 1
3798 EOF
3799
3800     fi
3801   fi
3802
3803
3804   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3805 echo "configure:3806: checking for __builtin_labs declaration" >&5
3806   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
3807   echo $ac_n "(cached) $ac_c" 1>&6
3808 else
3809
3810
3811     ac_ext=C
3812 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3813 ac_cpp='$CXXCPP $CPPFLAGS'
3814 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3815 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3816 cross_compiling=$ac_cv_prog_cxx_cross
3817
3818     cat > conftest.$ac_ext <<EOF
3819 #line 3820 "configure"
3820 #include "confdefs.h"
3821 #include <math.h>
3822 int main() {
3823  __builtin_labs(0);
3824 ; return 0; }
3825 EOF
3826 if { (eval echo configure:3827: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3827   rm -rf conftest*
3828   glibcpp_cv_func___builtin_labs_use=yes
3829 else
3830   echo "configure: failed program was:" >&5
3831   cat conftest.$ac_ext >&5
3832   rm -rf conftest*
3833   glibcpp_cv_func___builtin_labs_use=no
3834 fi
3835 rm -f conftest*
3836     ac_ext=c
3837 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3838 ac_cpp='$CPP $CPPFLAGS'
3839 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3840 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3841 cross_compiling=$ac_cv_prog_cc_cross
3842
3843
3844 fi
3845
3846   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
3847   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
3848     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3849 echo "configure:3850: checking for __builtin_labs linkage" >&5
3850     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
3851   echo $ac_n "(cached) $ac_c" 1>&6
3852 else
3853
3854       cat > conftest.$ac_ext <<EOF
3855 #line 3856 "configure"
3856 #include "confdefs.h"
3857 #include <math.h>
3858 int main() {
3859  __builtin_labs(0);
3860 ; return 0; }
3861 EOF
3862 if { (eval echo configure:3863: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3863   rm -rf conftest*
3864   glibcpp_cv_func___builtin_labs_link=yes
3865 else
3866   echo "configure: failed program was:" >&5
3867   cat conftest.$ac_ext >&5
3868   rm -rf conftest*
3869   glibcpp_cv_func___builtin_labs_link=no
3870 fi
3871 rm -f conftest*
3872
3873 fi
3874
3875     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
3876     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
3877       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3878       cat >> confdefs.h <<EOF
3879 #define ${ac_tr_func} 1
3880 EOF
3881
3882     fi
3883   fi
3884
3885
3886
3887   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3888 echo "configure:3889: checking for __builtin_sqrtf declaration" >&5
3889   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
3890   echo $ac_n "(cached) $ac_c" 1>&6
3891 else
3892
3893
3894     ac_ext=C
3895 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3896 ac_cpp='$CXXCPP $CPPFLAGS'
3897 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3898 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3899 cross_compiling=$ac_cv_prog_cxx_cross
3900
3901     cat > conftest.$ac_ext <<EOF
3902 #line 3903 "configure"
3903 #include "confdefs.h"
3904 #include <math.h>
3905 int main() {
3906  __builtin_sqrtf(0);
3907 ; return 0; }
3908 EOF
3909 if { (eval echo configure:3910: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3910   rm -rf conftest*
3911   glibcpp_cv_func___builtin_sqrtf_use=yes
3912 else
3913   echo "configure: failed program was:" >&5
3914   cat conftest.$ac_ext >&5
3915   rm -rf conftest*
3916   glibcpp_cv_func___builtin_sqrtf_use=no
3917 fi
3918 rm -f conftest*
3919     ac_ext=c
3920 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3921 ac_cpp='$CPP $CPPFLAGS'
3922 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3923 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3924 cross_compiling=$ac_cv_prog_cc_cross
3925
3926
3927 fi
3928
3929   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
3930   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
3931     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3932 echo "configure:3933: checking for __builtin_sqrtf linkage" >&5
3933     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
3934   echo $ac_n "(cached) $ac_c" 1>&6
3935 else
3936
3937       cat > conftest.$ac_ext <<EOF
3938 #line 3939 "configure"
3939 #include "confdefs.h"
3940 #include <math.h>
3941 int main() {
3942  __builtin_sqrtf(0);
3943 ; return 0; }
3944 EOF
3945 if { (eval echo configure:3946: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3946   rm -rf conftest*
3947   glibcpp_cv_func___builtin_sqrtf_link=yes
3948 else
3949   echo "configure: failed program was:" >&5
3950   cat conftest.$ac_ext >&5
3951   rm -rf conftest*
3952   glibcpp_cv_func___builtin_sqrtf_link=no
3953 fi
3954 rm -f conftest*
3955
3956 fi
3957
3958     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
3959     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
3960       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3961       cat >> confdefs.h <<EOF
3962 #define ${ac_tr_func} 1
3963 EOF
3964
3965     fi
3966   fi
3967
3968
3969   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
3970 echo "configure:3971: checking for __builtin_fsqrt declaration" >&5
3971   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
3972   echo $ac_n "(cached) $ac_c" 1>&6
3973 else
3974
3975
3976     ac_ext=C
3977 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3978 ac_cpp='$CXXCPP $CPPFLAGS'
3979 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3980 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3981 cross_compiling=$ac_cv_prog_cxx_cross
3982
3983     cat > conftest.$ac_ext <<EOF
3984 #line 3985 "configure"
3985 #include "confdefs.h"
3986 #include <math.h>
3987 int main() {
3988  __builtin_fsqrt(0);
3989 ; return 0; }
3990 EOF
3991 if { (eval echo configure:3992: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3992   rm -rf conftest*
3993   glibcpp_cv_func___builtin_fsqrt_use=yes
3994 else
3995   echo "configure: failed program was:" >&5
3996   cat conftest.$ac_ext >&5
3997   rm -rf conftest*
3998   glibcpp_cv_func___builtin_fsqrt_use=no
3999 fi
4000 rm -f conftest*
4001     ac_ext=c
4002 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4003 ac_cpp='$CPP $CPPFLAGS'
4004 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4005 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4006 cross_compiling=$ac_cv_prog_cc_cross
4007
4008
4009 fi
4010
4011   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
4012   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
4013     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
4014 echo "configure:4015: checking for __builtin_fsqrt linkage" >&5
4015     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
4016   echo $ac_n "(cached) $ac_c" 1>&6
4017 else
4018
4019       cat > conftest.$ac_ext <<EOF
4020 #line 4021 "configure"
4021 #include "confdefs.h"
4022 #include <math.h>
4023 int main() {
4024  __builtin_fsqrt(0);
4025 ; return 0; }
4026 EOF
4027 if { (eval echo configure:4028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4028   rm -rf conftest*
4029   glibcpp_cv_func___builtin_fsqrt_link=yes
4030 else
4031   echo "configure: failed program was:" >&5
4032   cat conftest.$ac_ext >&5
4033   rm -rf conftest*
4034   glibcpp_cv_func___builtin_fsqrt_link=no
4035 fi
4036 rm -f conftest*
4037
4038 fi
4039
4040     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
4041     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
4042       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4043       cat >> confdefs.h <<EOF
4044 #define ${ac_tr_func} 1
4045 EOF
4046
4047     fi
4048   fi
4049
4050
4051   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
4052 echo "configure:4053: checking for __builtin_sqrtl declaration" >&5
4053   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
4054   echo $ac_n "(cached) $ac_c" 1>&6
4055 else
4056
4057
4058     ac_ext=C
4059 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4060 ac_cpp='$CXXCPP $CPPFLAGS'
4061 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4062 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4063 cross_compiling=$ac_cv_prog_cxx_cross
4064
4065     cat > conftest.$ac_ext <<EOF
4066 #line 4067 "configure"
4067 #include "confdefs.h"
4068 #include <math.h>
4069 int main() {
4070  __builtin_sqrtl(0);
4071 ; return 0; }
4072 EOF
4073 if { (eval echo configure:4074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4074   rm -rf conftest*
4075   glibcpp_cv_func___builtin_sqrtl_use=yes
4076 else
4077   echo "configure: failed program was:" >&5
4078   cat conftest.$ac_ext >&5
4079   rm -rf conftest*
4080   glibcpp_cv_func___builtin_sqrtl_use=no
4081 fi
4082 rm -f conftest*
4083     ac_ext=c
4084 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4085 ac_cpp='$CPP $CPPFLAGS'
4086 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4087 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4088 cross_compiling=$ac_cv_prog_cc_cross
4089
4090
4091 fi
4092
4093   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
4094   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
4095     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
4096 echo "configure:4097: checking for __builtin_sqrtl linkage" >&5
4097     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
4098   echo $ac_n "(cached) $ac_c" 1>&6
4099 else
4100
4101       cat > conftest.$ac_ext <<EOF
4102 #line 4103 "configure"
4103 #include "confdefs.h"
4104 #include <math.h>
4105 int main() {
4106  __builtin_sqrtl(0);
4107 ; return 0; }
4108 EOF
4109 if { (eval echo configure:4110: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4110   rm -rf conftest*
4111   glibcpp_cv_func___builtin_sqrtl_link=yes
4112 else
4113   echo "configure: failed program was:" >&5
4114   cat conftest.$ac_ext >&5
4115   rm -rf conftest*
4116   glibcpp_cv_func___builtin_sqrtl_link=no
4117 fi
4118 rm -f conftest*
4119
4120 fi
4121
4122     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
4123     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
4124       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4125       cat >> confdefs.h <<EOF
4126 #define ${ac_tr_func} 1
4127 EOF
4128
4129     fi
4130   fi
4131
4132
4133
4134   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
4135 echo "configure:4136: checking for __builtin_sinf declaration" >&5
4136   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
4137   echo $ac_n "(cached) $ac_c" 1>&6
4138 else
4139
4140
4141     ac_ext=C
4142 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4143 ac_cpp='$CXXCPP $CPPFLAGS'
4144 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4145 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4146 cross_compiling=$ac_cv_prog_cxx_cross
4147
4148     cat > conftest.$ac_ext <<EOF
4149 #line 4150 "configure"
4150 #include "confdefs.h"
4151 #include <math.h>
4152 int main() {
4153  __builtin_sinf(0);
4154 ; return 0; }
4155 EOF
4156 if { (eval echo configure:4157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4157   rm -rf conftest*
4158   glibcpp_cv_func___builtin_sinf_use=yes
4159 else
4160   echo "configure: failed program was:" >&5
4161   cat conftest.$ac_ext >&5
4162   rm -rf conftest*
4163   glibcpp_cv_func___builtin_sinf_use=no
4164 fi
4165 rm -f conftest*
4166     ac_ext=c
4167 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4168 ac_cpp='$CPP $CPPFLAGS'
4169 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4170 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4171 cross_compiling=$ac_cv_prog_cc_cross
4172
4173
4174 fi
4175
4176   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
4177   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
4178     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
4179 echo "configure:4180: checking for __builtin_sinf linkage" >&5
4180     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
4181   echo $ac_n "(cached) $ac_c" 1>&6
4182 else
4183
4184       cat > conftest.$ac_ext <<EOF
4185 #line 4186 "configure"
4186 #include "confdefs.h"
4187 #include <math.h>
4188 int main() {
4189  __builtin_sinf(0);
4190 ; return 0; }
4191 EOF
4192 if { (eval echo configure:4193: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4193   rm -rf conftest*
4194   glibcpp_cv_func___builtin_sinf_link=yes
4195 else
4196   echo "configure: failed program was:" >&5
4197   cat conftest.$ac_ext >&5
4198   rm -rf conftest*
4199   glibcpp_cv_func___builtin_sinf_link=no
4200 fi
4201 rm -f conftest*
4202
4203 fi
4204
4205     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
4206     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
4207       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4208       cat >> confdefs.h <<EOF
4209 #define ${ac_tr_func} 1
4210 EOF
4211
4212     fi
4213   fi
4214
4215
4216   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
4217 echo "configure:4218: checking for __builtin_sin declaration" >&5
4218   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
4219   echo $ac_n "(cached) $ac_c" 1>&6
4220 else
4221
4222
4223     ac_ext=C
4224 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4225 ac_cpp='$CXXCPP $CPPFLAGS'
4226 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4227 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4228 cross_compiling=$ac_cv_prog_cxx_cross
4229
4230     cat > conftest.$ac_ext <<EOF
4231 #line 4232 "configure"
4232 #include "confdefs.h"
4233 #include <math.h>
4234 int main() {
4235  __builtin_sin(0);
4236 ; return 0; }
4237 EOF
4238 if { (eval echo configure:4239: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4239   rm -rf conftest*
4240   glibcpp_cv_func___builtin_sin_use=yes
4241 else
4242   echo "configure: failed program was:" >&5
4243   cat conftest.$ac_ext >&5
4244   rm -rf conftest*
4245   glibcpp_cv_func___builtin_sin_use=no
4246 fi
4247 rm -f conftest*
4248     ac_ext=c
4249 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4250 ac_cpp='$CPP $CPPFLAGS'
4251 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4252 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4253 cross_compiling=$ac_cv_prog_cc_cross
4254
4255
4256 fi
4257
4258   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
4259   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
4260     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
4261 echo "configure:4262: checking for __builtin_sin linkage" >&5
4262     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
4263   echo $ac_n "(cached) $ac_c" 1>&6
4264 else
4265
4266       cat > conftest.$ac_ext <<EOF
4267 #line 4268 "configure"
4268 #include "confdefs.h"
4269 #include <math.h>
4270 int main() {
4271  __builtin_sin(0);
4272 ; return 0; }
4273 EOF
4274 if { (eval echo configure:4275: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4275   rm -rf conftest*
4276   glibcpp_cv_func___builtin_sin_link=yes
4277 else
4278   echo "configure: failed program was:" >&5
4279   cat conftest.$ac_ext >&5
4280   rm -rf conftest*
4281   glibcpp_cv_func___builtin_sin_link=no
4282 fi
4283 rm -f conftest*
4284
4285 fi
4286
4287     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
4288     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
4289       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4290       cat >> confdefs.h <<EOF
4291 #define ${ac_tr_func} 1
4292 EOF
4293
4294     fi
4295   fi
4296
4297
4298   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
4299 echo "configure:4300: checking for __builtin_sinl declaration" >&5
4300   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
4301   echo $ac_n "(cached) $ac_c" 1>&6
4302 else
4303
4304
4305     ac_ext=C
4306 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4307 ac_cpp='$CXXCPP $CPPFLAGS'
4308 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4309 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4310 cross_compiling=$ac_cv_prog_cxx_cross
4311
4312     cat > conftest.$ac_ext <<EOF
4313 #line 4314 "configure"
4314 #include "confdefs.h"
4315 #include <math.h>
4316 int main() {
4317  __builtin_sinl(0);
4318 ; return 0; }
4319 EOF
4320 if { (eval echo configure:4321: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4321   rm -rf conftest*
4322   glibcpp_cv_func___builtin_sinl_use=yes
4323 else
4324   echo "configure: failed program was:" >&5
4325   cat conftest.$ac_ext >&5
4326   rm -rf conftest*
4327   glibcpp_cv_func___builtin_sinl_use=no
4328 fi
4329 rm -f conftest*
4330     ac_ext=c
4331 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4332 ac_cpp='$CPP $CPPFLAGS'
4333 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4334 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4335 cross_compiling=$ac_cv_prog_cc_cross
4336
4337
4338 fi
4339
4340   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
4341   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
4342     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
4343 echo "configure:4344: checking for __builtin_sinl linkage" >&5
4344     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
4345   echo $ac_n "(cached) $ac_c" 1>&6
4346 else
4347
4348       cat > conftest.$ac_ext <<EOF
4349 #line 4350 "configure"
4350 #include "confdefs.h"
4351 #include <math.h>
4352 int main() {
4353  __builtin_sinl(0);
4354 ; return 0; }
4355 EOF
4356 if { (eval echo configure:4357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4357   rm -rf conftest*
4358   glibcpp_cv_func___builtin_sinl_link=yes
4359 else
4360   echo "configure: failed program was:" >&5
4361   cat conftest.$ac_ext >&5
4362   rm -rf conftest*
4363   glibcpp_cv_func___builtin_sinl_link=no
4364 fi
4365 rm -f conftest*
4366
4367 fi
4368
4369     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
4370     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
4371       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4372       cat >> confdefs.h <<EOF
4373 #define ${ac_tr_func} 1
4374 EOF
4375
4376     fi
4377   fi
4378
4379
4380
4381   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
4382 echo "configure:4383: checking for __builtin_cosf declaration" >&5
4383   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
4384   echo $ac_n "(cached) $ac_c" 1>&6
4385 else
4386
4387
4388     ac_ext=C
4389 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4390 ac_cpp='$CXXCPP $CPPFLAGS'
4391 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4392 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4393 cross_compiling=$ac_cv_prog_cxx_cross
4394
4395     cat > conftest.$ac_ext <<EOF
4396 #line 4397 "configure"
4397 #include "confdefs.h"
4398 #include <math.h>
4399 int main() {
4400  __builtin_cosf(0);
4401 ; return 0; }
4402 EOF
4403 if { (eval echo configure:4404: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4404   rm -rf conftest*
4405   glibcpp_cv_func___builtin_cosf_use=yes
4406 else
4407   echo "configure: failed program was:" >&5
4408   cat conftest.$ac_ext >&5
4409   rm -rf conftest*
4410   glibcpp_cv_func___builtin_cosf_use=no
4411 fi
4412 rm -f conftest*
4413     ac_ext=c
4414 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4415 ac_cpp='$CPP $CPPFLAGS'
4416 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4417 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4418 cross_compiling=$ac_cv_prog_cc_cross
4419
4420
4421 fi
4422
4423   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
4424   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
4425     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
4426 echo "configure:4427: checking for __builtin_cosf linkage" >&5
4427     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
4428   echo $ac_n "(cached) $ac_c" 1>&6
4429 else
4430
4431       cat > conftest.$ac_ext <<EOF
4432 #line 4433 "configure"
4433 #include "confdefs.h"
4434 #include <math.h>
4435 int main() {
4436  __builtin_cosf(0);
4437 ; return 0; }
4438 EOF
4439 if { (eval echo configure:4440: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4440   rm -rf conftest*
4441   glibcpp_cv_func___builtin_cosf_link=yes
4442 else
4443   echo "configure: failed program was:" >&5
4444   cat conftest.$ac_ext >&5
4445   rm -rf conftest*
4446   glibcpp_cv_func___builtin_cosf_link=no
4447 fi
4448 rm -f conftest*
4449
4450 fi
4451
4452     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
4453     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
4454       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4455       cat >> confdefs.h <<EOF
4456 #define ${ac_tr_func} 1
4457 EOF
4458
4459     fi
4460   fi
4461
4462
4463   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
4464 echo "configure:4465: checking for __builtin_cos declaration" >&5
4465   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
4466   echo $ac_n "(cached) $ac_c" 1>&6
4467 else
4468
4469
4470     ac_ext=C
4471 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4472 ac_cpp='$CXXCPP $CPPFLAGS'
4473 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4474 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4475 cross_compiling=$ac_cv_prog_cxx_cross
4476
4477     cat > conftest.$ac_ext <<EOF
4478 #line 4479 "configure"
4479 #include "confdefs.h"
4480 #include <math.h>
4481 int main() {
4482  __builtin_cos(0);
4483 ; return 0; }
4484 EOF
4485 if { (eval echo configure:4486: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4486   rm -rf conftest*
4487   glibcpp_cv_func___builtin_cos_use=yes
4488 else
4489   echo "configure: failed program was:" >&5
4490   cat conftest.$ac_ext >&5
4491   rm -rf conftest*
4492   glibcpp_cv_func___builtin_cos_use=no
4493 fi
4494 rm -f conftest*
4495     ac_ext=c
4496 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4497 ac_cpp='$CPP $CPPFLAGS'
4498 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4499 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4500 cross_compiling=$ac_cv_prog_cc_cross
4501
4502
4503 fi
4504
4505   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
4506   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
4507     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
4508 echo "configure:4509: checking for __builtin_cos linkage" >&5
4509     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
4510   echo $ac_n "(cached) $ac_c" 1>&6
4511 else
4512
4513       cat > conftest.$ac_ext <<EOF
4514 #line 4515 "configure"
4515 #include "confdefs.h"
4516 #include <math.h>
4517 int main() {
4518  __builtin_cos(0);
4519 ; return 0; }
4520 EOF
4521 if { (eval echo configure:4522: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4522   rm -rf conftest*
4523   glibcpp_cv_func___builtin_cos_link=yes
4524 else
4525   echo "configure: failed program was:" >&5
4526   cat conftest.$ac_ext >&5
4527   rm -rf conftest*
4528   glibcpp_cv_func___builtin_cos_link=no
4529 fi
4530 rm -f conftest*
4531
4532 fi
4533
4534     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
4535     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
4536       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4537       cat >> confdefs.h <<EOF
4538 #define ${ac_tr_func} 1
4539 EOF
4540
4541     fi
4542   fi
4543
4544
4545   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
4546 echo "configure:4547: checking for __builtin_cosl declaration" >&5
4547   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
4548   echo $ac_n "(cached) $ac_c" 1>&6
4549 else
4550
4551
4552     ac_ext=C
4553 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4554 ac_cpp='$CXXCPP $CPPFLAGS'
4555 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4556 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4557 cross_compiling=$ac_cv_prog_cxx_cross
4558
4559     cat > conftest.$ac_ext <<EOF
4560 #line 4561 "configure"
4561 #include "confdefs.h"
4562 #include <math.h>
4563 int main() {
4564  __builtin_cosl(0);
4565 ; return 0; }
4566 EOF
4567 if { (eval echo configure:4568: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4568   rm -rf conftest*
4569   glibcpp_cv_func___builtin_cosl_use=yes
4570 else
4571   echo "configure: failed program was:" >&5
4572   cat conftest.$ac_ext >&5
4573   rm -rf conftest*
4574   glibcpp_cv_func___builtin_cosl_use=no
4575 fi
4576 rm -f conftest*
4577     ac_ext=c
4578 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4579 ac_cpp='$CPP $CPPFLAGS'
4580 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4581 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4582 cross_compiling=$ac_cv_prog_cc_cross
4583
4584
4585 fi
4586
4587   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
4588   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
4589     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
4590 echo "configure:4591: checking for __builtin_cosl linkage" >&5
4591     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
4592   echo $ac_n "(cached) $ac_c" 1>&6
4593 else
4594
4595       cat > conftest.$ac_ext <<EOF
4596 #line 4597 "configure"
4597 #include "confdefs.h"
4598 #include <math.h>
4599 int main() {
4600  __builtin_cosl(0);
4601 ; return 0; }
4602 EOF
4603 if { (eval echo configure:4604: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4604   rm -rf conftest*
4605   glibcpp_cv_func___builtin_cosl_link=yes
4606 else
4607   echo "configure: failed program was:" >&5
4608   cat conftest.$ac_ext >&5
4609   rm -rf conftest*
4610   glibcpp_cv_func___builtin_cosl_link=no
4611 fi
4612 rm -f conftest*
4613
4614 fi
4615
4616     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
4617     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
4618       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4619       cat >> confdefs.h <<EOF
4620 #define ${ac_tr_func} 1
4621 EOF
4622
4623     fi
4624   fi
4625
4626
4627               dummyvar=no
4628   if test x$dummyvar = x"yes"; then
4629     cat >> confdefs.h <<\EOF
4630 #define HAVE___BUILTIN_ABS 1
4631 EOF
4632
4633     cat >> confdefs.h <<\EOF
4634 #define HAVE___BUILTIN_LABS 1
4635 EOF
4636
4637     cat >> confdefs.h <<\EOF
4638 #define HAVE___BUILTIN_COS 1
4639 EOF
4640
4641     cat >> confdefs.h <<\EOF
4642 #define HAVE___BUILTIN_COSF 1
4643 EOF
4644
4645     cat >> confdefs.h <<\EOF
4646 #define HAVE___BUILTIN_COSL 1
4647 EOF
4648
4649     cat >> confdefs.h <<\EOF
4650 #define HAVE___BUILTIN_FABS 1
4651 EOF
4652
4653     cat >> confdefs.h <<\EOF
4654 #define HAVE___BUILTIN_FABSF 1
4655 EOF
4656
4657     cat >> confdefs.h <<\EOF
4658 #define HAVE___BUILTIN_FABSL 1
4659 EOF
4660
4661     cat >> confdefs.h <<\EOF
4662 #define HAVE___BUILTIN_SIN 1
4663 EOF
4664
4665     cat >> confdefs.h <<\EOF
4666 #define HAVE___BUILTIN_SINF 1
4667 EOF
4668
4669     cat >> confdefs.h <<\EOF
4670 #define HAVE___BUILTIN_SINL 1
4671 EOF
4672
4673     cat >> confdefs.h <<\EOF
4674 #define HAVE___BUILTIN_FSQRT 1
4675 EOF
4676
4677     cat >> confdefs.h <<\EOF
4678 #define HAVE___BUILTIN_SQRTF 1
4679 EOF
4680
4681     cat >> confdefs.h <<\EOF
4682 #define HAVE___BUILTIN_SQRTL 1
4683 EOF
4684
4685   fi
4686
4687
4688   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4689   ac_save_CXXFLAGS="$CXXFLAGS"
4690   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4691
4692     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4693 echo "configure:4694: checking for sin in -lm" >&5
4694 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4695 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4696   echo $ac_n "(cached) $ac_c" 1>&6
4697 else
4698   ac_save_LIBS="$LIBS"
4699 LIBS="-lm  $LIBS"
4700 cat > conftest.$ac_ext <<EOF
4701 #line 4702 "configure"
4702 #include "confdefs.h"
4703 /* Override any gcc2 internal prototype to avoid an error.  */
4704 /* We use char because int might match the return type of a gcc2
4705     builtin and then its argument prototype would still apply.  */
4706 char sin();
4707
4708 int main() {
4709 sin()
4710 ; return 0; }
4711 EOF
4712 if { (eval echo configure:4713: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4713   rm -rf conftest*
4714   eval "ac_cv_lib_$ac_lib_var=yes"
4715 else
4716   echo "configure: failed program was:" >&5
4717   cat conftest.$ac_ext >&5
4718   rm -rf conftest*
4719   eval "ac_cv_lib_$ac_lib_var=no"
4720 fi
4721 rm -f conftest*
4722 LIBS="$ac_save_LIBS"
4723
4724 fi
4725 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4726   echo "$ac_t""yes" 1>&6
4727   libm="-lm"
4728 else
4729   echo "$ac_t""no" 1>&6
4730 fi
4731
4732   ac_save_LIBS="$LIBS"
4733   LIBS="$LIBS $libm"
4734
4735
4736   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4737 echo "configure:4738: checking for isinf declaration" >&5
4738   if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
4739   echo $ac_n "(cached) $ac_c" 1>&6
4740 else
4741
4742
4743     ac_ext=C
4744 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4745 ac_cpp='$CXXCPP $CPPFLAGS'
4746 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4747 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4748 cross_compiling=$ac_cv_prog_cxx_cross
4749
4750     cat > conftest.$ac_ext <<EOF
4751 #line 4752 "configure"
4752 #include "confdefs.h"
4753 #include <math.h>
4754 int main() {
4755  isinf(0);
4756 ; return 0; }
4757 EOF
4758 if { (eval echo configure:4759: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4759   rm -rf conftest*
4760   glibcpp_cv_func_isinf_use=yes
4761 else
4762   echo "configure: failed program was:" >&5
4763   cat conftest.$ac_ext >&5
4764   rm -rf conftest*
4765   glibcpp_cv_func_isinf_use=no
4766 fi
4767 rm -f conftest*
4768     ac_ext=c
4769 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4770 ac_cpp='$CPP $CPPFLAGS'
4771 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4772 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4773 cross_compiling=$ac_cv_prog_cc_cross
4774
4775
4776 fi
4777
4778   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
4779   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
4780     for ac_func in isinf
4781 do
4782 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4783 echo "configure:4784: checking for $ac_func" >&5
4784 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4785   echo $ac_n "(cached) $ac_c" 1>&6
4786 else
4787   cat > conftest.$ac_ext <<EOF
4788 #line 4789 "configure"
4789 #include "confdefs.h"
4790 /* System header to define __stub macros and hopefully few prototypes,
4791     which can conflict with char $ac_func(); below.  */
4792 #include <assert.h>
4793 /* Override any gcc2 internal prototype to avoid an error.  */
4794 /* We use char because int might match the return type of a gcc2
4795     builtin and then its argument prototype would still apply.  */
4796 char $ac_func();
4797
4798 int main() {
4799
4800 /* The GNU C library defines this for functions which it implements
4801     to always fail with ENOSYS.  Some functions are actually named
4802     something starting with __ and the normal name is an alias.  */
4803 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4804 choke me
4805 #else
4806 $ac_func();
4807 #endif
4808
4809 ; return 0; }
4810 EOF
4811 if { (eval echo configure:4812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4812   rm -rf conftest*
4813   eval "ac_cv_func_$ac_func=yes"
4814 else
4815   echo "configure: failed program was:" >&5
4816   cat conftest.$ac_ext >&5
4817   rm -rf conftest*
4818   eval "ac_cv_func_$ac_func=no"
4819 fi
4820 rm -f conftest*
4821 fi
4822
4823 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4824   echo "$ac_t""yes" 1>&6
4825     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4826   cat >> confdefs.h <<EOF
4827 #define $ac_tr_func 1
4828 EOF
4829
4830 else
4831   echo "$ac_t""no" 1>&6
4832 fi
4833 done
4834
4835   fi
4836
4837
4838   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4839 echo "configure:4840: checking for isnan declaration" >&5
4840   if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
4841   echo $ac_n "(cached) $ac_c" 1>&6
4842 else
4843
4844
4845     ac_ext=C
4846 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4847 ac_cpp='$CXXCPP $CPPFLAGS'
4848 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4849 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4850 cross_compiling=$ac_cv_prog_cxx_cross
4851
4852     cat > conftest.$ac_ext <<EOF
4853 #line 4854 "configure"
4854 #include "confdefs.h"
4855 #include <math.h>
4856 int main() {
4857  isnan(0);
4858 ; return 0; }
4859 EOF
4860 if { (eval echo configure:4861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4861   rm -rf conftest*
4862   glibcpp_cv_func_isnan_use=yes
4863 else
4864   echo "configure: failed program was:" >&5
4865   cat conftest.$ac_ext >&5
4866   rm -rf conftest*
4867   glibcpp_cv_func_isnan_use=no
4868 fi
4869 rm -f conftest*
4870     ac_ext=c
4871 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4872 ac_cpp='$CPP $CPPFLAGS'
4873 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4874 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4875 cross_compiling=$ac_cv_prog_cc_cross
4876
4877
4878 fi
4879
4880   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
4881   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
4882     for ac_func in isnan
4883 do
4884 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4885 echo "configure:4886: checking for $ac_func" >&5
4886 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4887   echo $ac_n "(cached) $ac_c" 1>&6
4888 else
4889   cat > conftest.$ac_ext <<EOF
4890 #line 4891 "configure"
4891 #include "confdefs.h"
4892 /* System header to define __stub macros and hopefully few prototypes,
4893     which can conflict with char $ac_func(); below.  */
4894 #include <assert.h>
4895 /* Override any gcc2 internal prototype to avoid an error.  */
4896 /* We use char because int might match the return type of a gcc2
4897     builtin and then its argument prototype would still apply.  */
4898 char $ac_func();
4899
4900 int main() {
4901
4902 /* The GNU C library defines this for functions which it implements
4903     to always fail with ENOSYS.  Some functions are actually named
4904     something starting with __ and the normal name is an alias.  */
4905 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4906 choke me
4907 #else
4908 $ac_func();
4909 #endif
4910
4911 ; return 0; }
4912 EOF
4913 if { (eval echo configure:4914: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4914   rm -rf conftest*
4915   eval "ac_cv_func_$ac_func=yes"
4916 else
4917   echo "configure: failed program was:" >&5
4918   cat conftest.$ac_ext >&5
4919   rm -rf conftest*
4920   eval "ac_cv_func_$ac_func=no"
4921 fi
4922 rm -f conftest*
4923 fi
4924
4925 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4926   echo "$ac_t""yes" 1>&6
4927     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4928   cat >> confdefs.h <<EOF
4929 #define $ac_tr_func 1
4930 EOF
4931
4932 else
4933   echo "$ac_t""no" 1>&6
4934 fi
4935 done
4936
4937   fi
4938
4939
4940   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
4941 echo "configure:4942: checking for finite declaration" >&5
4942   if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
4943   echo $ac_n "(cached) $ac_c" 1>&6
4944 else
4945
4946
4947     ac_ext=C
4948 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4949 ac_cpp='$CXXCPP $CPPFLAGS'
4950 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4951 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4952 cross_compiling=$ac_cv_prog_cxx_cross
4953
4954     cat > conftest.$ac_ext <<EOF
4955 #line 4956 "configure"
4956 #include "confdefs.h"
4957 #include <math.h>
4958 int main() {
4959  finite(0);
4960 ; return 0; }
4961 EOF
4962 if { (eval echo configure:4963: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4963   rm -rf conftest*
4964   glibcpp_cv_func_finite_use=yes
4965 else
4966   echo "configure: failed program was:" >&5
4967   cat conftest.$ac_ext >&5
4968   rm -rf conftest*
4969   glibcpp_cv_func_finite_use=no
4970 fi
4971 rm -f conftest*
4972     ac_ext=c
4973 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4974 ac_cpp='$CPP $CPPFLAGS'
4975 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4976 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4977 cross_compiling=$ac_cv_prog_cc_cross
4978
4979
4980 fi
4981
4982   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
4983   if test x$glibcpp_cv_func_finite_use = x"yes"; then
4984     for ac_func in finite
4985 do
4986 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4987 echo "configure:4988: checking for $ac_func" >&5
4988 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4989   echo $ac_n "(cached) $ac_c" 1>&6
4990 else
4991   cat > conftest.$ac_ext <<EOF
4992 #line 4993 "configure"
4993 #include "confdefs.h"
4994 /* System header to define __stub macros and hopefully few prototypes,
4995     which can conflict with char $ac_func(); below.  */
4996 #include <assert.h>
4997 /* Override any gcc2 internal prototype to avoid an error.  */
4998 /* We use char because int might match the return type of a gcc2
4999     builtin and then its argument prototype would still apply.  */
5000 char $ac_func();
5001
5002 int main() {
5003
5004 /* The GNU C library defines this for functions which it implements
5005     to always fail with ENOSYS.  Some functions are actually named
5006     something starting with __ and the normal name is an alias.  */
5007 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5008 choke me
5009 #else
5010 $ac_func();
5011 #endif
5012
5013 ; return 0; }
5014 EOF
5015 if { (eval echo configure:5016: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5016   rm -rf conftest*
5017   eval "ac_cv_func_$ac_func=yes"
5018 else
5019   echo "configure: failed program was:" >&5
5020   cat conftest.$ac_ext >&5
5021   rm -rf conftest*
5022   eval "ac_cv_func_$ac_func=no"
5023 fi
5024 rm -f conftest*
5025 fi
5026
5027 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5028   echo "$ac_t""yes" 1>&6
5029     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5030   cat >> confdefs.h <<EOF
5031 #define $ac_tr_func 1
5032 EOF
5033
5034 else
5035   echo "$ac_t""no" 1>&6
5036 fi
5037 done
5038
5039   fi
5040
5041
5042   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
5043 echo "configure:5044: checking for copysign declaration" >&5
5044   if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
5045   echo $ac_n "(cached) $ac_c" 1>&6
5046 else
5047
5048
5049     ac_ext=C
5050 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5051 ac_cpp='$CXXCPP $CPPFLAGS'
5052 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5053 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5054 cross_compiling=$ac_cv_prog_cxx_cross
5055
5056     cat > conftest.$ac_ext <<EOF
5057 #line 5058 "configure"
5058 #include "confdefs.h"
5059 #include <math.h>
5060 int main() {
5061  copysign(0, 0);
5062 ; return 0; }
5063 EOF
5064 if { (eval echo configure:5065: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5065   rm -rf conftest*
5066   glibcpp_cv_func_copysign_use=yes
5067 else
5068   echo "configure: failed program was:" >&5
5069   cat conftest.$ac_ext >&5
5070   rm -rf conftest*
5071   glibcpp_cv_func_copysign_use=no
5072 fi
5073 rm -f conftest*
5074     ac_ext=c
5075 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5076 ac_cpp='$CPP $CPPFLAGS'
5077 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5078 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5079 cross_compiling=$ac_cv_prog_cc_cross
5080
5081
5082 fi
5083
5084   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
5085   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
5086     for ac_func in copysign
5087 do
5088 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5089 echo "configure:5090: checking for $ac_func" >&5
5090 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5091   echo $ac_n "(cached) $ac_c" 1>&6
5092 else
5093   cat > conftest.$ac_ext <<EOF
5094 #line 5095 "configure"
5095 #include "confdefs.h"
5096 /* System header to define __stub macros and hopefully few prototypes,
5097     which can conflict with char $ac_func(); below.  */
5098 #include <assert.h>
5099 /* Override any gcc2 internal prototype to avoid an error.  */
5100 /* We use char because int might match the return type of a gcc2
5101     builtin and then its argument prototype would still apply.  */
5102 char $ac_func();
5103
5104 int main() {
5105
5106 /* The GNU C library defines this for functions which it implements
5107     to always fail with ENOSYS.  Some functions are actually named
5108     something starting with __ and the normal name is an alias.  */
5109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5110 choke me
5111 #else
5112 $ac_func();
5113 #endif
5114
5115 ; return 0; }
5116 EOF
5117 if { (eval echo configure:5118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5118   rm -rf conftest*
5119   eval "ac_cv_func_$ac_func=yes"
5120 else
5121   echo "configure: failed program was:" >&5
5122   cat conftest.$ac_ext >&5
5123   rm -rf conftest*
5124   eval "ac_cv_func_$ac_func=no"
5125 fi
5126 rm -f conftest*
5127 fi
5128
5129 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5130   echo "$ac_t""yes" 1>&6
5131     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5132   cat >> confdefs.h <<EOF
5133 #define $ac_tr_func 1
5134 EOF
5135
5136 else
5137   echo "$ac_t""no" 1>&6
5138 fi
5139 done
5140
5141   fi
5142
5143
5144   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
5145 echo "configure:5146: checking for sincos declaration" >&5
5146   if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
5147   echo $ac_n "(cached) $ac_c" 1>&6
5148 else
5149
5150
5151     ac_ext=C
5152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5153 ac_cpp='$CXXCPP $CPPFLAGS'
5154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5156 cross_compiling=$ac_cv_prog_cxx_cross
5157
5158     cat > conftest.$ac_ext <<EOF
5159 #line 5160 "configure"
5160 #include "confdefs.h"
5161 #include <math.h>
5162 int main() {
5163  sincos(0, 0, 0);
5164 ; return 0; }
5165 EOF
5166 if { (eval echo configure:5167: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5167   rm -rf conftest*
5168   glibcpp_cv_func_sincos_use=yes
5169 else
5170   echo "configure: failed program was:" >&5
5171   cat conftest.$ac_ext >&5
5172   rm -rf conftest*
5173   glibcpp_cv_func_sincos_use=no
5174 fi
5175 rm -f conftest*
5176     ac_ext=c
5177 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5178 ac_cpp='$CPP $CPPFLAGS'
5179 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5180 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5181 cross_compiling=$ac_cv_prog_cc_cross
5182
5183
5184 fi
5185
5186   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
5187   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
5188     for ac_func in sincos
5189 do
5190 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5191 echo "configure:5192: checking for $ac_func" >&5
5192 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5193   echo $ac_n "(cached) $ac_c" 1>&6
5194 else
5195   cat > conftest.$ac_ext <<EOF
5196 #line 5197 "configure"
5197 #include "confdefs.h"
5198 /* System header to define __stub macros and hopefully few prototypes,
5199     which can conflict with char $ac_func(); below.  */
5200 #include <assert.h>
5201 /* Override any gcc2 internal prototype to avoid an error.  */
5202 /* We use char because int might match the return type of a gcc2
5203     builtin and then its argument prototype would still apply.  */
5204 char $ac_func();
5205
5206 int main() {
5207
5208 /* The GNU C library defines this for functions which it implements
5209     to always fail with ENOSYS.  Some functions are actually named
5210     something starting with __ and the normal name is an alias.  */
5211 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5212 choke me
5213 #else
5214 $ac_func();
5215 #endif
5216
5217 ; return 0; }
5218 EOF
5219 if { (eval echo configure:5220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5220   rm -rf conftest*
5221   eval "ac_cv_func_$ac_func=yes"
5222 else
5223   echo "configure: failed program was:" >&5
5224   cat conftest.$ac_ext >&5
5225   rm -rf conftest*
5226   eval "ac_cv_func_$ac_func=no"
5227 fi
5228 rm -f conftest*
5229 fi
5230
5231 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5232   echo "$ac_t""yes" 1>&6
5233     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5234   cat >> confdefs.h <<EOF
5235 #define $ac_tr_func 1
5236 EOF
5237
5238 else
5239   echo "$ac_t""no" 1>&6
5240 fi
5241 done
5242
5243   fi
5244
5245
5246   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
5247 echo "configure:5248: checking for fpclass declaration" >&5
5248   if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
5249   echo $ac_n "(cached) $ac_c" 1>&6
5250 else
5251
5252
5253     ac_ext=C
5254 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5255 ac_cpp='$CXXCPP $CPPFLAGS'
5256 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5257 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5258 cross_compiling=$ac_cv_prog_cxx_cross
5259
5260     cat > conftest.$ac_ext <<EOF
5261 #line 5262 "configure"
5262 #include "confdefs.h"
5263 #include <math.h>
5264 int main() {
5265  fpclass(0);
5266 ; return 0; }
5267 EOF
5268 if { (eval echo configure:5269: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5269   rm -rf conftest*
5270   glibcpp_cv_func_fpclass_use=yes
5271 else
5272   echo "configure: failed program was:" >&5
5273   cat conftest.$ac_ext >&5
5274   rm -rf conftest*
5275   glibcpp_cv_func_fpclass_use=no
5276 fi
5277 rm -f conftest*
5278     ac_ext=c
5279 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5280 ac_cpp='$CPP $CPPFLAGS'
5281 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5282 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5283 cross_compiling=$ac_cv_prog_cc_cross
5284
5285
5286 fi
5287
5288   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
5289   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
5290     for ac_func in fpclass
5291 do
5292 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5293 echo "configure:5294: checking for $ac_func" >&5
5294 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5295   echo $ac_n "(cached) $ac_c" 1>&6
5296 else
5297   cat > conftest.$ac_ext <<EOF
5298 #line 5299 "configure"
5299 #include "confdefs.h"
5300 /* System header to define __stub macros and hopefully few prototypes,
5301     which can conflict with char $ac_func(); below.  */
5302 #include <assert.h>
5303 /* Override any gcc2 internal prototype to avoid an error.  */
5304 /* We use char because int might match the return type of a gcc2
5305     builtin and then its argument prototype would still apply.  */
5306 char $ac_func();
5307
5308 int main() {
5309
5310 /* The GNU C library defines this for functions which it implements
5311     to always fail with ENOSYS.  Some functions are actually named
5312     something starting with __ and the normal name is an alias.  */
5313 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5314 choke me
5315 #else
5316 $ac_func();
5317 #endif
5318
5319 ; return 0; }
5320 EOF
5321 if { (eval echo configure:5322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5322   rm -rf conftest*
5323   eval "ac_cv_func_$ac_func=yes"
5324 else
5325   echo "configure: failed program was:" >&5
5326   cat conftest.$ac_ext >&5
5327   rm -rf conftest*
5328   eval "ac_cv_func_$ac_func=no"
5329 fi
5330 rm -f conftest*
5331 fi
5332
5333 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5334   echo "$ac_t""yes" 1>&6
5335     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5336   cat >> confdefs.h <<EOF
5337 #define $ac_tr_func 1
5338 EOF
5339
5340 else
5341   echo "$ac_t""no" 1>&6
5342 fi
5343 done
5344
5345   fi
5346
5347
5348   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
5349 echo "configure:5350: checking for qfpclass declaration" >&5
5350   if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
5351   echo $ac_n "(cached) $ac_c" 1>&6
5352 else
5353
5354
5355     ac_ext=C
5356 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5357 ac_cpp='$CXXCPP $CPPFLAGS'
5358 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5359 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5360 cross_compiling=$ac_cv_prog_cxx_cross
5361
5362     cat > conftest.$ac_ext <<EOF
5363 #line 5364 "configure"
5364 #include "confdefs.h"
5365 #include <math.h>
5366 int main() {
5367  qfpclass(0);
5368 ; return 0; }
5369 EOF
5370 if { (eval echo configure:5371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5371   rm -rf conftest*
5372   glibcpp_cv_func_qfpclass_use=yes
5373 else
5374   echo "configure: failed program was:" >&5
5375   cat conftest.$ac_ext >&5
5376   rm -rf conftest*
5377   glibcpp_cv_func_qfpclass_use=no
5378 fi
5379 rm -f conftest*
5380     ac_ext=c
5381 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5382 ac_cpp='$CPP $CPPFLAGS'
5383 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5384 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5385 cross_compiling=$ac_cv_prog_cc_cross
5386
5387
5388 fi
5389
5390   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
5391   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
5392     for ac_func in qfpclass
5393 do
5394 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5395 echo "configure:5396: checking for $ac_func" >&5
5396 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5397   echo $ac_n "(cached) $ac_c" 1>&6
5398 else
5399   cat > conftest.$ac_ext <<EOF
5400 #line 5401 "configure"
5401 #include "confdefs.h"
5402 /* System header to define __stub macros and hopefully few prototypes,
5403     which can conflict with char $ac_func(); below.  */
5404 #include <assert.h>
5405 /* Override any gcc2 internal prototype to avoid an error.  */
5406 /* We use char because int might match the return type of a gcc2
5407     builtin and then its argument prototype would still apply.  */
5408 char $ac_func();
5409
5410 int main() {
5411
5412 /* The GNU C library defines this for functions which it implements
5413     to always fail with ENOSYS.  Some functions are actually named
5414     something starting with __ and the normal name is an alias.  */
5415 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5416 choke me
5417 #else
5418 $ac_func();
5419 #endif
5420
5421 ; return 0; }
5422 EOF
5423 if { (eval echo configure:5424: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5424   rm -rf conftest*
5425   eval "ac_cv_func_$ac_func=yes"
5426 else
5427   echo "configure: failed program was:" >&5
5428   cat conftest.$ac_ext >&5
5429   rm -rf conftest*
5430   eval "ac_cv_func_$ac_func=no"
5431 fi
5432 rm -f conftest*
5433 fi
5434
5435 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5436   echo "$ac_t""yes" 1>&6
5437     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5438   cat >> confdefs.h <<EOF
5439 #define $ac_tr_func 1
5440 EOF
5441
5442 else
5443   echo "$ac_t""no" 1>&6
5444 fi
5445 done
5446
5447   fi
5448
5449
5450
5451   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5452 echo "configure:5453: checking for isnanf declaration" >&5
5453   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
5454   echo $ac_n "(cached) $ac_c" 1>&6
5455 else
5456
5457
5458     ac_ext=C
5459 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5460 ac_cpp='$CXXCPP $CPPFLAGS'
5461 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5462 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5463 cross_compiling=$ac_cv_prog_cxx_cross
5464
5465     cat > conftest.$ac_ext <<EOF
5466 #line 5467 "configure"
5467 #include "confdefs.h"
5468 #include <math.h>
5469 int main() {
5470  isnanf(0);
5471 ; return 0; }
5472 EOF
5473 if { (eval echo configure:5474: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5474   rm -rf conftest*
5475   glibcpp_cv_func_isnanf_use=yes
5476 else
5477   echo "configure: failed program was:" >&5
5478   cat conftest.$ac_ext >&5
5479   rm -rf conftest*
5480   glibcpp_cv_func_isnanf_use=no
5481 fi
5482 rm -f conftest*
5483     ac_ext=c
5484 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5485 ac_cpp='$CPP $CPPFLAGS'
5486 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5487 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5488 cross_compiling=$ac_cv_prog_cc_cross
5489
5490
5491 fi
5492
5493   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
5494   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
5495     for ac_func in isnanf
5496 do
5497 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5498 echo "configure:5499: checking for $ac_func" >&5
5499 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5500   echo $ac_n "(cached) $ac_c" 1>&6
5501 else
5502   cat > conftest.$ac_ext <<EOF
5503 #line 5504 "configure"
5504 #include "confdefs.h"
5505 /* System header to define __stub macros and hopefully few prototypes,
5506     which can conflict with char $ac_func(); below.  */
5507 #include <assert.h>
5508 /* Override any gcc2 internal prototype to avoid an error.  */
5509 /* We use char because int might match the return type of a gcc2
5510     builtin and then its argument prototype would still apply.  */
5511 char $ac_func();
5512
5513 int main() {
5514
5515 /* The GNU C library defines this for functions which it implements
5516     to always fail with ENOSYS.  Some functions are actually named
5517     something starting with __ and the normal name is an alias.  */
5518 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5519 choke me
5520 #else
5521 $ac_func();
5522 #endif
5523
5524 ; return 0; }
5525 EOF
5526 if { (eval echo configure:5527: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5527   rm -rf conftest*
5528   eval "ac_cv_func_$ac_func=yes"
5529 else
5530   echo "configure: failed program was:" >&5
5531   cat conftest.$ac_ext >&5
5532   rm -rf conftest*
5533   eval "ac_cv_func_$ac_func=no"
5534 fi
5535 rm -f conftest*
5536 fi
5537
5538 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5539   echo "$ac_t""yes" 1>&6
5540     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5541   cat >> confdefs.h <<EOF
5542 #define $ac_tr_func 1
5543 EOF
5544
5545 else
5546   echo "$ac_t""no" 1>&6
5547 fi
5548 done
5549
5550   fi
5551
5552
5553   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5554 echo "configure:5555: checking for isinff declaration" >&5
5555   if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
5556   echo $ac_n "(cached) $ac_c" 1>&6
5557 else
5558
5559
5560     ac_ext=C
5561 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5562 ac_cpp='$CXXCPP $CPPFLAGS'
5563 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5564 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5565 cross_compiling=$ac_cv_prog_cxx_cross
5566
5567     cat > conftest.$ac_ext <<EOF
5568 #line 5569 "configure"
5569 #include "confdefs.h"
5570 #include <math.h>
5571 int main() {
5572  isinff(0);
5573 ; return 0; }
5574 EOF
5575 if { (eval echo configure:5576: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5576   rm -rf conftest*
5577   glibcpp_cv_func_isinff_use=yes
5578 else
5579   echo "configure: failed program was:" >&5
5580   cat conftest.$ac_ext >&5
5581   rm -rf conftest*
5582   glibcpp_cv_func_isinff_use=no
5583 fi
5584 rm -f conftest*
5585     ac_ext=c
5586 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5587 ac_cpp='$CPP $CPPFLAGS'
5588 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5589 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5590 cross_compiling=$ac_cv_prog_cc_cross
5591
5592
5593 fi
5594
5595   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
5596   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
5597     for ac_func in isinff
5598 do
5599 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5600 echo "configure:5601: checking for $ac_func" >&5
5601 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5602   echo $ac_n "(cached) $ac_c" 1>&6
5603 else
5604   cat > conftest.$ac_ext <<EOF
5605 #line 5606 "configure"
5606 #include "confdefs.h"
5607 /* System header to define __stub macros and hopefully few prototypes,
5608     which can conflict with char $ac_func(); below.  */
5609 #include <assert.h>
5610 /* Override any gcc2 internal prototype to avoid an error.  */
5611 /* We use char because int might match the return type of a gcc2
5612     builtin and then its argument prototype would still apply.  */
5613 char $ac_func();
5614
5615 int main() {
5616
5617 /* The GNU C library defines this for functions which it implements
5618     to always fail with ENOSYS.  Some functions are actually named
5619     something starting with __ and the normal name is an alias.  */
5620 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5621 choke me
5622 #else
5623 $ac_func();
5624 #endif
5625
5626 ; return 0; }
5627 EOF
5628 if { (eval echo configure:5629: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5629   rm -rf conftest*
5630   eval "ac_cv_func_$ac_func=yes"
5631 else
5632   echo "configure: failed program was:" >&5
5633   cat conftest.$ac_ext >&5
5634   rm -rf conftest*
5635   eval "ac_cv_func_$ac_func=no"
5636 fi
5637 rm -f conftest*
5638 fi
5639
5640 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5641   echo "$ac_t""yes" 1>&6
5642     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5643   cat >> confdefs.h <<EOF
5644 #define $ac_tr_func 1
5645 EOF
5646
5647 else
5648   echo "$ac_t""no" 1>&6
5649 fi
5650 done
5651
5652   fi
5653
5654
5655   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5656 echo "configure:5657: checking for acosf declaration" >&5
5657   if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
5658   echo $ac_n "(cached) $ac_c" 1>&6
5659 else
5660
5661
5662     ac_ext=C
5663 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5664 ac_cpp='$CXXCPP $CPPFLAGS'
5665 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5666 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5667 cross_compiling=$ac_cv_prog_cxx_cross
5668
5669     cat > conftest.$ac_ext <<EOF
5670 #line 5671 "configure"
5671 #include "confdefs.h"
5672 #include <math.h>
5673 int main() {
5674  acosf(0);
5675 ; return 0; }
5676 EOF
5677 if { (eval echo configure:5678: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5678   rm -rf conftest*
5679   glibcpp_cv_func_acosf_use=yes
5680 else
5681   echo "configure: failed program was:" >&5
5682   cat conftest.$ac_ext >&5
5683   rm -rf conftest*
5684   glibcpp_cv_func_acosf_use=no
5685 fi
5686 rm -f conftest*
5687     ac_ext=c
5688 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5689 ac_cpp='$CPP $CPPFLAGS'
5690 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5691 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5692 cross_compiling=$ac_cv_prog_cc_cross
5693
5694
5695 fi
5696
5697   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
5698   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
5699     for ac_func in acosf
5700 do
5701 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5702 echo "configure:5703: checking for $ac_func" >&5
5703 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5704   echo $ac_n "(cached) $ac_c" 1>&6
5705 else
5706   cat > conftest.$ac_ext <<EOF
5707 #line 5708 "configure"
5708 #include "confdefs.h"
5709 /* System header to define __stub macros and hopefully few prototypes,
5710     which can conflict with char $ac_func(); below.  */
5711 #include <assert.h>
5712 /* Override any gcc2 internal prototype to avoid an error.  */
5713 /* We use char because int might match the return type of a gcc2
5714     builtin and then its argument prototype would still apply.  */
5715 char $ac_func();
5716
5717 int main() {
5718
5719 /* The GNU C library defines this for functions which it implements
5720     to always fail with ENOSYS.  Some functions are actually named
5721     something starting with __ and the normal name is an alias.  */
5722 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5723 choke me
5724 #else
5725 $ac_func();
5726 #endif
5727
5728 ; return 0; }
5729 EOF
5730 if { (eval echo configure:5731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5731   rm -rf conftest*
5732   eval "ac_cv_func_$ac_func=yes"
5733 else
5734   echo "configure: failed program was:" >&5
5735   cat conftest.$ac_ext >&5
5736   rm -rf conftest*
5737   eval "ac_cv_func_$ac_func=no"
5738 fi
5739 rm -f conftest*
5740 fi
5741
5742 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5743   echo "$ac_t""yes" 1>&6
5744     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5745   cat >> confdefs.h <<EOF
5746 #define $ac_tr_func 1
5747 EOF
5748
5749 else
5750   echo "$ac_t""no" 1>&6
5751 fi
5752 done
5753
5754   fi
5755
5756
5757   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5758 echo "configure:5759: checking for asinf declaration" >&5
5759   if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
5760   echo $ac_n "(cached) $ac_c" 1>&6
5761 else
5762
5763
5764     ac_ext=C
5765 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5766 ac_cpp='$CXXCPP $CPPFLAGS'
5767 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5768 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5769 cross_compiling=$ac_cv_prog_cxx_cross
5770
5771     cat > conftest.$ac_ext <<EOF
5772 #line 5773 "configure"
5773 #include "confdefs.h"
5774 #include <math.h>
5775 int main() {
5776  asinf(0);
5777 ; return 0; }
5778 EOF
5779 if { (eval echo configure:5780: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5780   rm -rf conftest*
5781   glibcpp_cv_func_asinf_use=yes
5782 else
5783   echo "configure: failed program was:" >&5
5784   cat conftest.$ac_ext >&5
5785   rm -rf conftest*
5786   glibcpp_cv_func_asinf_use=no
5787 fi
5788 rm -f conftest*
5789     ac_ext=c
5790 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5791 ac_cpp='$CPP $CPPFLAGS'
5792 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5793 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5794 cross_compiling=$ac_cv_prog_cc_cross
5795
5796
5797 fi
5798
5799   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
5800   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
5801     for ac_func in asinf
5802 do
5803 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5804 echo "configure:5805: checking for $ac_func" >&5
5805 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5806   echo $ac_n "(cached) $ac_c" 1>&6
5807 else
5808   cat > conftest.$ac_ext <<EOF
5809 #line 5810 "configure"
5810 #include "confdefs.h"
5811 /* System header to define __stub macros and hopefully few prototypes,
5812     which can conflict with char $ac_func(); below.  */
5813 #include <assert.h>
5814 /* Override any gcc2 internal prototype to avoid an error.  */
5815 /* We use char because int might match the return type of a gcc2
5816     builtin and then its argument prototype would still apply.  */
5817 char $ac_func();
5818
5819 int main() {
5820
5821 /* The GNU C library defines this for functions which it implements
5822     to always fail with ENOSYS.  Some functions are actually named
5823     something starting with __ and the normal name is an alias.  */
5824 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5825 choke me
5826 #else
5827 $ac_func();
5828 #endif
5829
5830 ; return 0; }
5831 EOF
5832 if { (eval echo configure:5833: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5833   rm -rf conftest*
5834   eval "ac_cv_func_$ac_func=yes"
5835 else
5836   echo "configure: failed program was:" >&5
5837   cat conftest.$ac_ext >&5
5838   rm -rf conftest*
5839   eval "ac_cv_func_$ac_func=no"
5840 fi
5841 rm -f conftest*
5842 fi
5843
5844 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5845   echo "$ac_t""yes" 1>&6
5846     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5847   cat >> confdefs.h <<EOF
5848 #define $ac_tr_func 1
5849 EOF
5850
5851 else
5852   echo "$ac_t""no" 1>&6
5853 fi
5854 done
5855
5856   fi
5857
5858
5859   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5860 echo "configure:5861: checking for atanf declaration" >&5
5861   if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
5862   echo $ac_n "(cached) $ac_c" 1>&6
5863 else
5864
5865
5866     ac_ext=C
5867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5868 ac_cpp='$CXXCPP $CPPFLAGS'
5869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5871 cross_compiling=$ac_cv_prog_cxx_cross
5872
5873     cat > conftest.$ac_ext <<EOF
5874 #line 5875 "configure"
5875 #include "confdefs.h"
5876 #include <math.h>
5877 int main() {
5878  atanf(0);
5879 ; return 0; }
5880 EOF
5881 if { (eval echo configure:5882: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5882   rm -rf conftest*
5883   glibcpp_cv_func_atanf_use=yes
5884 else
5885   echo "configure: failed program was:" >&5
5886   cat conftest.$ac_ext >&5
5887   rm -rf conftest*
5888   glibcpp_cv_func_atanf_use=no
5889 fi
5890 rm -f conftest*
5891     ac_ext=c
5892 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5893 ac_cpp='$CPP $CPPFLAGS'
5894 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5895 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5896 cross_compiling=$ac_cv_prog_cc_cross
5897
5898
5899 fi
5900
5901   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
5902   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
5903     for ac_func in atanf
5904 do
5905 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5906 echo "configure:5907: checking for $ac_func" >&5
5907 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5908   echo $ac_n "(cached) $ac_c" 1>&6
5909 else
5910   cat > conftest.$ac_ext <<EOF
5911 #line 5912 "configure"
5912 #include "confdefs.h"
5913 /* System header to define __stub macros and hopefully few prototypes,
5914     which can conflict with char $ac_func(); below.  */
5915 #include <assert.h>
5916 /* Override any gcc2 internal prototype to avoid an error.  */
5917 /* We use char because int might match the return type of a gcc2
5918     builtin and then its argument prototype would still apply.  */
5919 char $ac_func();
5920
5921 int main() {
5922
5923 /* The GNU C library defines this for functions which it implements
5924     to always fail with ENOSYS.  Some functions are actually named
5925     something starting with __ and the normal name is an alias.  */
5926 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5927 choke me
5928 #else
5929 $ac_func();
5930 #endif
5931
5932 ; return 0; }
5933 EOF
5934 if { (eval echo configure:5935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5935   rm -rf conftest*
5936   eval "ac_cv_func_$ac_func=yes"
5937 else
5938   echo "configure: failed program was:" >&5
5939   cat conftest.$ac_ext >&5
5940   rm -rf conftest*
5941   eval "ac_cv_func_$ac_func=no"
5942 fi
5943 rm -f conftest*
5944 fi
5945
5946 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5947   echo "$ac_t""yes" 1>&6
5948     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5949   cat >> confdefs.h <<EOF
5950 #define $ac_tr_func 1
5951 EOF
5952
5953 else
5954   echo "$ac_t""no" 1>&6
5955 fi
5956 done
5957
5958   fi
5959
5960
5961   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
5962 echo "configure:5963: checking for atan2f declaration" >&5
5963   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
5964   echo $ac_n "(cached) $ac_c" 1>&6
5965 else
5966
5967
5968     ac_ext=C
5969 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5970 ac_cpp='$CXXCPP $CPPFLAGS'
5971 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5972 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5973 cross_compiling=$ac_cv_prog_cxx_cross
5974
5975     cat > conftest.$ac_ext <<EOF
5976 #line 5977 "configure"
5977 #include "confdefs.h"
5978 #include <math.h>
5979 int main() {
5980  atan2f(0, 0);
5981 ; return 0; }
5982 EOF
5983 if { (eval echo configure:5984: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5984   rm -rf conftest*
5985   glibcpp_cv_func_atan2f_use=yes
5986 else
5987   echo "configure: failed program was:" >&5
5988   cat conftest.$ac_ext >&5
5989   rm -rf conftest*
5990   glibcpp_cv_func_atan2f_use=no
5991 fi
5992 rm -f conftest*
5993     ac_ext=c
5994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5995 ac_cpp='$CPP $CPPFLAGS'
5996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5998 cross_compiling=$ac_cv_prog_cc_cross
5999
6000
6001 fi
6002
6003   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
6004   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
6005     for ac_func in atan2f
6006 do
6007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6008 echo "configure:6009: checking for $ac_func" >&5
6009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6010   echo $ac_n "(cached) $ac_c" 1>&6
6011 else
6012   cat > conftest.$ac_ext <<EOF
6013 #line 6014 "configure"
6014 #include "confdefs.h"
6015 /* System header to define __stub macros and hopefully few prototypes,
6016     which can conflict with char $ac_func(); below.  */
6017 #include <assert.h>
6018 /* Override any gcc2 internal prototype to avoid an error.  */
6019 /* We use char because int might match the return type of a gcc2
6020     builtin and then its argument prototype would still apply.  */
6021 char $ac_func();
6022
6023 int main() {
6024
6025 /* The GNU C library defines this for functions which it implements
6026     to always fail with ENOSYS.  Some functions are actually named
6027     something starting with __ and the normal name is an alias.  */
6028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6029 choke me
6030 #else
6031 $ac_func();
6032 #endif
6033
6034 ; return 0; }
6035 EOF
6036 if { (eval echo configure:6037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6037   rm -rf conftest*
6038   eval "ac_cv_func_$ac_func=yes"
6039 else
6040   echo "configure: failed program was:" >&5
6041   cat conftest.$ac_ext >&5
6042   rm -rf conftest*
6043   eval "ac_cv_func_$ac_func=no"
6044 fi
6045 rm -f conftest*
6046 fi
6047
6048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6049   echo "$ac_t""yes" 1>&6
6050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6051   cat >> confdefs.h <<EOF
6052 #define $ac_tr_func 1
6053 EOF
6054
6055 else
6056   echo "$ac_t""no" 1>&6
6057 fi
6058 done
6059
6060   fi
6061
6062
6063   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6064 echo "configure:6065: checking for ceilf declaration" >&5
6065   if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
6066   echo $ac_n "(cached) $ac_c" 1>&6
6067 else
6068
6069
6070     ac_ext=C
6071 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6072 ac_cpp='$CXXCPP $CPPFLAGS'
6073 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6074 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6075 cross_compiling=$ac_cv_prog_cxx_cross
6076
6077     cat > conftest.$ac_ext <<EOF
6078 #line 6079 "configure"
6079 #include "confdefs.h"
6080 #include <math.h>
6081 int main() {
6082  ceilf(0);
6083 ; return 0; }
6084 EOF
6085 if { (eval echo configure:6086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6086   rm -rf conftest*
6087   glibcpp_cv_func_ceilf_use=yes
6088 else
6089   echo "configure: failed program was:" >&5
6090   cat conftest.$ac_ext >&5
6091   rm -rf conftest*
6092   glibcpp_cv_func_ceilf_use=no
6093 fi
6094 rm -f conftest*
6095     ac_ext=c
6096 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6097 ac_cpp='$CPP $CPPFLAGS'
6098 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6099 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6100 cross_compiling=$ac_cv_prog_cc_cross
6101
6102
6103 fi
6104
6105   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
6106   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
6107     for ac_func in ceilf
6108 do
6109 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6110 echo "configure:6111: checking for $ac_func" >&5
6111 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6112   echo $ac_n "(cached) $ac_c" 1>&6
6113 else
6114   cat > conftest.$ac_ext <<EOF
6115 #line 6116 "configure"
6116 #include "confdefs.h"
6117 /* System header to define __stub macros and hopefully few prototypes,
6118     which can conflict with char $ac_func(); below.  */
6119 #include <assert.h>
6120 /* Override any gcc2 internal prototype to avoid an error.  */
6121 /* We use char because int might match the return type of a gcc2
6122     builtin and then its argument prototype would still apply.  */
6123 char $ac_func();
6124
6125 int main() {
6126
6127 /* The GNU C library defines this for functions which it implements
6128     to always fail with ENOSYS.  Some functions are actually named
6129     something starting with __ and the normal name is an alias.  */
6130 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6131 choke me
6132 #else
6133 $ac_func();
6134 #endif
6135
6136 ; return 0; }
6137 EOF
6138 if { (eval echo configure:6139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6139   rm -rf conftest*
6140   eval "ac_cv_func_$ac_func=yes"
6141 else
6142   echo "configure: failed program was:" >&5
6143   cat conftest.$ac_ext >&5
6144   rm -rf conftest*
6145   eval "ac_cv_func_$ac_func=no"
6146 fi
6147 rm -f conftest*
6148 fi
6149
6150 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6151   echo "$ac_t""yes" 1>&6
6152     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6153   cat >> confdefs.h <<EOF
6154 #define $ac_tr_func 1
6155 EOF
6156
6157 else
6158   echo "$ac_t""no" 1>&6
6159 fi
6160 done
6161
6162   fi
6163
6164
6165   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6166 echo "configure:6167: checking for cosf declaration" >&5
6167   if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
6168   echo $ac_n "(cached) $ac_c" 1>&6
6169 else
6170
6171
6172     ac_ext=C
6173 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6174 ac_cpp='$CXXCPP $CPPFLAGS'
6175 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6176 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6177 cross_compiling=$ac_cv_prog_cxx_cross
6178
6179     cat > conftest.$ac_ext <<EOF
6180 #line 6181 "configure"
6181 #include "confdefs.h"
6182 #include <math.h>
6183 int main() {
6184  cosf(0);
6185 ; return 0; }
6186 EOF
6187 if { (eval echo configure:6188: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6188   rm -rf conftest*
6189   glibcpp_cv_func_cosf_use=yes
6190 else
6191   echo "configure: failed program was:" >&5
6192   cat conftest.$ac_ext >&5
6193   rm -rf conftest*
6194   glibcpp_cv_func_cosf_use=no
6195 fi
6196 rm -f conftest*
6197     ac_ext=c
6198 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6199 ac_cpp='$CPP $CPPFLAGS'
6200 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6201 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6202 cross_compiling=$ac_cv_prog_cc_cross
6203
6204
6205 fi
6206
6207   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
6208   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
6209     for ac_func in cosf
6210 do
6211 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6212 echo "configure:6213: checking for $ac_func" >&5
6213 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6214   echo $ac_n "(cached) $ac_c" 1>&6
6215 else
6216   cat > conftest.$ac_ext <<EOF
6217 #line 6218 "configure"
6218 #include "confdefs.h"
6219 /* System header to define __stub macros and hopefully few prototypes,
6220     which can conflict with char $ac_func(); below.  */
6221 #include <assert.h>
6222 /* Override any gcc2 internal prototype to avoid an error.  */
6223 /* We use char because int might match the return type of a gcc2
6224     builtin and then its argument prototype would still apply.  */
6225 char $ac_func();
6226
6227 int main() {
6228
6229 /* The GNU C library defines this for functions which it implements
6230     to always fail with ENOSYS.  Some functions are actually named
6231     something starting with __ and the normal name is an alias.  */
6232 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6233 choke me
6234 #else
6235 $ac_func();
6236 #endif
6237
6238 ; return 0; }
6239 EOF
6240 if { (eval echo configure:6241: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6241   rm -rf conftest*
6242   eval "ac_cv_func_$ac_func=yes"
6243 else
6244   echo "configure: failed program was:" >&5
6245   cat conftest.$ac_ext >&5
6246   rm -rf conftest*
6247   eval "ac_cv_func_$ac_func=no"
6248 fi
6249 rm -f conftest*
6250 fi
6251
6252 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6253   echo "$ac_t""yes" 1>&6
6254     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6255   cat >> confdefs.h <<EOF
6256 #define $ac_tr_func 1
6257 EOF
6258
6259 else
6260   echo "$ac_t""no" 1>&6
6261 fi
6262 done
6263
6264   fi
6265
6266
6267   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6268 echo "configure:6269: checking for coshf declaration" >&5
6269   if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
6270   echo $ac_n "(cached) $ac_c" 1>&6
6271 else
6272
6273
6274     ac_ext=C
6275 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6276 ac_cpp='$CXXCPP $CPPFLAGS'
6277 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6278 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6279 cross_compiling=$ac_cv_prog_cxx_cross
6280
6281     cat > conftest.$ac_ext <<EOF
6282 #line 6283 "configure"
6283 #include "confdefs.h"
6284 #include <math.h>
6285 int main() {
6286  coshf(0);
6287 ; return 0; }
6288 EOF
6289 if { (eval echo configure:6290: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6290   rm -rf conftest*
6291   glibcpp_cv_func_coshf_use=yes
6292 else
6293   echo "configure: failed program was:" >&5
6294   cat conftest.$ac_ext >&5
6295   rm -rf conftest*
6296   glibcpp_cv_func_coshf_use=no
6297 fi
6298 rm -f conftest*
6299     ac_ext=c
6300 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6301 ac_cpp='$CPP $CPPFLAGS'
6302 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6303 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6304 cross_compiling=$ac_cv_prog_cc_cross
6305
6306
6307 fi
6308
6309   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
6310   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
6311     for ac_func in coshf
6312 do
6313 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6314 echo "configure:6315: checking for $ac_func" >&5
6315 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6316   echo $ac_n "(cached) $ac_c" 1>&6
6317 else
6318   cat > conftest.$ac_ext <<EOF
6319 #line 6320 "configure"
6320 #include "confdefs.h"
6321 /* System header to define __stub macros and hopefully few prototypes,
6322     which can conflict with char $ac_func(); below.  */
6323 #include <assert.h>
6324 /* Override any gcc2 internal prototype to avoid an error.  */
6325 /* We use char because int might match the return type of a gcc2
6326     builtin and then its argument prototype would still apply.  */
6327 char $ac_func();
6328
6329 int main() {
6330
6331 /* The GNU C library defines this for functions which it implements
6332     to always fail with ENOSYS.  Some functions are actually named
6333     something starting with __ and the normal name is an alias.  */
6334 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6335 choke me
6336 #else
6337 $ac_func();
6338 #endif
6339
6340 ; return 0; }
6341 EOF
6342 if { (eval echo configure:6343: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6343   rm -rf conftest*
6344   eval "ac_cv_func_$ac_func=yes"
6345 else
6346   echo "configure: failed program was:" >&5
6347   cat conftest.$ac_ext >&5
6348   rm -rf conftest*
6349   eval "ac_cv_func_$ac_func=no"
6350 fi
6351 rm -f conftest*
6352 fi
6353
6354 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6355   echo "$ac_t""yes" 1>&6
6356     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6357   cat >> confdefs.h <<EOF
6358 #define $ac_tr_func 1
6359 EOF
6360
6361 else
6362   echo "$ac_t""no" 1>&6
6363 fi
6364 done
6365
6366   fi
6367
6368
6369   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6370 echo "configure:6371: checking for expf declaration" >&5
6371   if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
6372   echo $ac_n "(cached) $ac_c" 1>&6
6373 else
6374
6375
6376     ac_ext=C
6377 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6378 ac_cpp='$CXXCPP $CPPFLAGS'
6379 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6380 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6381 cross_compiling=$ac_cv_prog_cxx_cross
6382
6383     cat > conftest.$ac_ext <<EOF
6384 #line 6385 "configure"
6385 #include "confdefs.h"
6386 #include <math.h>
6387 int main() {
6388  expf(0);
6389 ; return 0; }
6390 EOF
6391 if { (eval echo configure:6392: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6392   rm -rf conftest*
6393   glibcpp_cv_func_expf_use=yes
6394 else
6395   echo "configure: failed program was:" >&5
6396   cat conftest.$ac_ext >&5
6397   rm -rf conftest*
6398   glibcpp_cv_func_expf_use=no
6399 fi
6400 rm -f conftest*
6401     ac_ext=c
6402 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6403 ac_cpp='$CPP $CPPFLAGS'
6404 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6405 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6406 cross_compiling=$ac_cv_prog_cc_cross
6407
6408
6409 fi
6410
6411   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
6412   if test x$glibcpp_cv_func_expf_use = x"yes"; then
6413     for ac_func in expf
6414 do
6415 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6416 echo "configure:6417: checking for $ac_func" >&5
6417 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6418   echo $ac_n "(cached) $ac_c" 1>&6
6419 else
6420   cat > conftest.$ac_ext <<EOF
6421 #line 6422 "configure"
6422 #include "confdefs.h"
6423 /* System header to define __stub macros and hopefully few prototypes,
6424     which can conflict with char $ac_func(); below.  */
6425 #include <assert.h>
6426 /* Override any gcc2 internal prototype to avoid an error.  */
6427 /* We use char because int might match the return type of a gcc2
6428     builtin and then its argument prototype would still apply.  */
6429 char $ac_func();
6430
6431 int main() {
6432
6433 /* The GNU C library defines this for functions which it implements
6434     to always fail with ENOSYS.  Some functions are actually named
6435     something starting with __ and the normal name is an alias.  */
6436 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6437 choke me
6438 #else
6439 $ac_func();
6440 #endif
6441
6442 ; return 0; }
6443 EOF
6444 if { (eval echo configure:6445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6445   rm -rf conftest*
6446   eval "ac_cv_func_$ac_func=yes"
6447 else
6448   echo "configure: failed program was:" >&5
6449   cat conftest.$ac_ext >&5
6450   rm -rf conftest*
6451   eval "ac_cv_func_$ac_func=no"
6452 fi
6453 rm -f conftest*
6454 fi
6455
6456 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6457   echo "$ac_t""yes" 1>&6
6458     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6459   cat >> confdefs.h <<EOF
6460 #define $ac_tr_func 1
6461 EOF
6462
6463 else
6464   echo "$ac_t""no" 1>&6
6465 fi
6466 done
6467
6468   fi
6469
6470
6471   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6472 echo "configure:6473: checking for fabsf declaration" >&5
6473   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
6474   echo $ac_n "(cached) $ac_c" 1>&6
6475 else
6476
6477
6478     ac_ext=C
6479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6480 ac_cpp='$CXXCPP $CPPFLAGS'
6481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6483 cross_compiling=$ac_cv_prog_cxx_cross
6484
6485     cat > conftest.$ac_ext <<EOF
6486 #line 6487 "configure"
6487 #include "confdefs.h"
6488 #include <math.h>
6489 int main() {
6490  fabsf(0);
6491 ; return 0; }
6492 EOF
6493 if { (eval echo configure:6494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6494   rm -rf conftest*
6495   glibcpp_cv_func_fabsf_use=yes
6496 else
6497   echo "configure: failed program was:" >&5
6498   cat conftest.$ac_ext >&5
6499   rm -rf conftest*
6500   glibcpp_cv_func_fabsf_use=no
6501 fi
6502 rm -f conftest*
6503     ac_ext=c
6504 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6505 ac_cpp='$CPP $CPPFLAGS'
6506 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6507 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6508 cross_compiling=$ac_cv_prog_cc_cross
6509
6510
6511 fi
6512
6513   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
6514   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
6515     for ac_func in fabsf
6516 do
6517 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6518 echo "configure:6519: checking for $ac_func" >&5
6519 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6520   echo $ac_n "(cached) $ac_c" 1>&6
6521 else
6522   cat > conftest.$ac_ext <<EOF
6523 #line 6524 "configure"
6524 #include "confdefs.h"
6525 /* System header to define __stub macros and hopefully few prototypes,
6526     which can conflict with char $ac_func(); below.  */
6527 #include <assert.h>
6528 /* Override any gcc2 internal prototype to avoid an error.  */
6529 /* We use char because int might match the return type of a gcc2
6530     builtin and then its argument prototype would still apply.  */
6531 char $ac_func();
6532
6533 int main() {
6534
6535 /* The GNU C library defines this for functions which it implements
6536     to always fail with ENOSYS.  Some functions are actually named
6537     something starting with __ and the normal name is an alias.  */
6538 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6539 choke me
6540 #else
6541 $ac_func();
6542 #endif
6543
6544 ; return 0; }
6545 EOF
6546 if { (eval echo configure:6547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6547   rm -rf conftest*
6548   eval "ac_cv_func_$ac_func=yes"
6549 else
6550   echo "configure: failed program was:" >&5
6551   cat conftest.$ac_ext >&5
6552   rm -rf conftest*
6553   eval "ac_cv_func_$ac_func=no"
6554 fi
6555 rm -f conftest*
6556 fi
6557
6558 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6559   echo "$ac_t""yes" 1>&6
6560     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6561   cat >> confdefs.h <<EOF
6562 #define $ac_tr_func 1
6563 EOF
6564
6565 else
6566   echo "$ac_t""no" 1>&6
6567 fi
6568 done
6569
6570   fi
6571
6572
6573   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6574 echo "configure:6575: checking for floorf declaration" >&5
6575   if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
6576   echo $ac_n "(cached) $ac_c" 1>&6
6577 else
6578
6579
6580     ac_ext=C
6581 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6582 ac_cpp='$CXXCPP $CPPFLAGS'
6583 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6584 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6585 cross_compiling=$ac_cv_prog_cxx_cross
6586
6587     cat > conftest.$ac_ext <<EOF
6588 #line 6589 "configure"
6589 #include "confdefs.h"
6590 #include <math.h>
6591 int main() {
6592  floorf(0);
6593 ; return 0; }
6594 EOF
6595 if { (eval echo configure:6596: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6596   rm -rf conftest*
6597   glibcpp_cv_func_floorf_use=yes
6598 else
6599   echo "configure: failed program was:" >&5
6600   cat conftest.$ac_ext >&5
6601   rm -rf conftest*
6602   glibcpp_cv_func_floorf_use=no
6603 fi
6604 rm -f conftest*
6605     ac_ext=c
6606 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6607 ac_cpp='$CPP $CPPFLAGS'
6608 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6609 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6610 cross_compiling=$ac_cv_prog_cc_cross
6611
6612
6613 fi
6614
6615   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
6616   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
6617     for ac_func in floorf
6618 do
6619 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6620 echo "configure:6621: checking for $ac_func" >&5
6621 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6622   echo $ac_n "(cached) $ac_c" 1>&6
6623 else
6624   cat > conftest.$ac_ext <<EOF
6625 #line 6626 "configure"
6626 #include "confdefs.h"
6627 /* System header to define __stub macros and hopefully few prototypes,
6628     which can conflict with char $ac_func(); below.  */
6629 #include <assert.h>
6630 /* Override any gcc2 internal prototype to avoid an error.  */
6631 /* We use char because int might match the return type of a gcc2
6632     builtin and then its argument prototype would still apply.  */
6633 char $ac_func();
6634
6635 int main() {
6636
6637 /* The GNU C library defines this for functions which it implements
6638     to always fail with ENOSYS.  Some functions are actually named
6639     something starting with __ and the normal name is an alias.  */
6640 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6641 choke me
6642 #else
6643 $ac_func();
6644 #endif
6645
6646 ; return 0; }
6647 EOF
6648 if { (eval echo configure:6649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6649   rm -rf conftest*
6650   eval "ac_cv_func_$ac_func=yes"
6651 else
6652   echo "configure: failed program was:" >&5
6653   cat conftest.$ac_ext >&5
6654   rm -rf conftest*
6655   eval "ac_cv_func_$ac_func=no"
6656 fi
6657 rm -f conftest*
6658 fi
6659
6660 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6661   echo "$ac_t""yes" 1>&6
6662     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6663   cat >> confdefs.h <<EOF
6664 #define $ac_tr_func 1
6665 EOF
6666
6667 else
6668   echo "$ac_t""no" 1>&6
6669 fi
6670 done
6671
6672   fi
6673
6674
6675   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6676 echo "configure:6677: checking for fmodf declaration" >&5
6677   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
6678   echo $ac_n "(cached) $ac_c" 1>&6
6679 else
6680
6681
6682     ac_ext=C
6683 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6684 ac_cpp='$CXXCPP $CPPFLAGS'
6685 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6686 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6687 cross_compiling=$ac_cv_prog_cxx_cross
6688
6689     cat > conftest.$ac_ext <<EOF
6690 #line 6691 "configure"
6691 #include "confdefs.h"
6692 #include <math.h>
6693 int main() {
6694  fmodf(0, 0);
6695 ; return 0; }
6696 EOF
6697 if { (eval echo configure:6698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6698   rm -rf conftest*
6699   glibcpp_cv_func_fmodf_use=yes
6700 else
6701   echo "configure: failed program was:" >&5
6702   cat conftest.$ac_ext >&5
6703   rm -rf conftest*
6704   glibcpp_cv_func_fmodf_use=no
6705 fi
6706 rm -f conftest*
6707     ac_ext=c
6708 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6709 ac_cpp='$CPP $CPPFLAGS'
6710 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6711 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6712 cross_compiling=$ac_cv_prog_cc_cross
6713
6714
6715 fi
6716
6717   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
6718   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
6719     for ac_func in fmodf
6720 do
6721 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6722 echo "configure:6723: checking for $ac_func" >&5
6723 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6724   echo $ac_n "(cached) $ac_c" 1>&6
6725 else
6726   cat > conftest.$ac_ext <<EOF
6727 #line 6728 "configure"
6728 #include "confdefs.h"
6729 /* System header to define __stub macros and hopefully few prototypes,
6730     which can conflict with char $ac_func(); below.  */
6731 #include <assert.h>
6732 /* Override any gcc2 internal prototype to avoid an error.  */
6733 /* We use char because int might match the return type of a gcc2
6734     builtin and then its argument prototype would still apply.  */
6735 char $ac_func();
6736
6737 int main() {
6738
6739 /* The GNU C library defines this for functions which it implements
6740     to always fail with ENOSYS.  Some functions are actually named
6741     something starting with __ and the normal name is an alias.  */
6742 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6743 choke me
6744 #else
6745 $ac_func();
6746 #endif
6747
6748 ; return 0; }
6749 EOF
6750 if { (eval echo configure:6751: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6751   rm -rf conftest*
6752   eval "ac_cv_func_$ac_func=yes"
6753 else
6754   echo "configure: failed program was:" >&5
6755   cat conftest.$ac_ext >&5
6756   rm -rf conftest*
6757   eval "ac_cv_func_$ac_func=no"
6758 fi
6759 rm -f conftest*
6760 fi
6761
6762 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6763   echo "$ac_t""yes" 1>&6
6764     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6765   cat >> confdefs.h <<EOF
6766 #define $ac_tr_func 1
6767 EOF
6768
6769 else
6770   echo "$ac_t""no" 1>&6
6771 fi
6772 done
6773
6774   fi
6775
6776
6777   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6778 echo "configure:6779: checking for frexpf declaration" >&5
6779   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
6780   echo $ac_n "(cached) $ac_c" 1>&6
6781 else
6782
6783
6784     ac_ext=C
6785 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6786 ac_cpp='$CXXCPP $CPPFLAGS'
6787 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6788 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6789 cross_compiling=$ac_cv_prog_cxx_cross
6790
6791     cat > conftest.$ac_ext <<EOF
6792 #line 6793 "configure"
6793 #include "confdefs.h"
6794 #include <math.h>
6795 int main() {
6796  frexpf(0, 0);
6797 ; return 0; }
6798 EOF
6799 if { (eval echo configure:6800: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6800   rm -rf conftest*
6801   glibcpp_cv_func_frexpf_use=yes
6802 else
6803   echo "configure: failed program was:" >&5
6804   cat conftest.$ac_ext >&5
6805   rm -rf conftest*
6806   glibcpp_cv_func_frexpf_use=no
6807 fi
6808 rm -f conftest*
6809     ac_ext=c
6810 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6811 ac_cpp='$CPP $CPPFLAGS'
6812 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6813 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6814 cross_compiling=$ac_cv_prog_cc_cross
6815
6816
6817 fi
6818
6819   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
6820   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
6821     for ac_func in frexpf
6822 do
6823 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6824 echo "configure:6825: checking for $ac_func" >&5
6825 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6826   echo $ac_n "(cached) $ac_c" 1>&6
6827 else
6828   cat > conftest.$ac_ext <<EOF
6829 #line 6830 "configure"
6830 #include "confdefs.h"
6831 /* System header to define __stub macros and hopefully few prototypes,
6832     which can conflict with char $ac_func(); below.  */
6833 #include <assert.h>
6834 /* Override any gcc2 internal prototype to avoid an error.  */
6835 /* We use char because int might match the return type of a gcc2
6836     builtin and then its argument prototype would still apply.  */
6837 char $ac_func();
6838
6839 int main() {
6840
6841 /* The GNU C library defines this for functions which it implements
6842     to always fail with ENOSYS.  Some functions are actually named
6843     something starting with __ and the normal name is an alias.  */
6844 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6845 choke me
6846 #else
6847 $ac_func();
6848 #endif
6849
6850 ; return 0; }
6851 EOF
6852 if { (eval echo configure:6853: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6853   rm -rf conftest*
6854   eval "ac_cv_func_$ac_func=yes"
6855 else
6856   echo "configure: failed program was:" >&5
6857   cat conftest.$ac_ext >&5
6858   rm -rf conftest*
6859   eval "ac_cv_func_$ac_func=no"
6860 fi
6861 rm -f conftest*
6862 fi
6863
6864 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6865   echo "$ac_t""yes" 1>&6
6866     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6867   cat >> confdefs.h <<EOF
6868 #define $ac_tr_func 1
6869 EOF
6870
6871 else
6872   echo "$ac_t""no" 1>&6
6873 fi
6874 done
6875
6876   fi
6877
6878
6879   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6880 echo "configure:6881: checking for ldexpf declaration" >&5
6881   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
6882   echo $ac_n "(cached) $ac_c" 1>&6
6883 else
6884
6885
6886     ac_ext=C
6887 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6888 ac_cpp='$CXXCPP $CPPFLAGS'
6889 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6890 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6891 cross_compiling=$ac_cv_prog_cxx_cross
6892
6893     cat > conftest.$ac_ext <<EOF
6894 #line 6895 "configure"
6895 #include "confdefs.h"
6896 #include <math.h>
6897 int main() {
6898  ldexpf(0, 0);
6899 ; return 0; }
6900 EOF
6901 if { (eval echo configure:6902: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6902   rm -rf conftest*
6903   glibcpp_cv_func_ldexpf_use=yes
6904 else
6905   echo "configure: failed program was:" >&5
6906   cat conftest.$ac_ext >&5
6907   rm -rf conftest*
6908   glibcpp_cv_func_ldexpf_use=no
6909 fi
6910 rm -f conftest*
6911     ac_ext=c
6912 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6913 ac_cpp='$CPP $CPPFLAGS'
6914 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6915 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6916 cross_compiling=$ac_cv_prog_cc_cross
6917
6918
6919 fi
6920
6921   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
6922   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
6923     for ac_func in ldexpf
6924 do
6925 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6926 echo "configure:6927: checking for $ac_func" >&5
6927 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6928   echo $ac_n "(cached) $ac_c" 1>&6
6929 else
6930   cat > conftest.$ac_ext <<EOF
6931 #line 6932 "configure"
6932 #include "confdefs.h"
6933 /* System header to define __stub macros and hopefully few prototypes,
6934     which can conflict with char $ac_func(); below.  */
6935 #include <assert.h>
6936 /* Override any gcc2 internal prototype to avoid an error.  */
6937 /* We use char because int might match the return type of a gcc2
6938     builtin and then its argument prototype would still apply.  */
6939 char $ac_func();
6940
6941 int main() {
6942
6943 /* The GNU C library defines this for functions which it implements
6944     to always fail with ENOSYS.  Some functions are actually named
6945     something starting with __ and the normal name is an alias.  */
6946 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6947 choke me
6948 #else
6949 $ac_func();
6950 #endif
6951
6952 ; return 0; }
6953 EOF
6954 if { (eval echo configure:6955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6955   rm -rf conftest*
6956   eval "ac_cv_func_$ac_func=yes"
6957 else
6958   echo "configure: failed program was:" >&5
6959   cat conftest.$ac_ext >&5
6960   rm -rf conftest*
6961   eval "ac_cv_func_$ac_func=no"
6962 fi
6963 rm -f conftest*
6964 fi
6965
6966 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6967   echo "$ac_t""yes" 1>&6
6968     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6969   cat >> confdefs.h <<EOF
6970 #define $ac_tr_func 1
6971 EOF
6972
6973 else
6974   echo "$ac_t""no" 1>&6
6975 fi
6976 done
6977
6978   fi
6979
6980
6981   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6982 echo "configure:6983: checking for logf declaration" >&5
6983   if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
6984   echo $ac_n "(cached) $ac_c" 1>&6
6985 else
6986
6987
6988     ac_ext=C
6989 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6990 ac_cpp='$CXXCPP $CPPFLAGS'
6991 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6992 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6993 cross_compiling=$ac_cv_prog_cxx_cross
6994
6995     cat > conftest.$ac_ext <<EOF
6996 #line 6997 "configure"
6997 #include "confdefs.h"
6998 #include <math.h>
6999 int main() {
7000  logf(0);
7001 ; return 0; }
7002 EOF
7003 if { (eval echo configure:7004: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7004   rm -rf conftest*
7005   glibcpp_cv_func_logf_use=yes
7006 else
7007   echo "configure: failed program was:" >&5
7008   cat conftest.$ac_ext >&5
7009   rm -rf conftest*
7010   glibcpp_cv_func_logf_use=no
7011 fi
7012 rm -f conftest*
7013     ac_ext=c
7014 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7015 ac_cpp='$CPP $CPPFLAGS'
7016 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7017 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7018 cross_compiling=$ac_cv_prog_cc_cross
7019
7020
7021 fi
7022
7023   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
7024   if test x$glibcpp_cv_func_logf_use = x"yes"; then
7025     for ac_func in logf
7026 do
7027 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7028 echo "configure:7029: checking for $ac_func" >&5
7029 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7030   echo $ac_n "(cached) $ac_c" 1>&6
7031 else
7032   cat > conftest.$ac_ext <<EOF
7033 #line 7034 "configure"
7034 #include "confdefs.h"
7035 /* System header to define __stub macros and hopefully few prototypes,
7036     which can conflict with char $ac_func(); below.  */
7037 #include <assert.h>
7038 /* Override any gcc2 internal prototype to avoid an error.  */
7039 /* We use char because int might match the return type of a gcc2
7040     builtin and then its argument prototype would still apply.  */
7041 char $ac_func();
7042
7043 int main() {
7044
7045 /* The GNU C library defines this for functions which it implements
7046     to always fail with ENOSYS.  Some functions are actually named
7047     something starting with __ and the normal name is an alias.  */
7048 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7049 choke me
7050 #else
7051 $ac_func();
7052 #endif
7053
7054 ; return 0; }
7055 EOF
7056 if { (eval echo configure:7057: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7057   rm -rf conftest*
7058   eval "ac_cv_func_$ac_func=yes"
7059 else
7060   echo "configure: failed program was:" >&5
7061   cat conftest.$ac_ext >&5
7062   rm -rf conftest*
7063   eval "ac_cv_func_$ac_func=no"
7064 fi
7065 rm -f conftest*
7066 fi
7067
7068 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7069   echo "$ac_t""yes" 1>&6
7070     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7071   cat >> confdefs.h <<EOF
7072 #define $ac_tr_func 1
7073 EOF
7074
7075 else
7076   echo "$ac_t""no" 1>&6
7077 fi
7078 done
7079
7080   fi
7081
7082
7083   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7084 echo "configure:7085: checking for log10f declaration" >&5
7085   if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
7086   echo $ac_n "(cached) $ac_c" 1>&6
7087 else
7088
7089
7090     ac_ext=C
7091 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7092 ac_cpp='$CXXCPP $CPPFLAGS'
7093 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7094 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7095 cross_compiling=$ac_cv_prog_cxx_cross
7096
7097     cat > conftest.$ac_ext <<EOF
7098 #line 7099 "configure"
7099 #include "confdefs.h"
7100 #include <math.h>
7101 int main() {
7102  log10f(0);
7103 ; return 0; }
7104 EOF
7105 if { (eval echo configure:7106: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7106   rm -rf conftest*
7107   glibcpp_cv_func_log10f_use=yes
7108 else
7109   echo "configure: failed program was:" >&5
7110   cat conftest.$ac_ext >&5
7111   rm -rf conftest*
7112   glibcpp_cv_func_log10f_use=no
7113 fi
7114 rm -f conftest*
7115     ac_ext=c
7116 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7117 ac_cpp='$CPP $CPPFLAGS'
7118 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7119 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7120 cross_compiling=$ac_cv_prog_cc_cross
7121
7122
7123 fi
7124
7125   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
7126   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
7127     for ac_func in log10f
7128 do
7129 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7130 echo "configure:7131: checking for $ac_func" >&5
7131 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7132   echo $ac_n "(cached) $ac_c" 1>&6
7133 else
7134   cat > conftest.$ac_ext <<EOF
7135 #line 7136 "configure"
7136 #include "confdefs.h"
7137 /* System header to define __stub macros and hopefully few prototypes,
7138     which can conflict with char $ac_func(); below.  */
7139 #include <assert.h>
7140 /* Override any gcc2 internal prototype to avoid an error.  */
7141 /* We use char because int might match the return type of a gcc2
7142     builtin and then its argument prototype would still apply.  */
7143 char $ac_func();
7144
7145 int main() {
7146
7147 /* The GNU C library defines this for functions which it implements
7148     to always fail with ENOSYS.  Some functions are actually named
7149     something starting with __ and the normal name is an alias.  */
7150 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7151 choke me
7152 #else
7153 $ac_func();
7154 #endif
7155
7156 ; return 0; }
7157 EOF
7158 if { (eval echo configure:7159: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7159   rm -rf conftest*
7160   eval "ac_cv_func_$ac_func=yes"
7161 else
7162   echo "configure: failed program was:" >&5
7163   cat conftest.$ac_ext >&5
7164   rm -rf conftest*
7165   eval "ac_cv_func_$ac_func=no"
7166 fi
7167 rm -f conftest*
7168 fi
7169
7170 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7171   echo "$ac_t""yes" 1>&6
7172     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7173   cat >> confdefs.h <<EOF
7174 #define $ac_tr_func 1
7175 EOF
7176
7177 else
7178   echo "$ac_t""no" 1>&6
7179 fi
7180 done
7181
7182   fi
7183
7184
7185   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7186 echo "configure:7187: checking for modff declaration" >&5
7187   if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
7188   echo $ac_n "(cached) $ac_c" 1>&6
7189 else
7190
7191
7192     ac_ext=C
7193 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7194 ac_cpp='$CXXCPP $CPPFLAGS'
7195 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7196 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7197 cross_compiling=$ac_cv_prog_cxx_cross
7198
7199     cat > conftest.$ac_ext <<EOF
7200 #line 7201 "configure"
7201 #include "confdefs.h"
7202 #include <math.h>
7203 int main() {
7204  modff(0, 0);
7205 ; return 0; }
7206 EOF
7207 if { (eval echo configure:7208: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7208   rm -rf conftest*
7209   glibcpp_cv_func_modff_use=yes
7210 else
7211   echo "configure: failed program was:" >&5
7212   cat conftest.$ac_ext >&5
7213   rm -rf conftest*
7214   glibcpp_cv_func_modff_use=no
7215 fi
7216 rm -f conftest*
7217     ac_ext=c
7218 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7219 ac_cpp='$CPP $CPPFLAGS'
7220 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7221 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7222 cross_compiling=$ac_cv_prog_cc_cross
7223
7224
7225 fi
7226
7227   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
7228   if test x$glibcpp_cv_func_modff_use = x"yes"; then
7229     for ac_func in modff
7230 do
7231 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7232 echo "configure:7233: checking for $ac_func" >&5
7233 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7234   echo $ac_n "(cached) $ac_c" 1>&6
7235 else
7236   cat > conftest.$ac_ext <<EOF
7237 #line 7238 "configure"
7238 #include "confdefs.h"
7239 /* System header to define __stub macros and hopefully few prototypes,
7240     which can conflict with char $ac_func(); below.  */
7241 #include <assert.h>
7242 /* Override any gcc2 internal prototype to avoid an error.  */
7243 /* We use char because int might match the return type of a gcc2
7244     builtin and then its argument prototype would still apply.  */
7245 char $ac_func();
7246
7247 int main() {
7248
7249 /* The GNU C library defines this for functions which it implements
7250     to always fail with ENOSYS.  Some functions are actually named
7251     something starting with __ and the normal name is an alias.  */
7252 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7253 choke me
7254 #else
7255 $ac_func();
7256 #endif
7257
7258 ; return 0; }
7259 EOF
7260 if { (eval echo configure:7261: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7261   rm -rf conftest*
7262   eval "ac_cv_func_$ac_func=yes"
7263 else
7264   echo "configure: failed program was:" >&5
7265   cat conftest.$ac_ext >&5
7266   rm -rf conftest*
7267   eval "ac_cv_func_$ac_func=no"
7268 fi
7269 rm -f conftest*
7270 fi
7271
7272 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7273   echo "$ac_t""yes" 1>&6
7274     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7275   cat >> confdefs.h <<EOF
7276 #define $ac_tr_func 1
7277 EOF
7278
7279 else
7280   echo "$ac_t""no" 1>&6
7281 fi
7282 done
7283
7284   fi
7285
7286
7287   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
7288 echo "configure:7289: checking for powf declaration" >&5
7289   if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
7290   echo $ac_n "(cached) $ac_c" 1>&6
7291 else
7292
7293
7294     ac_ext=C
7295 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7296 ac_cpp='$CXXCPP $CPPFLAGS'
7297 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7298 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7299 cross_compiling=$ac_cv_prog_cxx_cross
7300
7301     cat > conftest.$ac_ext <<EOF
7302 #line 7303 "configure"
7303 #include "confdefs.h"
7304 #include <math.h>
7305 int main() {
7306  powf(0, 0);
7307 ; return 0; }
7308 EOF
7309 if { (eval echo configure:7310: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7310   rm -rf conftest*
7311   glibcpp_cv_func_powf_use=yes
7312 else
7313   echo "configure: failed program was:" >&5
7314   cat conftest.$ac_ext >&5
7315   rm -rf conftest*
7316   glibcpp_cv_func_powf_use=no
7317 fi
7318 rm -f conftest*
7319     ac_ext=c
7320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7321 ac_cpp='$CPP $CPPFLAGS'
7322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7324 cross_compiling=$ac_cv_prog_cc_cross
7325
7326
7327 fi
7328
7329   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
7330   if test x$glibcpp_cv_func_powf_use = x"yes"; then
7331     for ac_func in powf
7332 do
7333 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7334 echo "configure:7335: checking for $ac_func" >&5
7335 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7336   echo $ac_n "(cached) $ac_c" 1>&6
7337 else
7338   cat > conftest.$ac_ext <<EOF
7339 #line 7340 "configure"
7340 #include "confdefs.h"
7341 /* System header to define __stub macros and hopefully few prototypes,
7342     which can conflict with char $ac_func(); below.  */
7343 #include <assert.h>
7344 /* Override any gcc2 internal prototype to avoid an error.  */
7345 /* We use char because int might match the return type of a gcc2
7346     builtin and then its argument prototype would still apply.  */
7347 char $ac_func();
7348
7349 int main() {
7350
7351 /* The GNU C library defines this for functions which it implements
7352     to always fail with ENOSYS.  Some functions are actually named
7353     something starting with __ and the normal name is an alias.  */
7354 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7355 choke me
7356 #else
7357 $ac_func();
7358 #endif
7359
7360 ; return 0; }
7361 EOF
7362 if { (eval echo configure:7363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7363   rm -rf conftest*
7364   eval "ac_cv_func_$ac_func=yes"
7365 else
7366   echo "configure: failed program was:" >&5
7367   cat conftest.$ac_ext >&5
7368   rm -rf conftest*
7369   eval "ac_cv_func_$ac_func=no"
7370 fi
7371 rm -f conftest*
7372 fi
7373
7374 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7375   echo "$ac_t""yes" 1>&6
7376     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7377   cat >> confdefs.h <<EOF
7378 #define $ac_tr_func 1
7379 EOF
7380
7381 else
7382   echo "$ac_t""no" 1>&6
7383 fi
7384 done
7385
7386   fi
7387
7388
7389   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
7390 echo "configure:7391: checking for sinf declaration" >&5
7391   if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
7392   echo $ac_n "(cached) $ac_c" 1>&6
7393 else
7394
7395
7396     ac_ext=C
7397 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7398 ac_cpp='$CXXCPP $CPPFLAGS'
7399 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7400 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7401 cross_compiling=$ac_cv_prog_cxx_cross
7402
7403     cat > conftest.$ac_ext <<EOF
7404 #line 7405 "configure"
7405 #include "confdefs.h"
7406 #include <math.h>
7407 int main() {
7408  sinf(0);
7409 ; return 0; }
7410 EOF
7411 if { (eval echo configure:7412: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7412   rm -rf conftest*
7413   glibcpp_cv_func_sinf_use=yes
7414 else
7415   echo "configure: failed program was:" >&5
7416   cat conftest.$ac_ext >&5
7417   rm -rf conftest*
7418   glibcpp_cv_func_sinf_use=no
7419 fi
7420 rm -f conftest*
7421     ac_ext=c
7422 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7423 ac_cpp='$CPP $CPPFLAGS'
7424 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7425 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7426 cross_compiling=$ac_cv_prog_cc_cross
7427
7428
7429 fi
7430
7431   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
7432   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
7433     for ac_func in sinf
7434 do
7435 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7436 echo "configure:7437: checking for $ac_func" >&5
7437 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7438   echo $ac_n "(cached) $ac_c" 1>&6
7439 else
7440   cat > conftest.$ac_ext <<EOF
7441 #line 7442 "configure"
7442 #include "confdefs.h"
7443 /* System header to define __stub macros and hopefully few prototypes,
7444     which can conflict with char $ac_func(); below.  */
7445 #include <assert.h>
7446 /* Override any gcc2 internal prototype to avoid an error.  */
7447 /* We use char because int might match the return type of a gcc2
7448     builtin and then its argument prototype would still apply.  */
7449 char $ac_func();
7450
7451 int main() {
7452
7453 /* The GNU C library defines this for functions which it implements
7454     to always fail with ENOSYS.  Some functions are actually named
7455     something starting with __ and the normal name is an alias.  */
7456 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7457 choke me
7458 #else
7459 $ac_func();
7460 #endif
7461
7462 ; return 0; }
7463 EOF
7464 if { (eval echo configure:7465: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7465   rm -rf conftest*
7466   eval "ac_cv_func_$ac_func=yes"
7467 else
7468   echo "configure: failed program was:" >&5
7469   cat conftest.$ac_ext >&5
7470   rm -rf conftest*
7471   eval "ac_cv_func_$ac_func=no"
7472 fi
7473 rm -f conftest*
7474 fi
7475
7476 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7477   echo "$ac_t""yes" 1>&6
7478     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7479   cat >> confdefs.h <<EOF
7480 #define $ac_tr_func 1
7481 EOF
7482
7483 else
7484   echo "$ac_t""no" 1>&6
7485 fi
7486 done
7487
7488   fi
7489
7490
7491   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
7492 echo "configure:7493: checking for sinhf declaration" >&5
7493   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
7494   echo $ac_n "(cached) $ac_c" 1>&6
7495 else
7496
7497
7498     ac_ext=C
7499 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7500 ac_cpp='$CXXCPP $CPPFLAGS'
7501 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7502 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7503 cross_compiling=$ac_cv_prog_cxx_cross
7504
7505     cat > conftest.$ac_ext <<EOF
7506 #line 7507 "configure"
7507 #include "confdefs.h"
7508 #include <math.h>
7509 int main() {
7510  sinhf(0);
7511 ; return 0; }
7512 EOF
7513 if { (eval echo configure:7514: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7514   rm -rf conftest*
7515   glibcpp_cv_func_sinhf_use=yes
7516 else
7517   echo "configure: failed program was:" >&5
7518   cat conftest.$ac_ext >&5
7519   rm -rf conftest*
7520   glibcpp_cv_func_sinhf_use=no
7521 fi
7522 rm -f conftest*
7523     ac_ext=c
7524 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7525 ac_cpp='$CPP $CPPFLAGS'
7526 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7527 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7528 cross_compiling=$ac_cv_prog_cc_cross
7529
7530
7531 fi
7532
7533   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
7534   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
7535     for ac_func in sinhf
7536 do
7537 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7538 echo "configure:7539: checking for $ac_func" >&5
7539 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7540   echo $ac_n "(cached) $ac_c" 1>&6
7541 else
7542   cat > conftest.$ac_ext <<EOF
7543 #line 7544 "configure"
7544 #include "confdefs.h"
7545 /* System header to define __stub macros and hopefully few prototypes,
7546     which can conflict with char $ac_func(); below.  */
7547 #include <assert.h>
7548 /* Override any gcc2 internal prototype to avoid an error.  */
7549 /* We use char because int might match the return type of a gcc2
7550     builtin and then its argument prototype would still apply.  */
7551 char $ac_func();
7552
7553 int main() {
7554
7555 /* The GNU C library defines this for functions which it implements
7556     to always fail with ENOSYS.  Some functions are actually named
7557     something starting with __ and the normal name is an alias.  */
7558 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7559 choke me
7560 #else
7561 $ac_func();
7562 #endif
7563
7564 ; return 0; }
7565 EOF
7566 if { (eval echo configure:7567: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7567   rm -rf conftest*
7568   eval "ac_cv_func_$ac_func=yes"
7569 else
7570   echo "configure: failed program was:" >&5
7571   cat conftest.$ac_ext >&5
7572   rm -rf conftest*
7573   eval "ac_cv_func_$ac_func=no"
7574 fi
7575 rm -f conftest*
7576 fi
7577
7578 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7579   echo "$ac_t""yes" 1>&6
7580     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7581   cat >> confdefs.h <<EOF
7582 #define $ac_tr_func 1
7583 EOF
7584
7585 else
7586   echo "$ac_t""no" 1>&6
7587 fi
7588 done
7589
7590   fi
7591
7592
7593   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
7594 echo "configure:7595: checking for sqrtf declaration" >&5
7595   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
7596   echo $ac_n "(cached) $ac_c" 1>&6
7597 else
7598
7599
7600     ac_ext=C
7601 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7602 ac_cpp='$CXXCPP $CPPFLAGS'
7603 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7604 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7605 cross_compiling=$ac_cv_prog_cxx_cross
7606
7607     cat > conftest.$ac_ext <<EOF
7608 #line 7609 "configure"
7609 #include "confdefs.h"
7610 #include <math.h>
7611 int main() {
7612  sqrtf(0);
7613 ; return 0; }
7614 EOF
7615 if { (eval echo configure:7616: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7616   rm -rf conftest*
7617   glibcpp_cv_func_sqrtf_use=yes
7618 else
7619   echo "configure: failed program was:" >&5
7620   cat conftest.$ac_ext >&5
7621   rm -rf conftest*
7622   glibcpp_cv_func_sqrtf_use=no
7623 fi
7624 rm -f conftest*
7625     ac_ext=c
7626 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7627 ac_cpp='$CPP $CPPFLAGS'
7628 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7629 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7630 cross_compiling=$ac_cv_prog_cc_cross
7631
7632
7633 fi
7634
7635   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
7636   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
7637     for ac_func in sqrtf
7638 do
7639 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7640 echo "configure:7641: checking for $ac_func" >&5
7641 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7642   echo $ac_n "(cached) $ac_c" 1>&6
7643 else
7644   cat > conftest.$ac_ext <<EOF
7645 #line 7646 "configure"
7646 #include "confdefs.h"
7647 /* System header to define __stub macros and hopefully few prototypes,
7648     which can conflict with char $ac_func(); below.  */
7649 #include <assert.h>
7650 /* Override any gcc2 internal prototype to avoid an error.  */
7651 /* We use char because int might match the return type of a gcc2
7652     builtin and then its argument prototype would still apply.  */
7653 char $ac_func();
7654
7655 int main() {
7656
7657 /* The GNU C library defines this for functions which it implements
7658     to always fail with ENOSYS.  Some functions are actually named
7659     something starting with __ and the normal name is an alias.  */
7660 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7661 choke me
7662 #else
7663 $ac_func();
7664 #endif
7665
7666 ; return 0; }
7667 EOF
7668 if { (eval echo configure:7669: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7669   rm -rf conftest*
7670   eval "ac_cv_func_$ac_func=yes"
7671 else
7672   echo "configure: failed program was:" >&5
7673   cat conftest.$ac_ext >&5
7674   rm -rf conftest*
7675   eval "ac_cv_func_$ac_func=no"
7676 fi
7677 rm -f conftest*
7678 fi
7679
7680 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7681   echo "$ac_t""yes" 1>&6
7682     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7683   cat >> confdefs.h <<EOF
7684 #define $ac_tr_func 1
7685 EOF
7686
7687 else
7688   echo "$ac_t""no" 1>&6
7689 fi
7690 done
7691
7692   fi
7693
7694
7695   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
7696 echo "configure:7697: checking for tanf declaration" >&5
7697   if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
7698   echo $ac_n "(cached) $ac_c" 1>&6
7699 else
7700
7701
7702     ac_ext=C
7703 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7704 ac_cpp='$CXXCPP $CPPFLAGS'
7705 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7706 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7707 cross_compiling=$ac_cv_prog_cxx_cross
7708
7709     cat > conftest.$ac_ext <<EOF
7710 #line 7711 "configure"
7711 #include "confdefs.h"
7712 #include <math.h>
7713 int main() {
7714  tanf(0);
7715 ; return 0; }
7716 EOF
7717 if { (eval echo configure:7718: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7718   rm -rf conftest*
7719   glibcpp_cv_func_tanf_use=yes
7720 else
7721   echo "configure: failed program was:" >&5
7722   cat conftest.$ac_ext >&5
7723   rm -rf conftest*
7724   glibcpp_cv_func_tanf_use=no
7725 fi
7726 rm -f conftest*
7727     ac_ext=c
7728 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7729 ac_cpp='$CPP $CPPFLAGS'
7730 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7731 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7732 cross_compiling=$ac_cv_prog_cc_cross
7733
7734
7735 fi
7736
7737   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
7738   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
7739     for ac_func in tanf
7740 do
7741 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7742 echo "configure:7743: checking for $ac_func" >&5
7743 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7744   echo $ac_n "(cached) $ac_c" 1>&6
7745 else
7746   cat > conftest.$ac_ext <<EOF
7747 #line 7748 "configure"
7748 #include "confdefs.h"
7749 /* System header to define __stub macros and hopefully few prototypes,
7750     which can conflict with char $ac_func(); below.  */
7751 #include <assert.h>
7752 /* Override any gcc2 internal prototype to avoid an error.  */
7753 /* We use char because int might match the return type of a gcc2
7754     builtin and then its argument prototype would still apply.  */
7755 char $ac_func();
7756
7757 int main() {
7758
7759 /* The GNU C library defines this for functions which it implements
7760     to always fail with ENOSYS.  Some functions are actually named
7761     something starting with __ and the normal name is an alias.  */
7762 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7763 choke me
7764 #else
7765 $ac_func();
7766 #endif
7767
7768 ; return 0; }
7769 EOF
7770 if { (eval echo configure:7771: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7771   rm -rf conftest*
7772   eval "ac_cv_func_$ac_func=yes"
7773 else
7774   echo "configure: failed program was:" >&5
7775   cat conftest.$ac_ext >&5
7776   rm -rf conftest*
7777   eval "ac_cv_func_$ac_func=no"
7778 fi
7779 rm -f conftest*
7780 fi
7781
7782 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7783   echo "$ac_t""yes" 1>&6
7784     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7785   cat >> confdefs.h <<EOF
7786 #define $ac_tr_func 1
7787 EOF
7788
7789 else
7790   echo "$ac_t""no" 1>&6
7791 fi
7792 done
7793
7794   fi
7795
7796
7797   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
7798 echo "configure:7799: checking for tanhf declaration" >&5
7799   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
7800   echo $ac_n "(cached) $ac_c" 1>&6
7801 else
7802
7803
7804     ac_ext=C
7805 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7806 ac_cpp='$CXXCPP $CPPFLAGS'
7807 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7808 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7809 cross_compiling=$ac_cv_prog_cxx_cross
7810
7811     cat > conftest.$ac_ext <<EOF
7812 #line 7813 "configure"
7813 #include "confdefs.h"
7814 #include <math.h>
7815 int main() {
7816  tanhf(0);
7817 ; return 0; }
7818 EOF
7819 if { (eval echo configure:7820: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7820   rm -rf conftest*
7821   glibcpp_cv_func_tanhf_use=yes
7822 else
7823   echo "configure: failed program was:" >&5
7824   cat conftest.$ac_ext >&5
7825   rm -rf conftest*
7826   glibcpp_cv_func_tanhf_use=no
7827 fi
7828 rm -f conftest*
7829     ac_ext=c
7830 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7831 ac_cpp='$CPP $CPPFLAGS'
7832 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7833 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7834 cross_compiling=$ac_cv_prog_cc_cross
7835
7836
7837 fi
7838
7839   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
7840   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
7841     for ac_func in tanhf
7842 do
7843 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7844 echo "configure:7845: checking for $ac_func" >&5
7845 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7846   echo $ac_n "(cached) $ac_c" 1>&6
7847 else
7848   cat > conftest.$ac_ext <<EOF
7849 #line 7850 "configure"
7850 #include "confdefs.h"
7851 /* System header to define __stub macros and hopefully few prototypes,
7852     which can conflict with char $ac_func(); below.  */
7853 #include <assert.h>
7854 /* Override any gcc2 internal prototype to avoid an error.  */
7855 /* We use char because int might match the return type of a gcc2
7856     builtin and then its argument prototype would still apply.  */
7857 char $ac_func();
7858
7859 int main() {
7860
7861 /* The GNU C library defines this for functions which it implements
7862     to always fail with ENOSYS.  Some functions are actually named
7863     something starting with __ and the normal name is an alias.  */
7864 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7865 choke me
7866 #else
7867 $ac_func();
7868 #endif
7869
7870 ; return 0; }
7871 EOF
7872 if { (eval echo configure:7873: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7873   rm -rf conftest*
7874   eval "ac_cv_func_$ac_func=yes"
7875 else
7876   echo "configure: failed program was:" >&5
7877   cat conftest.$ac_ext >&5
7878   rm -rf conftest*
7879   eval "ac_cv_func_$ac_func=no"
7880 fi
7881 rm -f conftest*
7882 fi
7883
7884 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7885   echo "$ac_t""yes" 1>&6
7886     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7887   cat >> confdefs.h <<EOF
7888 #define $ac_tr_func 1
7889 EOF
7890
7891 else
7892   echo "$ac_t""no" 1>&6
7893 fi
7894 done
7895
7896   fi
7897
7898
7899   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7900 echo "configure:7901: checking for sincosf declaration" >&5
7901   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
7902   echo $ac_n "(cached) $ac_c" 1>&6
7903 else
7904
7905
7906     ac_ext=C
7907 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7908 ac_cpp='$CXXCPP $CPPFLAGS'
7909 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7910 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7911 cross_compiling=$ac_cv_prog_cxx_cross
7912
7913     cat > conftest.$ac_ext <<EOF
7914 #line 7915 "configure"
7915 #include "confdefs.h"
7916 #include <math.h>
7917 int main() {
7918  sincosf(0, 0, 0);
7919 ; return 0; }
7920 EOF
7921 if { (eval echo configure:7922: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7922   rm -rf conftest*
7923   glibcpp_cv_func_sincosf_use=yes
7924 else
7925   echo "configure: failed program was:" >&5
7926   cat conftest.$ac_ext >&5
7927   rm -rf conftest*
7928   glibcpp_cv_func_sincosf_use=no
7929 fi
7930 rm -f conftest*
7931     ac_ext=c
7932 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7933 ac_cpp='$CPP $CPPFLAGS'
7934 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7935 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7936 cross_compiling=$ac_cv_prog_cc_cross
7937
7938
7939 fi
7940
7941   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
7942   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
7943     for ac_func in sincosf
7944 do
7945 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7946 echo "configure:7947: checking for $ac_func" >&5
7947 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7948   echo $ac_n "(cached) $ac_c" 1>&6
7949 else
7950   cat > conftest.$ac_ext <<EOF
7951 #line 7952 "configure"
7952 #include "confdefs.h"
7953 /* System header to define __stub macros and hopefully few prototypes,
7954     which can conflict with char $ac_func(); below.  */
7955 #include <assert.h>
7956 /* Override any gcc2 internal prototype to avoid an error.  */
7957 /* We use char because int might match the return type of a gcc2
7958     builtin and then its argument prototype would still apply.  */
7959 char $ac_func();
7960
7961 int main() {
7962
7963 /* The GNU C library defines this for functions which it implements
7964     to always fail with ENOSYS.  Some functions are actually named
7965     something starting with __ and the normal name is an alias.  */
7966 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7967 choke me
7968 #else
7969 $ac_func();
7970 #endif
7971
7972 ; return 0; }
7973 EOF
7974 if { (eval echo configure:7975: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7975   rm -rf conftest*
7976   eval "ac_cv_func_$ac_func=yes"
7977 else
7978   echo "configure: failed program was:" >&5
7979   cat conftest.$ac_ext >&5
7980   rm -rf conftest*
7981   eval "ac_cv_func_$ac_func=no"
7982 fi
7983 rm -f conftest*
7984 fi
7985
7986 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7987   echo "$ac_t""yes" 1>&6
7988     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7989   cat >> confdefs.h <<EOF
7990 #define $ac_tr_func 1
7991 EOF
7992
7993 else
7994   echo "$ac_t""no" 1>&6
7995 fi
7996 done
7997
7998   fi
7999
8000
8001   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
8002 echo "configure:8003: checking for finitef declaration" >&5
8003   if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
8004   echo $ac_n "(cached) $ac_c" 1>&6
8005 else
8006
8007
8008     ac_ext=C
8009 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8010 ac_cpp='$CXXCPP $CPPFLAGS'
8011 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8012 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8013 cross_compiling=$ac_cv_prog_cxx_cross
8014
8015     cat > conftest.$ac_ext <<EOF
8016 #line 8017 "configure"
8017 #include "confdefs.h"
8018 #include <math.h>
8019 int main() {
8020  finitef(0);
8021 ; return 0; }
8022 EOF
8023 if { (eval echo configure:8024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8024   rm -rf conftest*
8025   glibcpp_cv_func_finitef_use=yes
8026 else
8027   echo "configure: failed program was:" >&5
8028   cat conftest.$ac_ext >&5
8029   rm -rf conftest*
8030   glibcpp_cv_func_finitef_use=no
8031 fi
8032 rm -f conftest*
8033     ac_ext=c
8034 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8035 ac_cpp='$CPP $CPPFLAGS'
8036 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8037 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8038 cross_compiling=$ac_cv_prog_cc_cross
8039
8040
8041 fi
8042
8043   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
8044   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
8045     for ac_func in finitef
8046 do
8047 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8048 echo "configure:8049: checking for $ac_func" >&5
8049 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8050   echo $ac_n "(cached) $ac_c" 1>&6
8051 else
8052   cat > conftest.$ac_ext <<EOF
8053 #line 8054 "configure"
8054 #include "confdefs.h"
8055 /* System header to define __stub macros and hopefully few prototypes,
8056     which can conflict with char $ac_func(); below.  */
8057 #include <assert.h>
8058 /* Override any gcc2 internal prototype to avoid an error.  */
8059 /* We use char because int might match the return type of a gcc2
8060     builtin and then its argument prototype would still apply.  */
8061 char $ac_func();
8062
8063 int main() {
8064
8065 /* The GNU C library defines this for functions which it implements
8066     to always fail with ENOSYS.  Some functions are actually named
8067     something starting with __ and the normal name is an alias.  */
8068 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8069 choke me
8070 #else
8071 $ac_func();
8072 #endif
8073
8074 ; return 0; }
8075 EOF
8076 if { (eval echo configure:8077: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8077   rm -rf conftest*
8078   eval "ac_cv_func_$ac_func=yes"
8079 else
8080   echo "configure: failed program was:" >&5
8081   cat conftest.$ac_ext >&5
8082   rm -rf conftest*
8083   eval "ac_cv_func_$ac_func=no"
8084 fi
8085 rm -f conftest*
8086 fi
8087
8088 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8089   echo "$ac_t""yes" 1>&6
8090     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8091   cat >> confdefs.h <<EOF
8092 #define $ac_tr_func 1
8093 EOF
8094
8095 else
8096   echo "$ac_t""no" 1>&6
8097 fi
8098 done
8099
8100   fi
8101
8102
8103
8104   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8105 echo "configure:8106: checking for isnanl declaration" >&5
8106   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
8107   echo $ac_n "(cached) $ac_c" 1>&6
8108 else
8109
8110
8111     ac_ext=C
8112 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8113 ac_cpp='$CXXCPP $CPPFLAGS'
8114 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8115 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8116 cross_compiling=$ac_cv_prog_cxx_cross
8117
8118     cat > conftest.$ac_ext <<EOF
8119 #line 8120 "configure"
8120 #include "confdefs.h"
8121 #include <math.h>
8122 int main() {
8123  isnanl(0);
8124 ; return 0; }
8125 EOF
8126 if { (eval echo configure:8127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8127   rm -rf conftest*
8128   glibcpp_cv_func_isnanl_use=yes
8129 else
8130   echo "configure: failed program was:" >&5
8131   cat conftest.$ac_ext >&5
8132   rm -rf conftest*
8133   glibcpp_cv_func_isnanl_use=no
8134 fi
8135 rm -f conftest*
8136     ac_ext=c
8137 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8138 ac_cpp='$CPP $CPPFLAGS'
8139 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8140 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8141 cross_compiling=$ac_cv_prog_cc_cross
8142
8143
8144 fi
8145
8146   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
8147   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
8148     for ac_func in isnanl
8149 do
8150 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8151 echo "configure:8152: checking for $ac_func" >&5
8152 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8153   echo $ac_n "(cached) $ac_c" 1>&6
8154 else
8155   cat > conftest.$ac_ext <<EOF
8156 #line 8157 "configure"
8157 #include "confdefs.h"
8158 /* System header to define __stub macros and hopefully few prototypes,
8159     which can conflict with char $ac_func(); below.  */
8160 #include <assert.h>
8161 /* Override any gcc2 internal prototype to avoid an error.  */
8162 /* We use char because int might match the return type of a gcc2
8163     builtin and then its argument prototype would still apply.  */
8164 char $ac_func();
8165
8166 int main() {
8167
8168 /* The GNU C library defines this for functions which it implements
8169     to always fail with ENOSYS.  Some functions are actually named
8170     something starting with __ and the normal name is an alias.  */
8171 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8172 choke me
8173 #else
8174 $ac_func();
8175 #endif
8176
8177 ; return 0; }
8178 EOF
8179 if { (eval echo configure:8180: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8180   rm -rf conftest*
8181   eval "ac_cv_func_$ac_func=yes"
8182 else
8183   echo "configure: failed program was:" >&5
8184   cat conftest.$ac_ext >&5
8185   rm -rf conftest*
8186   eval "ac_cv_func_$ac_func=no"
8187 fi
8188 rm -f conftest*
8189 fi
8190
8191 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8192   echo "$ac_t""yes" 1>&6
8193     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8194   cat >> confdefs.h <<EOF
8195 #define $ac_tr_func 1
8196 EOF
8197
8198 else
8199   echo "$ac_t""no" 1>&6
8200 fi
8201 done
8202
8203   fi
8204
8205
8206   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8207 echo "configure:8208: checking for isinfl declaration" >&5
8208   if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
8209   echo $ac_n "(cached) $ac_c" 1>&6
8210 else
8211
8212
8213     ac_ext=C
8214 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8215 ac_cpp='$CXXCPP $CPPFLAGS'
8216 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8217 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8218 cross_compiling=$ac_cv_prog_cxx_cross
8219
8220     cat > conftest.$ac_ext <<EOF
8221 #line 8222 "configure"
8222 #include "confdefs.h"
8223 #include <math.h>
8224 int main() {
8225  isinfl(0);
8226 ; return 0; }
8227 EOF
8228 if { (eval echo configure:8229: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8229   rm -rf conftest*
8230   glibcpp_cv_func_isinfl_use=yes
8231 else
8232   echo "configure: failed program was:" >&5
8233   cat conftest.$ac_ext >&5
8234   rm -rf conftest*
8235   glibcpp_cv_func_isinfl_use=no
8236 fi
8237 rm -f conftest*
8238     ac_ext=c
8239 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8240 ac_cpp='$CPP $CPPFLAGS'
8241 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8242 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8243 cross_compiling=$ac_cv_prog_cc_cross
8244
8245
8246 fi
8247
8248   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
8249   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
8250     for ac_func in isinfl
8251 do
8252 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8253 echo "configure:8254: checking for $ac_func" >&5
8254 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8255   echo $ac_n "(cached) $ac_c" 1>&6
8256 else
8257   cat > conftest.$ac_ext <<EOF
8258 #line 8259 "configure"
8259 #include "confdefs.h"
8260 /* System header to define __stub macros and hopefully few prototypes,
8261     which can conflict with char $ac_func(); below.  */
8262 #include <assert.h>
8263 /* Override any gcc2 internal prototype to avoid an error.  */
8264 /* We use char because int might match the return type of a gcc2
8265     builtin and then its argument prototype would still apply.  */
8266 char $ac_func();
8267
8268 int main() {
8269
8270 /* The GNU C library defines this for functions which it implements
8271     to always fail with ENOSYS.  Some functions are actually named
8272     something starting with __ and the normal name is an alias.  */
8273 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8274 choke me
8275 #else
8276 $ac_func();
8277 #endif
8278
8279 ; return 0; }
8280 EOF
8281 if { (eval echo configure:8282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8282   rm -rf conftest*
8283   eval "ac_cv_func_$ac_func=yes"
8284 else
8285   echo "configure: failed program was:" >&5
8286   cat conftest.$ac_ext >&5
8287   rm -rf conftest*
8288   eval "ac_cv_func_$ac_func=no"
8289 fi
8290 rm -f conftest*
8291 fi
8292
8293 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8294   echo "$ac_t""yes" 1>&6
8295     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8296   cat >> confdefs.h <<EOF
8297 #define $ac_tr_func 1
8298 EOF
8299
8300 else
8301   echo "$ac_t""no" 1>&6
8302 fi
8303 done
8304
8305   fi
8306
8307
8308   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8309 echo "configure:8310: checking for copysignl declaration" >&5
8310   if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
8311   echo $ac_n "(cached) $ac_c" 1>&6
8312 else
8313
8314
8315     ac_ext=C
8316 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8317 ac_cpp='$CXXCPP $CPPFLAGS'
8318 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8319 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8320 cross_compiling=$ac_cv_prog_cxx_cross
8321
8322     cat > conftest.$ac_ext <<EOF
8323 #line 8324 "configure"
8324 #include "confdefs.h"
8325 #include <math.h>
8326 int main() {
8327  copysignl(0, 0);
8328 ; return 0; }
8329 EOF
8330 if { (eval echo configure:8331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8331   rm -rf conftest*
8332   glibcpp_cv_func_copysignl_use=yes
8333 else
8334   echo "configure: failed program was:" >&5
8335   cat conftest.$ac_ext >&5
8336   rm -rf conftest*
8337   glibcpp_cv_func_copysignl_use=no
8338 fi
8339 rm -f conftest*
8340     ac_ext=c
8341 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8342 ac_cpp='$CPP $CPPFLAGS'
8343 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8344 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8345 cross_compiling=$ac_cv_prog_cc_cross
8346
8347
8348 fi
8349
8350   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
8351   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
8352     for ac_func in copysignl
8353 do
8354 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8355 echo "configure:8356: checking for $ac_func" >&5
8356 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8357   echo $ac_n "(cached) $ac_c" 1>&6
8358 else
8359   cat > conftest.$ac_ext <<EOF
8360 #line 8361 "configure"
8361 #include "confdefs.h"
8362 /* System header to define __stub macros and hopefully few prototypes,
8363     which can conflict with char $ac_func(); below.  */
8364 #include <assert.h>
8365 /* Override any gcc2 internal prototype to avoid an error.  */
8366 /* We use char because int might match the return type of a gcc2
8367     builtin and then its argument prototype would still apply.  */
8368 char $ac_func();
8369
8370 int main() {
8371
8372 /* The GNU C library defines this for functions which it implements
8373     to always fail with ENOSYS.  Some functions are actually named
8374     something starting with __ and the normal name is an alias.  */
8375 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8376 choke me
8377 #else
8378 $ac_func();
8379 #endif
8380
8381 ; return 0; }
8382 EOF
8383 if { (eval echo configure:8384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8384   rm -rf conftest*
8385   eval "ac_cv_func_$ac_func=yes"
8386 else
8387   echo "configure: failed program was:" >&5
8388   cat conftest.$ac_ext >&5
8389   rm -rf conftest*
8390   eval "ac_cv_func_$ac_func=no"
8391 fi
8392 rm -f conftest*
8393 fi
8394
8395 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8396   echo "$ac_t""yes" 1>&6
8397     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8398   cat >> confdefs.h <<EOF
8399 #define $ac_tr_func 1
8400 EOF
8401
8402 else
8403   echo "$ac_t""no" 1>&6
8404 fi
8405 done
8406
8407   fi
8408
8409
8410   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8411 echo "configure:8412: checking for acosl declaration" >&5
8412   if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
8413   echo $ac_n "(cached) $ac_c" 1>&6
8414 else
8415
8416
8417     ac_ext=C
8418 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8419 ac_cpp='$CXXCPP $CPPFLAGS'
8420 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8421 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8422 cross_compiling=$ac_cv_prog_cxx_cross
8423
8424     cat > conftest.$ac_ext <<EOF
8425 #line 8426 "configure"
8426 #include "confdefs.h"
8427 #include <math.h>
8428 int main() {
8429  acosl(0);
8430 ; return 0; }
8431 EOF
8432 if { (eval echo configure:8433: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8433   rm -rf conftest*
8434   glibcpp_cv_func_acosl_use=yes
8435 else
8436   echo "configure: failed program was:" >&5
8437   cat conftest.$ac_ext >&5
8438   rm -rf conftest*
8439   glibcpp_cv_func_acosl_use=no
8440 fi
8441 rm -f conftest*
8442     ac_ext=c
8443 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8444 ac_cpp='$CPP $CPPFLAGS'
8445 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8446 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8447 cross_compiling=$ac_cv_prog_cc_cross
8448
8449
8450 fi
8451
8452   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
8453   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
8454     for ac_func in acosl
8455 do
8456 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8457 echo "configure:8458: checking for $ac_func" >&5
8458 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8459   echo $ac_n "(cached) $ac_c" 1>&6
8460 else
8461   cat > conftest.$ac_ext <<EOF
8462 #line 8463 "configure"
8463 #include "confdefs.h"
8464 /* System header to define __stub macros and hopefully few prototypes,
8465     which can conflict with char $ac_func(); below.  */
8466 #include <assert.h>
8467 /* Override any gcc2 internal prototype to avoid an error.  */
8468 /* We use char because int might match the return type of a gcc2
8469     builtin and then its argument prototype would still apply.  */
8470 char $ac_func();
8471
8472 int main() {
8473
8474 /* The GNU C library defines this for functions which it implements
8475     to always fail with ENOSYS.  Some functions are actually named
8476     something starting with __ and the normal name is an alias.  */
8477 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8478 choke me
8479 #else
8480 $ac_func();
8481 #endif
8482
8483 ; return 0; }
8484 EOF
8485 if { (eval echo configure:8486: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8486   rm -rf conftest*
8487   eval "ac_cv_func_$ac_func=yes"
8488 else
8489   echo "configure: failed program was:" >&5
8490   cat conftest.$ac_ext >&5
8491   rm -rf conftest*
8492   eval "ac_cv_func_$ac_func=no"
8493 fi
8494 rm -f conftest*
8495 fi
8496
8497 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8498   echo "$ac_t""yes" 1>&6
8499     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8500   cat >> confdefs.h <<EOF
8501 #define $ac_tr_func 1
8502 EOF
8503
8504 else
8505   echo "$ac_t""no" 1>&6
8506 fi
8507 done
8508
8509   fi
8510
8511
8512   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8513 echo "configure:8514: checking for asinl declaration" >&5
8514   if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
8515   echo $ac_n "(cached) $ac_c" 1>&6
8516 else
8517
8518
8519     ac_ext=C
8520 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8521 ac_cpp='$CXXCPP $CPPFLAGS'
8522 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8523 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8524 cross_compiling=$ac_cv_prog_cxx_cross
8525
8526     cat > conftest.$ac_ext <<EOF
8527 #line 8528 "configure"
8528 #include "confdefs.h"
8529 #include <math.h>
8530 int main() {
8531  asinl(0);
8532 ; return 0; }
8533 EOF
8534 if { (eval echo configure:8535: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8535   rm -rf conftest*
8536   glibcpp_cv_func_asinl_use=yes
8537 else
8538   echo "configure: failed program was:" >&5
8539   cat conftest.$ac_ext >&5
8540   rm -rf conftest*
8541   glibcpp_cv_func_asinl_use=no
8542 fi
8543 rm -f conftest*
8544     ac_ext=c
8545 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8546 ac_cpp='$CPP $CPPFLAGS'
8547 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8548 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8549 cross_compiling=$ac_cv_prog_cc_cross
8550
8551
8552 fi
8553
8554   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
8555   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
8556     for ac_func in asinl
8557 do
8558 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8559 echo "configure:8560: checking for $ac_func" >&5
8560 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8561   echo $ac_n "(cached) $ac_c" 1>&6
8562 else
8563   cat > conftest.$ac_ext <<EOF
8564 #line 8565 "configure"
8565 #include "confdefs.h"
8566 /* System header to define __stub macros and hopefully few prototypes,
8567     which can conflict with char $ac_func(); below.  */
8568 #include <assert.h>
8569 /* Override any gcc2 internal prototype to avoid an error.  */
8570 /* We use char because int might match the return type of a gcc2
8571     builtin and then its argument prototype would still apply.  */
8572 char $ac_func();
8573
8574 int main() {
8575
8576 /* The GNU C library defines this for functions which it implements
8577     to always fail with ENOSYS.  Some functions are actually named
8578     something starting with __ and the normal name is an alias.  */
8579 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8580 choke me
8581 #else
8582 $ac_func();
8583 #endif
8584
8585 ; return 0; }
8586 EOF
8587 if { (eval echo configure:8588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8588   rm -rf conftest*
8589   eval "ac_cv_func_$ac_func=yes"
8590 else
8591   echo "configure: failed program was:" >&5
8592   cat conftest.$ac_ext >&5
8593   rm -rf conftest*
8594   eval "ac_cv_func_$ac_func=no"
8595 fi
8596 rm -f conftest*
8597 fi
8598
8599 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8600   echo "$ac_t""yes" 1>&6
8601     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8602   cat >> confdefs.h <<EOF
8603 #define $ac_tr_func 1
8604 EOF
8605
8606 else
8607   echo "$ac_t""no" 1>&6
8608 fi
8609 done
8610
8611   fi
8612
8613
8614   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8615 echo "configure:8616: checking for atanl declaration" >&5
8616   if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
8617   echo $ac_n "(cached) $ac_c" 1>&6
8618 else
8619
8620
8621     ac_ext=C
8622 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8623 ac_cpp='$CXXCPP $CPPFLAGS'
8624 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8625 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8626 cross_compiling=$ac_cv_prog_cxx_cross
8627
8628     cat > conftest.$ac_ext <<EOF
8629 #line 8630 "configure"
8630 #include "confdefs.h"
8631 #include <math.h>
8632 int main() {
8633  atanl(0);
8634 ; return 0; }
8635 EOF
8636 if { (eval echo configure:8637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8637   rm -rf conftest*
8638   glibcpp_cv_func_atanl_use=yes
8639 else
8640   echo "configure: failed program was:" >&5
8641   cat conftest.$ac_ext >&5
8642   rm -rf conftest*
8643   glibcpp_cv_func_atanl_use=no
8644 fi
8645 rm -f conftest*
8646     ac_ext=c
8647 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8648 ac_cpp='$CPP $CPPFLAGS'
8649 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8650 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8651 cross_compiling=$ac_cv_prog_cc_cross
8652
8653
8654 fi
8655
8656   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
8657   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
8658     for ac_func in atanl
8659 do
8660 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8661 echo "configure:8662: checking for $ac_func" >&5
8662 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8663   echo $ac_n "(cached) $ac_c" 1>&6
8664 else
8665   cat > conftest.$ac_ext <<EOF
8666 #line 8667 "configure"
8667 #include "confdefs.h"
8668 /* System header to define __stub macros and hopefully few prototypes,
8669     which can conflict with char $ac_func(); below.  */
8670 #include <assert.h>
8671 /* Override any gcc2 internal prototype to avoid an error.  */
8672 /* We use char because int might match the return type of a gcc2
8673     builtin and then its argument prototype would still apply.  */
8674 char $ac_func();
8675
8676 int main() {
8677
8678 /* The GNU C library defines this for functions which it implements
8679     to always fail with ENOSYS.  Some functions are actually named
8680     something starting with __ and the normal name is an alias.  */
8681 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8682 choke me
8683 #else
8684 $ac_func();
8685 #endif
8686
8687 ; return 0; }
8688 EOF
8689 if { (eval echo configure:8690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8690   rm -rf conftest*
8691   eval "ac_cv_func_$ac_func=yes"
8692 else
8693   echo "configure: failed program was:" >&5
8694   cat conftest.$ac_ext >&5
8695   rm -rf conftest*
8696   eval "ac_cv_func_$ac_func=no"
8697 fi
8698 rm -f conftest*
8699 fi
8700
8701 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8702   echo "$ac_t""yes" 1>&6
8703     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8704   cat >> confdefs.h <<EOF
8705 #define $ac_tr_func 1
8706 EOF
8707
8708 else
8709   echo "$ac_t""no" 1>&6
8710 fi
8711 done
8712
8713   fi
8714
8715
8716   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8717 echo "configure:8718: checking for atan2l declaration" >&5
8718   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
8719   echo $ac_n "(cached) $ac_c" 1>&6
8720 else
8721
8722
8723     ac_ext=C
8724 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8725 ac_cpp='$CXXCPP $CPPFLAGS'
8726 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8727 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8728 cross_compiling=$ac_cv_prog_cxx_cross
8729
8730     cat > conftest.$ac_ext <<EOF
8731 #line 8732 "configure"
8732 #include "confdefs.h"
8733 #include <math.h>
8734 int main() {
8735  atan2l(0, 0);
8736 ; return 0; }
8737 EOF
8738 if { (eval echo configure:8739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8739   rm -rf conftest*
8740   glibcpp_cv_func_atan2l_use=yes
8741 else
8742   echo "configure: failed program was:" >&5
8743   cat conftest.$ac_ext >&5
8744   rm -rf conftest*
8745   glibcpp_cv_func_atan2l_use=no
8746 fi
8747 rm -f conftest*
8748     ac_ext=c
8749 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8750 ac_cpp='$CPP $CPPFLAGS'
8751 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8752 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8753 cross_compiling=$ac_cv_prog_cc_cross
8754
8755
8756 fi
8757
8758   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
8759   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
8760     for ac_func in atan2l
8761 do
8762 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8763 echo "configure:8764: checking for $ac_func" >&5
8764 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8765   echo $ac_n "(cached) $ac_c" 1>&6
8766 else
8767   cat > conftest.$ac_ext <<EOF
8768 #line 8769 "configure"
8769 #include "confdefs.h"
8770 /* System header to define __stub macros and hopefully few prototypes,
8771     which can conflict with char $ac_func(); below.  */
8772 #include <assert.h>
8773 /* Override any gcc2 internal prototype to avoid an error.  */
8774 /* We use char because int might match the return type of a gcc2
8775     builtin and then its argument prototype would still apply.  */
8776 char $ac_func();
8777
8778 int main() {
8779
8780 /* The GNU C library defines this for functions which it implements
8781     to always fail with ENOSYS.  Some functions are actually named
8782     something starting with __ and the normal name is an alias.  */
8783 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8784 choke me
8785 #else
8786 $ac_func();
8787 #endif
8788
8789 ; return 0; }
8790 EOF
8791 if { (eval echo configure:8792: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8792   rm -rf conftest*
8793   eval "ac_cv_func_$ac_func=yes"
8794 else
8795   echo "configure: failed program was:" >&5
8796   cat conftest.$ac_ext >&5
8797   rm -rf conftest*
8798   eval "ac_cv_func_$ac_func=no"
8799 fi
8800 rm -f conftest*
8801 fi
8802
8803 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8804   echo "$ac_t""yes" 1>&6
8805     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8806   cat >> confdefs.h <<EOF
8807 #define $ac_tr_func 1
8808 EOF
8809
8810 else
8811   echo "$ac_t""no" 1>&6
8812 fi
8813 done
8814
8815   fi
8816
8817
8818   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8819 echo "configure:8820: checking for ceill declaration" >&5
8820   if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
8821   echo $ac_n "(cached) $ac_c" 1>&6
8822 else
8823
8824
8825     ac_ext=C
8826 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8827 ac_cpp='$CXXCPP $CPPFLAGS'
8828 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8829 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8830 cross_compiling=$ac_cv_prog_cxx_cross
8831
8832     cat > conftest.$ac_ext <<EOF
8833 #line 8834 "configure"
8834 #include "confdefs.h"
8835 #include <math.h>
8836 int main() {
8837  ceill(0);
8838 ; return 0; }
8839 EOF
8840 if { (eval echo configure:8841: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8841   rm -rf conftest*
8842   glibcpp_cv_func_ceill_use=yes
8843 else
8844   echo "configure: failed program was:" >&5
8845   cat conftest.$ac_ext >&5
8846   rm -rf conftest*
8847   glibcpp_cv_func_ceill_use=no
8848 fi
8849 rm -f conftest*
8850     ac_ext=c
8851 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8852 ac_cpp='$CPP $CPPFLAGS'
8853 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8854 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8855 cross_compiling=$ac_cv_prog_cc_cross
8856
8857
8858 fi
8859
8860   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
8861   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
8862     for ac_func in ceill
8863 do
8864 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8865 echo "configure:8866: checking for $ac_func" >&5
8866 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8867   echo $ac_n "(cached) $ac_c" 1>&6
8868 else
8869   cat > conftest.$ac_ext <<EOF
8870 #line 8871 "configure"
8871 #include "confdefs.h"
8872 /* System header to define __stub macros and hopefully few prototypes,
8873     which can conflict with char $ac_func(); below.  */
8874 #include <assert.h>
8875 /* Override any gcc2 internal prototype to avoid an error.  */
8876 /* We use char because int might match the return type of a gcc2
8877     builtin and then its argument prototype would still apply.  */
8878 char $ac_func();
8879
8880 int main() {
8881
8882 /* The GNU C library defines this for functions which it implements
8883     to always fail with ENOSYS.  Some functions are actually named
8884     something starting with __ and the normal name is an alias.  */
8885 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8886 choke me
8887 #else
8888 $ac_func();
8889 #endif
8890
8891 ; return 0; }
8892 EOF
8893 if { (eval echo configure:8894: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8894   rm -rf conftest*
8895   eval "ac_cv_func_$ac_func=yes"
8896 else
8897   echo "configure: failed program was:" >&5
8898   cat conftest.$ac_ext >&5
8899   rm -rf conftest*
8900   eval "ac_cv_func_$ac_func=no"
8901 fi
8902 rm -f conftest*
8903 fi
8904
8905 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8906   echo "$ac_t""yes" 1>&6
8907     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8908   cat >> confdefs.h <<EOF
8909 #define $ac_tr_func 1
8910 EOF
8911
8912 else
8913   echo "$ac_t""no" 1>&6
8914 fi
8915 done
8916
8917   fi
8918
8919
8920   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8921 echo "configure:8922: checking for cosl declaration" >&5
8922   if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
8923   echo $ac_n "(cached) $ac_c" 1>&6
8924 else
8925
8926
8927     ac_ext=C
8928 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8929 ac_cpp='$CXXCPP $CPPFLAGS'
8930 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8931 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8932 cross_compiling=$ac_cv_prog_cxx_cross
8933
8934     cat > conftest.$ac_ext <<EOF
8935 #line 8936 "configure"
8936 #include "confdefs.h"
8937 #include <math.h>
8938 int main() {
8939  cosl(0);
8940 ; return 0; }
8941 EOF
8942 if { (eval echo configure:8943: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8943   rm -rf conftest*
8944   glibcpp_cv_func_cosl_use=yes
8945 else
8946   echo "configure: failed program was:" >&5
8947   cat conftest.$ac_ext >&5
8948   rm -rf conftest*
8949   glibcpp_cv_func_cosl_use=no
8950 fi
8951 rm -f conftest*
8952     ac_ext=c
8953 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8954 ac_cpp='$CPP $CPPFLAGS'
8955 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8956 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8957 cross_compiling=$ac_cv_prog_cc_cross
8958
8959
8960 fi
8961
8962   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
8963   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
8964     for ac_func in cosl
8965 do
8966 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8967 echo "configure:8968: checking for $ac_func" >&5
8968 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8969   echo $ac_n "(cached) $ac_c" 1>&6
8970 else
8971   cat > conftest.$ac_ext <<EOF
8972 #line 8973 "configure"
8973 #include "confdefs.h"
8974 /* System header to define __stub macros and hopefully few prototypes,
8975     which can conflict with char $ac_func(); below.  */
8976 #include <assert.h>
8977 /* Override any gcc2 internal prototype to avoid an error.  */
8978 /* We use char because int might match the return type of a gcc2
8979     builtin and then its argument prototype would still apply.  */
8980 char $ac_func();
8981
8982 int main() {
8983
8984 /* The GNU C library defines this for functions which it implements
8985     to always fail with ENOSYS.  Some functions are actually named
8986     something starting with __ and the normal name is an alias.  */
8987 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8988 choke me
8989 #else
8990 $ac_func();
8991 #endif
8992
8993 ; return 0; }
8994 EOF
8995 if { (eval echo configure:8996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8996   rm -rf conftest*
8997   eval "ac_cv_func_$ac_func=yes"
8998 else
8999   echo "configure: failed program was:" >&5
9000   cat conftest.$ac_ext >&5
9001   rm -rf conftest*
9002   eval "ac_cv_func_$ac_func=no"
9003 fi
9004 rm -f conftest*
9005 fi
9006
9007 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9008   echo "$ac_t""yes" 1>&6
9009     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9010   cat >> confdefs.h <<EOF
9011 #define $ac_tr_func 1
9012 EOF
9013
9014 else
9015   echo "$ac_t""no" 1>&6
9016 fi
9017 done
9018
9019   fi
9020
9021
9022   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
9023 echo "configure:9024: checking for coshl declaration" >&5
9024   if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
9025   echo $ac_n "(cached) $ac_c" 1>&6
9026 else
9027
9028
9029     ac_ext=C
9030 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9031 ac_cpp='$CXXCPP $CPPFLAGS'
9032 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9033 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9034 cross_compiling=$ac_cv_prog_cxx_cross
9035
9036     cat > conftest.$ac_ext <<EOF
9037 #line 9038 "configure"
9038 #include "confdefs.h"
9039 #include <math.h>
9040 int main() {
9041  coshl(0);
9042 ; return 0; }
9043 EOF
9044 if { (eval echo configure:9045: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9045   rm -rf conftest*
9046   glibcpp_cv_func_coshl_use=yes
9047 else
9048   echo "configure: failed program was:" >&5
9049   cat conftest.$ac_ext >&5
9050   rm -rf conftest*
9051   glibcpp_cv_func_coshl_use=no
9052 fi
9053 rm -f conftest*
9054     ac_ext=c
9055 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9056 ac_cpp='$CPP $CPPFLAGS'
9057 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9058 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9059 cross_compiling=$ac_cv_prog_cc_cross
9060
9061
9062 fi
9063
9064   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
9065   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
9066     for ac_func in coshl
9067 do
9068 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9069 echo "configure:9070: checking for $ac_func" >&5
9070 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9071   echo $ac_n "(cached) $ac_c" 1>&6
9072 else
9073   cat > conftest.$ac_ext <<EOF
9074 #line 9075 "configure"
9075 #include "confdefs.h"
9076 /* System header to define __stub macros and hopefully few prototypes,
9077     which can conflict with char $ac_func(); below.  */
9078 #include <assert.h>
9079 /* Override any gcc2 internal prototype to avoid an error.  */
9080 /* We use char because int might match the return type of a gcc2
9081     builtin and then its argument prototype would still apply.  */
9082 char $ac_func();
9083
9084 int main() {
9085
9086 /* The GNU C library defines this for functions which it implements
9087     to always fail with ENOSYS.  Some functions are actually named
9088     something starting with __ and the normal name is an alias.  */
9089 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9090 choke me
9091 #else
9092 $ac_func();
9093 #endif
9094
9095 ; return 0; }
9096 EOF
9097 if { (eval echo configure:9098: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9098   rm -rf conftest*
9099   eval "ac_cv_func_$ac_func=yes"
9100 else
9101   echo "configure: failed program was:" >&5
9102   cat conftest.$ac_ext >&5
9103   rm -rf conftest*
9104   eval "ac_cv_func_$ac_func=no"
9105 fi
9106 rm -f conftest*
9107 fi
9108
9109 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9110   echo "$ac_t""yes" 1>&6
9111     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9112   cat >> confdefs.h <<EOF
9113 #define $ac_tr_func 1
9114 EOF
9115
9116 else
9117   echo "$ac_t""no" 1>&6
9118 fi
9119 done
9120
9121   fi
9122
9123
9124   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
9125 echo "configure:9126: checking for expl declaration" >&5
9126   if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
9127   echo $ac_n "(cached) $ac_c" 1>&6
9128 else
9129
9130
9131     ac_ext=C
9132 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9133 ac_cpp='$CXXCPP $CPPFLAGS'
9134 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9135 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9136 cross_compiling=$ac_cv_prog_cxx_cross
9137
9138     cat > conftest.$ac_ext <<EOF
9139 #line 9140 "configure"
9140 #include "confdefs.h"
9141 #include <math.h>
9142 int main() {
9143  expl(0);
9144 ; return 0; }
9145 EOF
9146 if { (eval echo configure:9147: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9147   rm -rf conftest*
9148   glibcpp_cv_func_expl_use=yes
9149 else
9150   echo "configure: failed program was:" >&5
9151   cat conftest.$ac_ext >&5
9152   rm -rf conftest*
9153   glibcpp_cv_func_expl_use=no
9154 fi
9155 rm -f conftest*
9156     ac_ext=c
9157 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9158 ac_cpp='$CPP $CPPFLAGS'
9159 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9160 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9161 cross_compiling=$ac_cv_prog_cc_cross
9162
9163
9164 fi
9165
9166   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
9167   if test x$glibcpp_cv_func_expl_use = x"yes"; then
9168     for ac_func in expl
9169 do
9170 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9171 echo "configure:9172: checking for $ac_func" >&5
9172 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9173   echo $ac_n "(cached) $ac_c" 1>&6
9174 else
9175   cat > conftest.$ac_ext <<EOF
9176 #line 9177 "configure"
9177 #include "confdefs.h"
9178 /* System header to define __stub macros and hopefully few prototypes,
9179     which can conflict with char $ac_func(); below.  */
9180 #include <assert.h>
9181 /* Override any gcc2 internal prototype to avoid an error.  */
9182 /* We use char because int might match the return type of a gcc2
9183     builtin and then its argument prototype would still apply.  */
9184 char $ac_func();
9185
9186 int main() {
9187
9188 /* The GNU C library defines this for functions which it implements
9189     to always fail with ENOSYS.  Some functions are actually named
9190     something starting with __ and the normal name is an alias.  */
9191 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9192 choke me
9193 #else
9194 $ac_func();
9195 #endif
9196
9197 ; return 0; }
9198 EOF
9199 if { (eval echo configure:9200: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9200   rm -rf conftest*
9201   eval "ac_cv_func_$ac_func=yes"
9202 else
9203   echo "configure: failed program was:" >&5
9204   cat conftest.$ac_ext >&5
9205   rm -rf conftest*
9206   eval "ac_cv_func_$ac_func=no"
9207 fi
9208 rm -f conftest*
9209 fi
9210
9211 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9212   echo "$ac_t""yes" 1>&6
9213     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9214   cat >> confdefs.h <<EOF
9215 #define $ac_tr_func 1
9216 EOF
9217
9218 else
9219   echo "$ac_t""no" 1>&6
9220 fi
9221 done
9222
9223   fi
9224
9225
9226   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9227 echo "configure:9228: checking for fabsl declaration" >&5
9228   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
9229   echo $ac_n "(cached) $ac_c" 1>&6
9230 else
9231
9232
9233     ac_ext=C
9234 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9235 ac_cpp='$CXXCPP $CPPFLAGS'
9236 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9237 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9238 cross_compiling=$ac_cv_prog_cxx_cross
9239
9240     cat > conftest.$ac_ext <<EOF
9241 #line 9242 "configure"
9242 #include "confdefs.h"
9243 #include <math.h>
9244 int main() {
9245  fabsl(0);
9246 ; return 0; }
9247 EOF
9248 if { (eval echo configure:9249: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9249   rm -rf conftest*
9250   glibcpp_cv_func_fabsl_use=yes
9251 else
9252   echo "configure: failed program was:" >&5
9253   cat conftest.$ac_ext >&5
9254   rm -rf conftest*
9255   glibcpp_cv_func_fabsl_use=no
9256 fi
9257 rm -f conftest*
9258     ac_ext=c
9259 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9260 ac_cpp='$CPP $CPPFLAGS'
9261 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9262 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9263 cross_compiling=$ac_cv_prog_cc_cross
9264
9265
9266 fi
9267
9268   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
9269   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
9270     for ac_func in fabsl
9271 do
9272 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9273 echo "configure:9274: checking for $ac_func" >&5
9274 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9275   echo $ac_n "(cached) $ac_c" 1>&6
9276 else
9277   cat > conftest.$ac_ext <<EOF
9278 #line 9279 "configure"
9279 #include "confdefs.h"
9280 /* System header to define __stub macros and hopefully few prototypes,
9281     which can conflict with char $ac_func(); below.  */
9282 #include <assert.h>
9283 /* Override any gcc2 internal prototype to avoid an error.  */
9284 /* We use char because int might match the return type of a gcc2
9285     builtin and then its argument prototype would still apply.  */
9286 char $ac_func();
9287
9288 int main() {
9289
9290 /* The GNU C library defines this for functions which it implements
9291     to always fail with ENOSYS.  Some functions are actually named
9292     something starting with __ and the normal name is an alias.  */
9293 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9294 choke me
9295 #else
9296 $ac_func();
9297 #endif
9298
9299 ; return 0; }
9300 EOF
9301 if { (eval echo configure:9302: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9302   rm -rf conftest*
9303   eval "ac_cv_func_$ac_func=yes"
9304 else
9305   echo "configure: failed program was:" >&5
9306   cat conftest.$ac_ext >&5
9307   rm -rf conftest*
9308   eval "ac_cv_func_$ac_func=no"
9309 fi
9310 rm -f conftest*
9311 fi
9312
9313 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9314   echo "$ac_t""yes" 1>&6
9315     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9316   cat >> confdefs.h <<EOF
9317 #define $ac_tr_func 1
9318 EOF
9319
9320 else
9321   echo "$ac_t""no" 1>&6
9322 fi
9323 done
9324
9325   fi
9326
9327
9328   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9329 echo "configure:9330: checking for floorl declaration" >&5
9330   if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
9331   echo $ac_n "(cached) $ac_c" 1>&6
9332 else
9333
9334
9335     ac_ext=C
9336 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9337 ac_cpp='$CXXCPP $CPPFLAGS'
9338 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9339 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9340 cross_compiling=$ac_cv_prog_cxx_cross
9341
9342     cat > conftest.$ac_ext <<EOF
9343 #line 9344 "configure"
9344 #include "confdefs.h"
9345 #include <math.h>
9346 int main() {
9347  floorl(0);
9348 ; return 0; }
9349 EOF
9350 if { (eval echo configure:9351: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9351   rm -rf conftest*
9352   glibcpp_cv_func_floorl_use=yes
9353 else
9354   echo "configure: failed program was:" >&5
9355   cat conftest.$ac_ext >&5
9356   rm -rf conftest*
9357   glibcpp_cv_func_floorl_use=no
9358 fi
9359 rm -f conftest*
9360     ac_ext=c
9361 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9362 ac_cpp='$CPP $CPPFLAGS'
9363 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9364 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9365 cross_compiling=$ac_cv_prog_cc_cross
9366
9367
9368 fi
9369
9370   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
9371   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
9372     for ac_func in floorl
9373 do
9374 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9375 echo "configure:9376: checking for $ac_func" >&5
9376 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9377   echo $ac_n "(cached) $ac_c" 1>&6
9378 else
9379   cat > conftest.$ac_ext <<EOF
9380 #line 9381 "configure"
9381 #include "confdefs.h"
9382 /* System header to define __stub macros and hopefully few prototypes,
9383     which can conflict with char $ac_func(); below.  */
9384 #include <assert.h>
9385 /* Override any gcc2 internal prototype to avoid an error.  */
9386 /* We use char because int might match the return type of a gcc2
9387     builtin and then its argument prototype would still apply.  */
9388 char $ac_func();
9389
9390 int main() {
9391
9392 /* The GNU C library defines this for functions which it implements
9393     to always fail with ENOSYS.  Some functions are actually named
9394     something starting with __ and the normal name is an alias.  */
9395 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9396 choke me
9397 #else
9398 $ac_func();
9399 #endif
9400
9401 ; return 0; }
9402 EOF
9403 if { (eval echo configure:9404: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9404   rm -rf conftest*
9405   eval "ac_cv_func_$ac_func=yes"
9406 else
9407   echo "configure: failed program was:" >&5
9408   cat conftest.$ac_ext >&5
9409   rm -rf conftest*
9410   eval "ac_cv_func_$ac_func=no"
9411 fi
9412 rm -f conftest*
9413 fi
9414
9415 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9416   echo "$ac_t""yes" 1>&6
9417     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9418   cat >> confdefs.h <<EOF
9419 #define $ac_tr_func 1
9420 EOF
9421
9422 else
9423   echo "$ac_t""no" 1>&6
9424 fi
9425 done
9426
9427   fi
9428
9429
9430   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9431 echo "configure:9432: checking for fmodl declaration" >&5
9432   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
9433   echo $ac_n "(cached) $ac_c" 1>&6
9434 else
9435
9436
9437     ac_ext=C
9438 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9439 ac_cpp='$CXXCPP $CPPFLAGS'
9440 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9441 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9442 cross_compiling=$ac_cv_prog_cxx_cross
9443
9444     cat > conftest.$ac_ext <<EOF
9445 #line 9446 "configure"
9446 #include "confdefs.h"
9447 #include <math.h>
9448 int main() {
9449  fmodl(0, 0);
9450 ; return 0; }
9451 EOF
9452 if { (eval echo configure:9453: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9453   rm -rf conftest*
9454   glibcpp_cv_func_fmodl_use=yes
9455 else
9456   echo "configure: failed program was:" >&5
9457   cat conftest.$ac_ext >&5
9458   rm -rf conftest*
9459   glibcpp_cv_func_fmodl_use=no
9460 fi
9461 rm -f conftest*
9462     ac_ext=c
9463 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9464 ac_cpp='$CPP $CPPFLAGS'
9465 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9466 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9467 cross_compiling=$ac_cv_prog_cc_cross
9468
9469
9470 fi
9471
9472   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
9473   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
9474     for ac_func in fmodl
9475 do
9476 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9477 echo "configure:9478: checking for $ac_func" >&5
9478 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9479   echo $ac_n "(cached) $ac_c" 1>&6
9480 else
9481   cat > conftest.$ac_ext <<EOF
9482 #line 9483 "configure"
9483 #include "confdefs.h"
9484 /* System header to define __stub macros and hopefully few prototypes,
9485     which can conflict with char $ac_func(); below.  */
9486 #include <assert.h>
9487 /* Override any gcc2 internal prototype to avoid an error.  */
9488 /* We use char because int might match the return type of a gcc2
9489     builtin and then its argument prototype would still apply.  */
9490 char $ac_func();
9491
9492 int main() {
9493
9494 /* The GNU C library defines this for functions which it implements
9495     to always fail with ENOSYS.  Some functions are actually named
9496     something starting with __ and the normal name is an alias.  */
9497 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9498 choke me
9499 #else
9500 $ac_func();
9501 #endif
9502
9503 ; return 0; }
9504 EOF
9505 if { (eval echo configure:9506: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9506   rm -rf conftest*
9507   eval "ac_cv_func_$ac_func=yes"
9508 else
9509   echo "configure: failed program was:" >&5
9510   cat conftest.$ac_ext >&5
9511   rm -rf conftest*
9512   eval "ac_cv_func_$ac_func=no"
9513 fi
9514 rm -f conftest*
9515 fi
9516
9517 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9518   echo "$ac_t""yes" 1>&6
9519     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9520   cat >> confdefs.h <<EOF
9521 #define $ac_tr_func 1
9522 EOF
9523
9524 else
9525   echo "$ac_t""no" 1>&6
9526 fi
9527 done
9528
9529   fi
9530
9531
9532   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9533 echo "configure:9534: checking for frexpl declaration" >&5
9534   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
9535   echo $ac_n "(cached) $ac_c" 1>&6
9536 else
9537
9538
9539     ac_ext=C
9540 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9541 ac_cpp='$CXXCPP $CPPFLAGS'
9542 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9543 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9544 cross_compiling=$ac_cv_prog_cxx_cross
9545
9546     cat > conftest.$ac_ext <<EOF
9547 #line 9548 "configure"
9548 #include "confdefs.h"
9549 #include <math.h>
9550 int main() {
9551  frexpl(0, 0);
9552 ; return 0; }
9553 EOF
9554 if { (eval echo configure:9555: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9555   rm -rf conftest*
9556   glibcpp_cv_func_frexpl_use=yes
9557 else
9558   echo "configure: failed program was:" >&5
9559   cat conftest.$ac_ext >&5
9560   rm -rf conftest*
9561   glibcpp_cv_func_frexpl_use=no
9562 fi
9563 rm -f conftest*
9564     ac_ext=c
9565 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9566 ac_cpp='$CPP $CPPFLAGS'
9567 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9568 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9569 cross_compiling=$ac_cv_prog_cc_cross
9570
9571
9572 fi
9573
9574   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
9575   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
9576     for ac_func in frexpl
9577 do
9578 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9579 echo "configure:9580: checking for $ac_func" >&5
9580 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9581   echo $ac_n "(cached) $ac_c" 1>&6
9582 else
9583   cat > conftest.$ac_ext <<EOF
9584 #line 9585 "configure"
9585 #include "confdefs.h"
9586 /* System header to define __stub macros and hopefully few prototypes,
9587     which can conflict with char $ac_func(); below.  */
9588 #include <assert.h>
9589 /* Override any gcc2 internal prototype to avoid an error.  */
9590 /* We use char because int might match the return type of a gcc2
9591     builtin and then its argument prototype would still apply.  */
9592 char $ac_func();
9593
9594 int main() {
9595
9596 /* The GNU C library defines this for functions which it implements
9597     to always fail with ENOSYS.  Some functions are actually named
9598     something starting with __ and the normal name is an alias.  */
9599 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9600 choke me
9601 #else
9602 $ac_func();
9603 #endif
9604
9605 ; return 0; }
9606 EOF
9607 if { (eval echo configure:9608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9608   rm -rf conftest*
9609   eval "ac_cv_func_$ac_func=yes"
9610 else
9611   echo "configure: failed program was:" >&5
9612   cat conftest.$ac_ext >&5
9613   rm -rf conftest*
9614   eval "ac_cv_func_$ac_func=no"
9615 fi
9616 rm -f conftest*
9617 fi
9618
9619 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9620   echo "$ac_t""yes" 1>&6
9621     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9622   cat >> confdefs.h <<EOF
9623 #define $ac_tr_func 1
9624 EOF
9625
9626 else
9627   echo "$ac_t""no" 1>&6
9628 fi
9629 done
9630
9631   fi
9632
9633
9634   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9635 echo "configure:9636: checking for ldexpl declaration" >&5
9636   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
9637   echo $ac_n "(cached) $ac_c" 1>&6
9638 else
9639
9640
9641     ac_ext=C
9642 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9643 ac_cpp='$CXXCPP $CPPFLAGS'
9644 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9645 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9646 cross_compiling=$ac_cv_prog_cxx_cross
9647
9648     cat > conftest.$ac_ext <<EOF
9649 #line 9650 "configure"
9650 #include "confdefs.h"
9651 #include <math.h>
9652 int main() {
9653  ldexpl(0, 0);
9654 ; return 0; }
9655 EOF
9656 if { (eval echo configure:9657: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9657   rm -rf conftest*
9658   glibcpp_cv_func_ldexpl_use=yes
9659 else
9660   echo "configure: failed program was:" >&5
9661   cat conftest.$ac_ext >&5
9662   rm -rf conftest*
9663   glibcpp_cv_func_ldexpl_use=no
9664 fi
9665 rm -f conftest*
9666     ac_ext=c
9667 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9668 ac_cpp='$CPP $CPPFLAGS'
9669 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9670 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9671 cross_compiling=$ac_cv_prog_cc_cross
9672
9673
9674 fi
9675
9676   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
9677   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
9678     for ac_func in ldexpl
9679 do
9680 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9681 echo "configure:9682: checking for $ac_func" >&5
9682 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9683   echo $ac_n "(cached) $ac_c" 1>&6
9684 else
9685   cat > conftest.$ac_ext <<EOF
9686 #line 9687 "configure"
9687 #include "confdefs.h"
9688 /* System header to define __stub macros and hopefully few prototypes,
9689     which can conflict with char $ac_func(); below.  */
9690 #include <assert.h>
9691 /* Override any gcc2 internal prototype to avoid an error.  */
9692 /* We use char because int might match the return type of a gcc2
9693     builtin and then its argument prototype would still apply.  */
9694 char $ac_func();
9695
9696 int main() {
9697
9698 /* The GNU C library defines this for functions which it implements
9699     to always fail with ENOSYS.  Some functions are actually named
9700     something starting with __ and the normal name is an alias.  */
9701 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9702 choke me
9703 #else
9704 $ac_func();
9705 #endif
9706
9707 ; return 0; }
9708 EOF
9709 if { (eval echo configure:9710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9710   rm -rf conftest*
9711   eval "ac_cv_func_$ac_func=yes"
9712 else
9713   echo "configure: failed program was:" >&5
9714   cat conftest.$ac_ext >&5
9715   rm -rf conftest*
9716   eval "ac_cv_func_$ac_func=no"
9717 fi
9718 rm -f conftest*
9719 fi
9720
9721 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9722   echo "$ac_t""yes" 1>&6
9723     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9724   cat >> confdefs.h <<EOF
9725 #define $ac_tr_func 1
9726 EOF
9727
9728 else
9729   echo "$ac_t""no" 1>&6
9730 fi
9731 done
9732
9733   fi
9734
9735
9736   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9737 echo "configure:9738: checking for logl declaration" >&5
9738   if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
9739   echo $ac_n "(cached) $ac_c" 1>&6
9740 else
9741
9742
9743     ac_ext=C
9744 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9745 ac_cpp='$CXXCPP $CPPFLAGS'
9746 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9747 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9748 cross_compiling=$ac_cv_prog_cxx_cross
9749
9750     cat > conftest.$ac_ext <<EOF
9751 #line 9752 "configure"
9752 #include "confdefs.h"
9753 #include <math.h>
9754 int main() {
9755  logl(0);
9756 ; return 0; }
9757 EOF
9758 if { (eval echo configure:9759: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9759   rm -rf conftest*
9760   glibcpp_cv_func_logl_use=yes
9761 else
9762   echo "configure: failed program was:" >&5
9763   cat conftest.$ac_ext >&5
9764   rm -rf conftest*
9765   glibcpp_cv_func_logl_use=no
9766 fi
9767 rm -f conftest*
9768     ac_ext=c
9769 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9770 ac_cpp='$CPP $CPPFLAGS'
9771 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9772 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9773 cross_compiling=$ac_cv_prog_cc_cross
9774
9775
9776 fi
9777
9778   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
9779   if test x$glibcpp_cv_func_logl_use = x"yes"; then
9780     for ac_func in logl
9781 do
9782 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9783 echo "configure:9784: checking for $ac_func" >&5
9784 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9785   echo $ac_n "(cached) $ac_c" 1>&6
9786 else
9787   cat > conftest.$ac_ext <<EOF
9788 #line 9789 "configure"
9789 #include "confdefs.h"
9790 /* System header to define __stub macros and hopefully few prototypes,
9791     which can conflict with char $ac_func(); below.  */
9792 #include <assert.h>
9793 /* Override any gcc2 internal prototype to avoid an error.  */
9794 /* We use char because int might match the return type of a gcc2
9795     builtin and then its argument prototype would still apply.  */
9796 char $ac_func();
9797
9798 int main() {
9799
9800 /* The GNU C library defines this for functions which it implements
9801     to always fail with ENOSYS.  Some functions are actually named
9802     something starting with __ and the normal name is an alias.  */
9803 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9804 choke me
9805 #else
9806 $ac_func();
9807 #endif
9808
9809 ; return 0; }
9810 EOF
9811 if { (eval echo configure:9812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9812   rm -rf conftest*
9813   eval "ac_cv_func_$ac_func=yes"
9814 else
9815   echo "configure: failed program was:" >&5
9816   cat conftest.$ac_ext >&5
9817   rm -rf conftest*
9818   eval "ac_cv_func_$ac_func=no"
9819 fi
9820 rm -f conftest*
9821 fi
9822
9823 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9824   echo "$ac_t""yes" 1>&6
9825     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9826   cat >> confdefs.h <<EOF
9827 #define $ac_tr_func 1
9828 EOF
9829
9830 else
9831   echo "$ac_t""no" 1>&6
9832 fi
9833 done
9834
9835   fi
9836
9837
9838   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9839 echo "configure:9840: checking for log10l declaration" >&5
9840   if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
9841   echo $ac_n "(cached) $ac_c" 1>&6
9842 else
9843
9844
9845     ac_ext=C
9846 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9847 ac_cpp='$CXXCPP $CPPFLAGS'
9848 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9849 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9850 cross_compiling=$ac_cv_prog_cxx_cross
9851
9852     cat > conftest.$ac_ext <<EOF
9853 #line 9854 "configure"
9854 #include "confdefs.h"
9855 #include <math.h>
9856 int main() {
9857  log10l(0);
9858 ; return 0; }
9859 EOF
9860 if { (eval echo configure:9861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9861   rm -rf conftest*
9862   glibcpp_cv_func_log10l_use=yes
9863 else
9864   echo "configure: failed program was:" >&5
9865   cat conftest.$ac_ext >&5
9866   rm -rf conftest*
9867   glibcpp_cv_func_log10l_use=no
9868 fi
9869 rm -f conftest*
9870     ac_ext=c
9871 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9872 ac_cpp='$CPP $CPPFLAGS'
9873 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9874 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9875 cross_compiling=$ac_cv_prog_cc_cross
9876
9877
9878 fi
9879
9880   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
9881   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
9882     for ac_func in log10l
9883 do
9884 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9885 echo "configure:9886: checking for $ac_func" >&5
9886 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9887   echo $ac_n "(cached) $ac_c" 1>&6
9888 else
9889   cat > conftest.$ac_ext <<EOF
9890 #line 9891 "configure"
9891 #include "confdefs.h"
9892 /* System header to define __stub macros and hopefully few prototypes,
9893     which can conflict with char $ac_func(); below.  */
9894 #include <assert.h>
9895 /* Override any gcc2 internal prototype to avoid an error.  */
9896 /* We use char because int might match the return type of a gcc2
9897     builtin and then its argument prototype would still apply.  */
9898 char $ac_func();
9899
9900 int main() {
9901
9902 /* The GNU C library defines this for functions which it implements
9903     to always fail with ENOSYS.  Some functions are actually named
9904     something starting with __ and the normal name is an alias.  */
9905 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9906 choke me
9907 #else
9908 $ac_func();
9909 #endif
9910
9911 ; return 0; }
9912 EOF
9913 if { (eval echo configure:9914: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9914   rm -rf conftest*
9915   eval "ac_cv_func_$ac_func=yes"
9916 else
9917   echo "configure: failed program was:" >&5
9918   cat conftest.$ac_ext >&5
9919   rm -rf conftest*
9920   eval "ac_cv_func_$ac_func=no"
9921 fi
9922 rm -f conftest*
9923 fi
9924
9925 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9926   echo "$ac_t""yes" 1>&6
9927     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9928   cat >> confdefs.h <<EOF
9929 #define $ac_tr_func 1
9930 EOF
9931
9932 else
9933   echo "$ac_t""no" 1>&6
9934 fi
9935 done
9936
9937   fi
9938
9939
9940   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
9941 echo "configure:9942: checking for modfl declaration" >&5
9942   if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
9943   echo $ac_n "(cached) $ac_c" 1>&6
9944 else
9945
9946
9947     ac_ext=C
9948 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9949 ac_cpp='$CXXCPP $CPPFLAGS'
9950 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9951 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9952 cross_compiling=$ac_cv_prog_cxx_cross
9953
9954     cat > conftest.$ac_ext <<EOF
9955 #line 9956 "configure"
9956 #include "confdefs.h"
9957 #include <math.h>
9958 int main() {
9959  modfl(0, 0);
9960 ; return 0; }
9961 EOF
9962 if { (eval echo configure:9963: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9963   rm -rf conftest*
9964   glibcpp_cv_func_modfl_use=yes
9965 else
9966   echo "configure: failed program was:" >&5
9967   cat conftest.$ac_ext >&5
9968   rm -rf conftest*
9969   glibcpp_cv_func_modfl_use=no
9970 fi
9971 rm -f conftest*
9972     ac_ext=c
9973 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9974 ac_cpp='$CPP $CPPFLAGS'
9975 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9976 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9977 cross_compiling=$ac_cv_prog_cc_cross
9978
9979
9980 fi
9981
9982   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
9983   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
9984     for ac_func in modfl
9985 do
9986 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9987 echo "configure:9988: checking for $ac_func" >&5
9988 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9989   echo $ac_n "(cached) $ac_c" 1>&6
9990 else
9991   cat > conftest.$ac_ext <<EOF
9992 #line 9993 "configure"
9993 #include "confdefs.h"
9994 /* System header to define __stub macros and hopefully few prototypes,
9995     which can conflict with char $ac_func(); below.  */
9996 #include <assert.h>
9997 /* Override any gcc2 internal prototype to avoid an error.  */
9998 /* We use char because int might match the return type of a gcc2
9999     builtin and then its argument prototype would still apply.  */
10000 char $ac_func();
10001
10002 int main() {
10003
10004 /* The GNU C library defines this for functions which it implements
10005     to always fail with ENOSYS.  Some functions are actually named
10006     something starting with __ and the normal name is an alias.  */
10007 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10008 choke me
10009 #else
10010 $ac_func();
10011 #endif
10012
10013 ; return 0; }
10014 EOF
10015 if { (eval echo configure:10016: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10016   rm -rf conftest*
10017   eval "ac_cv_func_$ac_func=yes"
10018 else
10019   echo "configure: failed program was:" >&5
10020   cat conftest.$ac_ext >&5
10021   rm -rf conftest*
10022   eval "ac_cv_func_$ac_func=no"
10023 fi
10024 rm -f conftest*
10025 fi
10026
10027 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10028   echo "$ac_t""yes" 1>&6
10029     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10030   cat >> confdefs.h <<EOF
10031 #define $ac_tr_func 1
10032 EOF
10033
10034 else
10035   echo "$ac_t""no" 1>&6
10036 fi
10037 done
10038
10039   fi
10040
10041
10042   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
10043 echo "configure:10044: checking for powl declaration" >&5
10044   if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
10045   echo $ac_n "(cached) $ac_c" 1>&6
10046 else
10047
10048
10049     ac_ext=C
10050 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10051 ac_cpp='$CXXCPP $CPPFLAGS'
10052 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10053 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10054 cross_compiling=$ac_cv_prog_cxx_cross
10055
10056     cat > conftest.$ac_ext <<EOF
10057 #line 10058 "configure"
10058 #include "confdefs.h"
10059 #include <math.h>
10060 int main() {
10061  powl(0, 0);
10062 ; return 0; }
10063 EOF
10064 if { (eval echo configure:10065: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10065   rm -rf conftest*
10066   glibcpp_cv_func_powl_use=yes
10067 else
10068   echo "configure: failed program was:" >&5
10069   cat conftest.$ac_ext >&5
10070   rm -rf conftest*
10071   glibcpp_cv_func_powl_use=no
10072 fi
10073 rm -f conftest*
10074     ac_ext=c
10075 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10076 ac_cpp='$CPP $CPPFLAGS'
10077 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10078 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10079 cross_compiling=$ac_cv_prog_cc_cross
10080
10081
10082 fi
10083
10084   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
10085   if test x$glibcpp_cv_func_powl_use = x"yes"; then
10086     for ac_func in powl
10087 do
10088 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10089 echo "configure:10090: checking for $ac_func" >&5
10090 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10091   echo $ac_n "(cached) $ac_c" 1>&6
10092 else
10093   cat > conftest.$ac_ext <<EOF
10094 #line 10095 "configure"
10095 #include "confdefs.h"
10096 /* System header to define __stub macros and hopefully few prototypes,
10097     which can conflict with char $ac_func(); below.  */
10098 #include <assert.h>
10099 /* Override any gcc2 internal prototype to avoid an error.  */
10100 /* We use char because int might match the return type of a gcc2
10101     builtin and then its argument prototype would still apply.  */
10102 char $ac_func();
10103
10104 int main() {
10105
10106 /* The GNU C library defines this for functions which it implements
10107     to always fail with ENOSYS.  Some functions are actually named
10108     something starting with __ and the normal name is an alias.  */
10109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10110 choke me
10111 #else
10112 $ac_func();
10113 #endif
10114
10115 ; return 0; }
10116 EOF
10117 if { (eval echo configure:10118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10118   rm -rf conftest*
10119   eval "ac_cv_func_$ac_func=yes"
10120 else
10121   echo "configure: failed program was:" >&5
10122   cat conftest.$ac_ext >&5
10123   rm -rf conftest*
10124   eval "ac_cv_func_$ac_func=no"
10125 fi
10126 rm -f conftest*
10127 fi
10128
10129 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10130   echo "$ac_t""yes" 1>&6
10131     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10132   cat >> confdefs.h <<EOF
10133 #define $ac_tr_func 1
10134 EOF
10135
10136 else
10137   echo "$ac_t""no" 1>&6
10138 fi
10139 done
10140
10141   fi
10142
10143
10144   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
10145 echo "configure:10146: checking for sinl declaration" >&5
10146   if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
10147   echo $ac_n "(cached) $ac_c" 1>&6
10148 else
10149
10150
10151     ac_ext=C
10152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10153 ac_cpp='$CXXCPP $CPPFLAGS'
10154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10156 cross_compiling=$ac_cv_prog_cxx_cross
10157
10158     cat > conftest.$ac_ext <<EOF
10159 #line 10160 "configure"
10160 #include "confdefs.h"
10161 #include <math.h>
10162 int main() {
10163  sinl(0);
10164 ; return 0; }
10165 EOF
10166 if { (eval echo configure:10167: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10167   rm -rf conftest*
10168   glibcpp_cv_func_sinl_use=yes
10169 else
10170   echo "configure: failed program was:" >&5
10171   cat conftest.$ac_ext >&5
10172   rm -rf conftest*
10173   glibcpp_cv_func_sinl_use=no
10174 fi
10175 rm -f conftest*
10176     ac_ext=c
10177 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10178 ac_cpp='$CPP $CPPFLAGS'
10179 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10180 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10181 cross_compiling=$ac_cv_prog_cc_cross
10182
10183
10184 fi
10185
10186   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
10187   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
10188     for ac_func in sinl
10189 do
10190 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10191 echo "configure:10192: checking for $ac_func" >&5
10192 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10193   echo $ac_n "(cached) $ac_c" 1>&6
10194 else
10195   cat > conftest.$ac_ext <<EOF
10196 #line 10197 "configure"
10197 #include "confdefs.h"
10198 /* System header to define __stub macros and hopefully few prototypes,
10199     which can conflict with char $ac_func(); below.  */
10200 #include <assert.h>
10201 /* Override any gcc2 internal prototype to avoid an error.  */
10202 /* We use char because int might match the return type of a gcc2
10203     builtin and then its argument prototype would still apply.  */
10204 char $ac_func();
10205
10206 int main() {
10207
10208 /* The GNU C library defines this for functions which it implements
10209     to always fail with ENOSYS.  Some functions are actually named
10210     something starting with __ and the normal name is an alias.  */
10211 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10212 choke me
10213 #else
10214 $ac_func();
10215 #endif
10216
10217 ; return 0; }
10218 EOF
10219 if { (eval echo configure:10220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10220   rm -rf conftest*
10221   eval "ac_cv_func_$ac_func=yes"
10222 else
10223   echo "configure: failed program was:" >&5
10224   cat conftest.$ac_ext >&5
10225   rm -rf conftest*
10226   eval "ac_cv_func_$ac_func=no"
10227 fi
10228 rm -f conftest*
10229 fi
10230
10231 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10232   echo "$ac_t""yes" 1>&6
10233     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10234   cat >> confdefs.h <<EOF
10235 #define $ac_tr_func 1
10236 EOF
10237
10238 else
10239   echo "$ac_t""no" 1>&6
10240 fi
10241 done
10242
10243   fi
10244
10245
10246   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
10247 echo "configure:10248: checking for sinhl declaration" >&5
10248   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
10249   echo $ac_n "(cached) $ac_c" 1>&6
10250 else
10251
10252
10253     ac_ext=C
10254 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10255 ac_cpp='$CXXCPP $CPPFLAGS'
10256 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10257 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10258 cross_compiling=$ac_cv_prog_cxx_cross
10259
10260     cat > conftest.$ac_ext <<EOF
10261 #line 10262 "configure"
10262 #include "confdefs.h"
10263 #include <math.h>
10264 int main() {
10265  sinhl(0);
10266 ; return 0; }
10267 EOF
10268 if { (eval echo configure:10269: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10269   rm -rf conftest*
10270   glibcpp_cv_func_sinhl_use=yes
10271 else
10272   echo "configure: failed program was:" >&5
10273   cat conftest.$ac_ext >&5
10274   rm -rf conftest*
10275   glibcpp_cv_func_sinhl_use=no
10276 fi
10277 rm -f conftest*
10278     ac_ext=c
10279 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10280 ac_cpp='$CPP $CPPFLAGS'
10281 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10282 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10283 cross_compiling=$ac_cv_prog_cc_cross
10284
10285
10286 fi
10287
10288   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
10289   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
10290     for ac_func in sinhl
10291 do
10292 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10293 echo "configure:10294: checking for $ac_func" >&5
10294 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10295   echo $ac_n "(cached) $ac_c" 1>&6
10296 else
10297   cat > conftest.$ac_ext <<EOF
10298 #line 10299 "configure"
10299 #include "confdefs.h"
10300 /* System header to define __stub macros and hopefully few prototypes,
10301     which can conflict with char $ac_func(); below.  */
10302 #include <assert.h>
10303 /* Override any gcc2 internal prototype to avoid an error.  */
10304 /* We use char because int might match the return type of a gcc2
10305     builtin and then its argument prototype would still apply.  */
10306 char $ac_func();
10307
10308 int main() {
10309
10310 /* The GNU C library defines this for functions which it implements
10311     to always fail with ENOSYS.  Some functions are actually named
10312     something starting with __ and the normal name is an alias.  */
10313 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10314 choke me
10315 #else
10316 $ac_func();
10317 #endif
10318
10319 ; return 0; }
10320 EOF
10321 if { (eval echo configure:10322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10322   rm -rf conftest*
10323   eval "ac_cv_func_$ac_func=yes"
10324 else
10325   echo "configure: failed program was:" >&5
10326   cat conftest.$ac_ext >&5
10327   rm -rf conftest*
10328   eval "ac_cv_func_$ac_func=no"
10329 fi
10330 rm -f conftest*
10331 fi
10332
10333 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10334   echo "$ac_t""yes" 1>&6
10335     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10336   cat >> confdefs.h <<EOF
10337 #define $ac_tr_func 1
10338 EOF
10339
10340 else
10341   echo "$ac_t""no" 1>&6
10342 fi
10343 done
10344
10345   fi
10346
10347
10348   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
10349 echo "configure:10350: checking for sqrtl declaration" >&5
10350   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
10351   echo $ac_n "(cached) $ac_c" 1>&6
10352 else
10353
10354
10355     ac_ext=C
10356 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10357 ac_cpp='$CXXCPP $CPPFLAGS'
10358 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10359 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10360 cross_compiling=$ac_cv_prog_cxx_cross
10361
10362     cat > conftest.$ac_ext <<EOF
10363 #line 10364 "configure"
10364 #include "confdefs.h"
10365 #include <math.h>
10366 int main() {
10367  sqrtl(0);
10368 ; return 0; }
10369 EOF
10370 if { (eval echo configure:10371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10371   rm -rf conftest*
10372   glibcpp_cv_func_sqrtl_use=yes
10373 else
10374   echo "configure: failed program was:" >&5
10375   cat conftest.$ac_ext >&5
10376   rm -rf conftest*
10377   glibcpp_cv_func_sqrtl_use=no
10378 fi
10379 rm -f conftest*
10380     ac_ext=c
10381 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10382 ac_cpp='$CPP $CPPFLAGS'
10383 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10384 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10385 cross_compiling=$ac_cv_prog_cc_cross
10386
10387
10388 fi
10389
10390   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
10391   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
10392     for ac_func in sqrtl
10393 do
10394 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10395 echo "configure:10396: checking for $ac_func" >&5
10396 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10397   echo $ac_n "(cached) $ac_c" 1>&6
10398 else
10399   cat > conftest.$ac_ext <<EOF
10400 #line 10401 "configure"
10401 #include "confdefs.h"
10402 /* System header to define __stub macros and hopefully few prototypes,
10403     which can conflict with char $ac_func(); below.  */
10404 #include <assert.h>
10405 /* Override any gcc2 internal prototype to avoid an error.  */
10406 /* We use char because int might match the return type of a gcc2
10407     builtin and then its argument prototype would still apply.  */
10408 char $ac_func();
10409
10410 int main() {
10411
10412 /* The GNU C library defines this for functions which it implements
10413     to always fail with ENOSYS.  Some functions are actually named
10414     something starting with __ and the normal name is an alias.  */
10415 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10416 choke me
10417 #else
10418 $ac_func();
10419 #endif
10420
10421 ; return 0; }
10422 EOF
10423 if { (eval echo configure:10424: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10424   rm -rf conftest*
10425   eval "ac_cv_func_$ac_func=yes"
10426 else
10427   echo "configure: failed program was:" >&5
10428   cat conftest.$ac_ext >&5
10429   rm -rf conftest*
10430   eval "ac_cv_func_$ac_func=no"
10431 fi
10432 rm -f conftest*
10433 fi
10434
10435 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10436   echo "$ac_t""yes" 1>&6
10437     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10438   cat >> confdefs.h <<EOF
10439 #define $ac_tr_func 1
10440 EOF
10441
10442 else
10443   echo "$ac_t""no" 1>&6
10444 fi
10445 done
10446
10447   fi
10448
10449
10450   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
10451 echo "configure:10452: checking for tanl declaration" >&5
10452   if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
10453   echo $ac_n "(cached) $ac_c" 1>&6
10454 else
10455
10456
10457     ac_ext=C
10458 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10459 ac_cpp='$CXXCPP $CPPFLAGS'
10460 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10461 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10462 cross_compiling=$ac_cv_prog_cxx_cross
10463
10464     cat > conftest.$ac_ext <<EOF
10465 #line 10466 "configure"
10466 #include "confdefs.h"
10467 #include <math.h>
10468 int main() {
10469  tanl(0);
10470 ; return 0; }
10471 EOF
10472 if { (eval echo configure:10473: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10473   rm -rf conftest*
10474   glibcpp_cv_func_tanl_use=yes
10475 else
10476   echo "configure: failed program was:" >&5
10477   cat conftest.$ac_ext >&5
10478   rm -rf conftest*
10479   glibcpp_cv_func_tanl_use=no
10480 fi
10481 rm -f conftest*
10482     ac_ext=c
10483 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10484 ac_cpp='$CPP $CPPFLAGS'
10485 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10486 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10487 cross_compiling=$ac_cv_prog_cc_cross
10488
10489
10490 fi
10491
10492   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
10493   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
10494     for ac_func in tanl
10495 do
10496 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10497 echo "configure:10498: checking for $ac_func" >&5
10498 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10499   echo $ac_n "(cached) $ac_c" 1>&6
10500 else
10501   cat > conftest.$ac_ext <<EOF
10502 #line 10503 "configure"
10503 #include "confdefs.h"
10504 /* System header to define __stub macros and hopefully few prototypes,
10505     which can conflict with char $ac_func(); below.  */
10506 #include <assert.h>
10507 /* Override any gcc2 internal prototype to avoid an error.  */
10508 /* We use char because int might match the return type of a gcc2
10509     builtin and then its argument prototype would still apply.  */
10510 char $ac_func();
10511
10512 int main() {
10513
10514 /* The GNU C library defines this for functions which it implements
10515     to always fail with ENOSYS.  Some functions are actually named
10516     something starting with __ and the normal name is an alias.  */
10517 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10518 choke me
10519 #else
10520 $ac_func();
10521 #endif
10522
10523 ; return 0; }
10524 EOF
10525 if { (eval echo configure:10526: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10526   rm -rf conftest*
10527   eval "ac_cv_func_$ac_func=yes"
10528 else
10529   echo "configure: failed program was:" >&5
10530   cat conftest.$ac_ext >&5
10531   rm -rf conftest*
10532   eval "ac_cv_func_$ac_func=no"
10533 fi
10534 rm -f conftest*
10535 fi
10536
10537 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10538   echo "$ac_t""yes" 1>&6
10539     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10540   cat >> confdefs.h <<EOF
10541 #define $ac_tr_func 1
10542 EOF
10543
10544 else
10545   echo "$ac_t""no" 1>&6
10546 fi
10547 done
10548
10549   fi
10550
10551
10552   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
10553 echo "configure:10554: checking for tanhl declaration" >&5
10554   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
10555   echo $ac_n "(cached) $ac_c" 1>&6
10556 else
10557
10558
10559     ac_ext=C
10560 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10561 ac_cpp='$CXXCPP $CPPFLAGS'
10562 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10563 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10564 cross_compiling=$ac_cv_prog_cxx_cross
10565
10566     cat > conftest.$ac_ext <<EOF
10567 #line 10568 "configure"
10568 #include "confdefs.h"
10569 #include <math.h>
10570 int main() {
10571  tanhl(0);
10572 ; return 0; }
10573 EOF
10574 if { (eval echo configure:10575: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10575   rm -rf conftest*
10576   glibcpp_cv_func_tanhl_use=yes
10577 else
10578   echo "configure: failed program was:" >&5
10579   cat conftest.$ac_ext >&5
10580   rm -rf conftest*
10581   glibcpp_cv_func_tanhl_use=no
10582 fi
10583 rm -f conftest*
10584     ac_ext=c
10585 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10586 ac_cpp='$CPP $CPPFLAGS'
10587 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10588 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10589 cross_compiling=$ac_cv_prog_cc_cross
10590
10591
10592 fi
10593
10594   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
10595   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
10596     for ac_func in tanhl
10597 do
10598 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10599 echo "configure:10600: checking for $ac_func" >&5
10600 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10601   echo $ac_n "(cached) $ac_c" 1>&6
10602 else
10603   cat > conftest.$ac_ext <<EOF
10604 #line 10605 "configure"
10605 #include "confdefs.h"
10606 /* System header to define __stub macros and hopefully few prototypes,
10607     which can conflict with char $ac_func(); below.  */
10608 #include <assert.h>
10609 /* Override any gcc2 internal prototype to avoid an error.  */
10610 /* We use char because int might match the return type of a gcc2
10611     builtin and then its argument prototype would still apply.  */
10612 char $ac_func();
10613
10614 int main() {
10615
10616 /* The GNU C library defines this for functions which it implements
10617     to always fail with ENOSYS.  Some functions are actually named
10618     something starting with __ and the normal name is an alias.  */
10619 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10620 choke me
10621 #else
10622 $ac_func();
10623 #endif
10624
10625 ; return 0; }
10626 EOF
10627 if { (eval echo configure:10628: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10628   rm -rf conftest*
10629   eval "ac_cv_func_$ac_func=yes"
10630 else
10631   echo "configure: failed program was:" >&5
10632   cat conftest.$ac_ext >&5
10633   rm -rf conftest*
10634   eval "ac_cv_func_$ac_func=no"
10635 fi
10636 rm -f conftest*
10637 fi
10638
10639 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10640   echo "$ac_t""yes" 1>&6
10641     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10642   cat >> confdefs.h <<EOF
10643 #define $ac_tr_func 1
10644 EOF
10645
10646 else
10647   echo "$ac_t""no" 1>&6
10648 fi
10649 done
10650
10651   fi
10652
10653
10654   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
10655 echo "configure:10656: checking for sincosl declaration" >&5
10656   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
10657   echo $ac_n "(cached) $ac_c" 1>&6
10658 else
10659
10660
10661     ac_ext=C
10662 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10663 ac_cpp='$CXXCPP $CPPFLAGS'
10664 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10665 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10666 cross_compiling=$ac_cv_prog_cxx_cross
10667
10668     cat > conftest.$ac_ext <<EOF
10669 #line 10670 "configure"
10670 #include "confdefs.h"
10671 #include <math.h>
10672 int main() {
10673  sincosl(0, 0, 0);
10674 ; return 0; }
10675 EOF
10676 if { (eval echo configure:10677: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10677   rm -rf conftest*
10678   glibcpp_cv_func_sincosl_use=yes
10679 else
10680   echo "configure: failed program was:" >&5
10681   cat conftest.$ac_ext >&5
10682   rm -rf conftest*
10683   glibcpp_cv_func_sincosl_use=no
10684 fi
10685 rm -f conftest*
10686     ac_ext=c
10687 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10688 ac_cpp='$CPP $CPPFLAGS'
10689 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10690 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10691 cross_compiling=$ac_cv_prog_cc_cross
10692
10693
10694 fi
10695
10696   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
10697   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
10698     for ac_func in sincosl
10699 do
10700 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10701 echo "configure:10702: checking for $ac_func" >&5
10702 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10703   echo $ac_n "(cached) $ac_c" 1>&6
10704 else
10705   cat > conftest.$ac_ext <<EOF
10706 #line 10707 "configure"
10707 #include "confdefs.h"
10708 /* System header to define __stub macros and hopefully few prototypes,
10709     which can conflict with char $ac_func(); below.  */
10710 #include <assert.h>
10711 /* Override any gcc2 internal prototype to avoid an error.  */
10712 /* We use char because int might match the return type of a gcc2
10713     builtin and then its argument prototype would still apply.  */
10714 char $ac_func();
10715
10716 int main() {
10717
10718 /* The GNU C library defines this for functions which it implements
10719     to always fail with ENOSYS.  Some functions are actually named
10720     something starting with __ and the normal name is an alias.  */
10721 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10722 choke me
10723 #else
10724 $ac_func();
10725 #endif
10726
10727 ; return 0; }
10728 EOF
10729 if { (eval echo configure:10730: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10730   rm -rf conftest*
10731   eval "ac_cv_func_$ac_func=yes"
10732 else
10733   echo "configure: failed program was:" >&5
10734   cat conftest.$ac_ext >&5
10735   rm -rf conftest*
10736   eval "ac_cv_func_$ac_func=no"
10737 fi
10738 rm -f conftest*
10739 fi
10740
10741 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10742   echo "$ac_t""yes" 1>&6
10743     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10744   cat >> confdefs.h <<EOF
10745 #define $ac_tr_func 1
10746 EOF
10747
10748 else
10749   echo "$ac_t""no" 1>&6
10750 fi
10751 done
10752
10753   fi
10754
10755
10756   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10757 echo "configure:10758: checking for finitel declaration" >&5
10758   if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
10759   echo $ac_n "(cached) $ac_c" 1>&6
10760 else
10761
10762
10763     ac_ext=C
10764 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10765 ac_cpp='$CXXCPP $CPPFLAGS'
10766 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10767 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10768 cross_compiling=$ac_cv_prog_cxx_cross
10769
10770     cat > conftest.$ac_ext <<EOF
10771 #line 10772 "configure"
10772 #include "confdefs.h"
10773 #include <math.h>
10774 int main() {
10775  finitel(0);
10776 ; return 0; }
10777 EOF
10778 if { (eval echo configure:10779: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10779   rm -rf conftest*
10780   glibcpp_cv_func_finitel_use=yes
10781 else
10782   echo "configure: failed program was:" >&5
10783   cat conftest.$ac_ext >&5
10784   rm -rf conftest*
10785   glibcpp_cv_func_finitel_use=no
10786 fi
10787 rm -f conftest*
10788     ac_ext=c
10789 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10790 ac_cpp='$CPP $CPPFLAGS'
10791 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10792 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10793 cross_compiling=$ac_cv_prog_cc_cross
10794
10795
10796 fi
10797
10798   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
10799   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
10800     for ac_func in finitel
10801 do
10802 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10803 echo "configure:10804: checking for $ac_func" >&5
10804 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10805   echo $ac_n "(cached) $ac_c" 1>&6
10806 else
10807   cat > conftest.$ac_ext <<EOF
10808 #line 10809 "configure"
10809 #include "confdefs.h"
10810 /* System header to define __stub macros and hopefully few prototypes,
10811     which can conflict with char $ac_func(); below.  */
10812 #include <assert.h>
10813 /* Override any gcc2 internal prototype to avoid an error.  */
10814 /* We use char because int might match the return type of a gcc2
10815     builtin and then its argument prototype would still apply.  */
10816 char $ac_func();
10817
10818 int main() {
10819
10820 /* The GNU C library defines this for functions which it implements
10821     to always fail with ENOSYS.  Some functions are actually named
10822     something starting with __ and the normal name is an alias.  */
10823 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10824 choke me
10825 #else
10826 $ac_func();
10827 #endif
10828
10829 ; return 0; }
10830 EOF
10831 if { (eval echo configure:10832: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10832   rm -rf conftest*
10833   eval "ac_cv_func_$ac_func=yes"
10834 else
10835   echo "configure: failed program was:" >&5
10836   cat conftest.$ac_ext >&5
10837   rm -rf conftest*
10838   eval "ac_cv_func_$ac_func=no"
10839 fi
10840 rm -f conftest*
10841 fi
10842
10843 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10844   echo "$ac_t""yes" 1>&6
10845     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10846   cat >> confdefs.h <<EOF
10847 #define $ac_tr_func 1
10848 EOF
10849
10850 else
10851   echo "$ac_t""no" 1>&6
10852 fi
10853 done
10854
10855   fi
10856
10857
10858
10859   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
10860 echo "configure:10861: checking for _isinf declaration" >&5
10861   if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
10862   echo $ac_n "(cached) $ac_c" 1>&6
10863 else
10864
10865
10866     ac_ext=C
10867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10868 ac_cpp='$CXXCPP $CPPFLAGS'
10869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10871 cross_compiling=$ac_cv_prog_cxx_cross
10872
10873     cat > conftest.$ac_ext <<EOF
10874 #line 10875 "configure"
10875 #include "confdefs.h"
10876 #include <math.h>
10877 int main() {
10878  _isinf(0);
10879 ; return 0; }
10880 EOF
10881 if { (eval echo configure:10882: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10882   rm -rf conftest*
10883   glibcpp_cv_func__isinf_use=yes
10884 else
10885   echo "configure: failed program was:" >&5
10886   cat conftest.$ac_ext >&5
10887   rm -rf conftest*
10888   glibcpp_cv_func__isinf_use=no
10889 fi
10890 rm -f conftest*
10891     ac_ext=c
10892 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10893 ac_cpp='$CPP $CPPFLAGS'
10894 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10895 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10896 cross_compiling=$ac_cv_prog_cc_cross
10897
10898
10899 fi
10900
10901   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
10902   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
10903     for ac_func in _isinf
10904 do
10905 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10906 echo "configure:10907: checking for $ac_func" >&5
10907 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10908   echo $ac_n "(cached) $ac_c" 1>&6
10909 else
10910   cat > conftest.$ac_ext <<EOF
10911 #line 10912 "configure"
10912 #include "confdefs.h"
10913 /* System header to define __stub macros and hopefully few prototypes,
10914     which can conflict with char $ac_func(); below.  */
10915 #include <assert.h>
10916 /* Override any gcc2 internal prototype to avoid an error.  */
10917 /* We use char because int might match the return type of a gcc2
10918     builtin and then its argument prototype would still apply.  */
10919 char $ac_func();
10920
10921 int main() {
10922
10923 /* The GNU C library defines this for functions which it implements
10924     to always fail with ENOSYS.  Some functions are actually named
10925     something starting with __ and the normal name is an alias.  */
10926 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10927 choke me
10928 #else
10929 $ac_func();
10930 #endif
10931
10932 ; return 0; }
10933 EOF
10934 if { (eval echo configure:10935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10935   rm -rf conftest*
10936   eval "ac_cv_func_$ac_func=yes"
10937 else
10938   echo "configure: failed program was:" >&5
10939   cat conftest.$ac_ext >&5
10940   rm -rf conftest*
10941   eval "ac_cv_func_$ac_func=no"
10942 fi
10943 rm -f conftest*
10944 fi
10945
10946 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10947   echo "$ac_t""yes" 1>&6
10948     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10949   cat >> confdefs.h <<EOF
10950 #define $ac_tr_func 1
10951 EOF
10952
10953 else
10954   echo "$ac_t""no" 1>&6
10955 fi
10956 done
10957
10958   fi
10959
10960
10961   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
10962 echo "configure:10963: checking for _isnan declaration" >&5
10963   if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
10964   echo $ac_n "(cached) $ac_c" 1>&6
10965 else
10966
10967
10968     ac_ext=C
10969 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10970 ac_cpp='$CXXCPP $CPPFLAGS'
10971 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10972 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10973 cross_compiling=$ac_cv_prog_cxx_cross
10974
10975     cat > conftest.$ac_ext <<EOF
10976 #line 10977 "configure"
10977 #include "confdefs.h"
10978 #include <math.h>
10979 int main() {
10980  _isnan(0);
10981 ; return 0; }
10982 EOF
10983 if { (eval echo configure:10984: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10984   rm -rf conftest*
10985   glibcpp_cv_func__isnan_use=yes
10986 else
10987   echo "configure: failed program was:" >&5
10988   cat conftest.$ac_ext >&5
10989   rm -rf conftest*
10990   glibcpp_cv_func__isnan_use=no
10991 fi
10992 rm -f conftest*
10993     ac_ext=c
10994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10995 ac_cpp='$CPP $CPPFLAGS'
10996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10998 cross_compiling=$ac_cv_prog_cc_cross
10999
11000
11001 fi
11002
11003   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
11004   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
11005     for ac_func in _isnan
11006 do
11007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11008 echo "configure:11009: checking for $ac_func" >&5
11009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11010   echo $ac_n "(cached) $ac_c" 1>&6
11011 else
11012   cat > conftest.$ac_ext <<EOF
11013 #line 11014 "configure"
11014 #include "confdefs.h"
11015 /* System header to define __stub macros and hopefully few prototypes,
11016     which can conflict with char $ac_func(); below.  */
11017 #include <assert.h>
11018 /* Override any gcc2 internal prototype to avoid an error.  */
11019 /* We use char because int might match the return type of a gcc2
11020     builtin and then its argument prototype would still apply.  */
11021 char $ac_func();
11022
11023 int main() {
11024
11025 /* The GNU C library defines this for functions which it implements
11026     to always fail with ENOSYS.  Some functions are actually named
11027     something starting with __ and the normal name is an alias.  */
11028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11029 choke me
11030 #else
11031 $ac_func();
11032 #endif
11033
11034 ; return 0; }
11035 EOF
11036 if { (eval echo configure:11037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11037   rm -rf conftest*
11038   eval "ac_cv_func_$ac_func=yes"
11039 else
11040   echo "configure: failed program was:" >&5
11041   cat conftest.$ac_ext >&5
11042   rm -rf conftest*
11043   eval "ac_cv_func_$ac_func=no"
11044 fi
11045 rm -f conftest*
11046 fi
11047
11048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11049   echo "$ac_t""yes" 1>&6
11050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11051   cat >> confdefs.h <<EOF
11052 #define $ac_tr_func 1
11053 EOF
11054
11055 else
11056   echo "$ac_t""no" 1>&6
11057 fi
11058 done
11059
11060   fi
11061
11062
11063   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
11064 echo "configure:11065: checking for _finite declaration" >&5
11065   if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
11066   echo $ac_n "(cached) $ac_c" 1>&6
11067 else
11068
11069
11070     ac_ext=C
11071 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11072 ac_cpp='$CXXCPP $CPPFLAGS'
11073 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11074 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11075 cross_compiling=$ac_cv_prog_cxx_cross
11076
11077     cat > conftest.$ac_ext <<EOF
11078 #line 11079 "configure"
11079 #include "confdefs.h"
11080 #include <math.h>
11081 int main() {
11082  _finite(0);
11083 ; return 0; }
11084 EOF
11085 if { (eval echo configure:11086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11086   rm -rf conftest*
11087   glibcpp_cv_func__finite_use=yes
11088 else
11089   echo "configure: failed program was:" >&5
11090   cat conftest.$ac_ext >&5
11091   rm -rf conftest*
11092   glibcpp_cv_func__finite_use=no
11093 fi
11094 rm -f conftest*
11095     ac_ext=c
11096 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11097 ac_cpp='$CPP $CPPFLAGS'
11098 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11099 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11100 cross_compiling=$ac_cv_prog_cc_cross
11101
11102
11103 fi
11104
11105   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
11106   if test x$glibcpp_cv_func__finite_use = x"yes"; then
11107     for ac_func in _finite
11108 do
11109 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11110 echo "configure:11111: checking for $ac_func" >&5
11111 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11112   echo $ac_n "(cached) $ac_c" 1>&6
11113 else
11114   cat > conftest.$ac_ext <<EOF
11115 #line 11116 "configure"
11116 #include "confdefs.h"
11117 /* System header to define __stub macros and hopefully few prototypes,
11118     which can conflict with char $ac_func(); below.  */
11119 #include <assert.h>
11120 /* Override any gcc2 internal prototype to avoid an error.  */
11121 /* We use char because int might match the return type of a gcc2
11122     builtin and then its argument prototype would still apply.  */
11123 char $ac_func();
11124
11125 int main() {
11126
11127 /* The GNU C library defines this for functions which it implements
11128     to always fail with ENOSYS.  Some functions are actually named
11129     something starting with __ and the normal name is an alias.  */
11130 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11131 choke me
11132 #else
11133 $ac_func();
11134 #endif
11135
11136 ; return 0; }
11137 EOF
11138 if { (eval echo configure:11139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11139   rm -rf conftest*
11140   eval "ac_cv_func_$ac_func=yes"
11141 else
11142   echo "configure: failed program was:" >&5
11143   cat conftest.$ac_ext >&5
11144   rm -rf conftest*
11145   eval "ac_cv_func_$ac_func=no"
11146 fi
11147 rm -f conftest*
11148 fi
11149
11150 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11151   echo "$ac_t""yes" 1>&6
11152     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11153   cat >> confdefs.h <<EOF
11154 #define $ac_tr_func 1
11155 EOF
11156
11157 else
11158   echo "$ac_t""no" 1>&6
11159 fi
11160 done
11161
11162   fi
11163
11164
11165   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
11166 echo "configure:11167: checking for _copysign declaration" >&5
11167   if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
11168   echo $ac_n "(cached) $ac_c" 1>&6
11169 else
11170
11171
11172     ac_ext=C
11173 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11174 ac_cpp='$CXXCPP $CPPFLAGS'
11175 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11176 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11177 cross_compiling=$ac_cv_prog_cxx_cross
11178
11179     cat > conftest.$ac_ext <<EOF
11180 #line 11181 "configure"
11181 #include "confdefs.h"
11182 #include <math.h>
11183 int main() {
11184  _copysign(0, 0);
11185 ; return 0; }
11186 EOF
11187 if { (eval echo configure:11188: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11188   rm -rf conftest*
11189   glibcpp_cv_func__copysign_use=yes
11190 else
11191   echo "configure: failed program was:" >&5
11192   cat conftest.$ac_ext >&5
11193   rm -rf conftest*
11194   glibcpp_cv_func__copysign_use=no
11195 fi
11196 rm -f conftest*
11197     ac_ext=c
11198 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11199 ac_cpp='$CPP $CPPFLAGS'
11200 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11201 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11202 cross_compiling=$ac_cv_prog_cc_cross
11203
11204
11205 fi
11206
11207   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
11208   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
11209     for ac_func in _copysign
11210 do
11211 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11212 echo "configure:11213: checking for $ac_func" >&5
11213 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11214   echo $ac_n "(cached) $ac_c" 1>&6
11215 else
11216   cat > conftest.$ac_ext <<EOF
11217 #line 11218 "configure"
11218 #include "confdefs.h"
11219 /* System header to define __stub macros and hopefully few prototypes,
11220     which can conflict with char $ac_func(); below.  */
11221 #include <assert.h>
11222 /* Override any gcc2 internal prototype to avoid an error.  */
11223 /* We use char because int might match the return type of a gcc2
11224     builtin and then its argument prototype would still apply.  */
11225 char $ac_func();
11226
11227 int main() {
11228
11229 /* The GNU C library defines this for functions which it implements
11230     to always fail with ENOSYS.  Some functions are actually named
11231     something starting with __ and the normal name is an alias.  */
11232 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11233 choke me
11234 #else
11235 $ac_func();
11236 #endif
11237
11238 ; return 0; }
11239 EOF
11240 if { (eval echo configure:11241: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11241   rm -rf conftest*
11242   eval "ac_cv_func_$ac_func=yes"
11243 else
11244   echo "configure: failed program was:" >&5
11245   cat conftest.$ac_ext >&5
11246   rm -rf conftest*
11247   eval "ac_cv_func_$ac_func=no"
11248 fi
11249 rm -f conftest*
11250 fi
11251
11252 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11253   echo "$ac_t""yes" 1>&6
11254     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11255   cat >> confdefs.h <<EOF
11256 #define $ac_tr_func 1
11257 EOF
11258
11259 else
11260   echo "$ac_t""no" 1>&6
11261 fi
11262 done
11263
11264   fi
11265
11266
11267   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
11268 echo "configure:11269: checking for _sincos declaration" >&5
11269   if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
11270   echo $ac_n "(cached) $ac_c" 1>&6
11271 else
11272
11273
11274     ac_ext=C
11275 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11276 ac_cpp='$CXXCPP $CPPFLAGS'
11277 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11278 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11279 cross_compiling=$ac_cv_prog_cxx_cross
11280
11281     cat > conftest.$ac_ext <<EOF
11282 #line 11283 "configure"
11283 #include "confdefs.h"
11284 #include <math.h>
11285 int main() {
11286  _sincos(0, 0, 0);
11287 ; return 0; }
11288 EOF
11289 if { (eval echo configure:11290: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11290   rm -rf conftest*
11291   glibcpp_cv_func__sincos_use=yes
11292 else
11293   echo "configure: failed program was:" >&5
11294   cat conftest.$ac_ext >&5
11295   rm -rf conftest*
11296   glibcpp_cv_func__sincos_use=no
11297 fi
11298 rm -f conftest*
11299     ac_ext=c
11300 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11301 ac_cpp='$CPP $CPPFLAGS'
11302 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11303 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11304 cross_compiling=$ac_cv_prog_cc_cross
11305
11306
11307 fi
11308
11309   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
11310   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
11311     for ac_func in _sincos
11312 do
11313 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11314 echo "configure:11315: checking for $ac_func" >&5
11315 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11316   echo $ac_n "(cached) $ac_c" 1>&6
11317 else
11318   cat > conftest.$ac_ext <<EOF
11319 #line 11320 "configure"
11320 #include "confdefs.h"
11321 /* System header to define __stub macros and hopefully few prototypes,
11322     which can conflict with char $ac_func(); below.  */
11323 #include <assert.h>
11324 /* Override any gcc2 internal prototype to avoid an error.  */
11325 /* We use char because int might match the return type of a gcc2
11326     builtin and then its argument prototype would still apply.  */
11327 char $ac_func();
11328
11329 int main() {
11330
11331 /* The GNU C library defines this for functions which it implements
11332     to always fail with ENOSYS.  Some functions are actually named
11333     something starting with __ and the normal name is an alias.  */
11334 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11335 choke me
11336 #else
11337 $ac_func();
11338 #endif
11339
11340 ; return 0; }
11341 EOF
11342 if { (eval echo configure:11343: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11343   rm -rf conftest*
11344   eval "ac_cv_func_$ac_func=yes"
11345 else
11346   echo "configure: failed program was:" >&5
11347   cat conftest.$ac_ext >&5
11348   rm -rf conftest*
11349   eval "ac_cv_func_$ac_func=no"
11350 fi
11351 rm -f conftest*
11352 fi
11353
11354 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11355   echo "$ac_t""yes" 1>&6
11356     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11357   cat >> confdefs.h <<EOF
11358 #define $ac_tr_func 1
11359 EOF
11360
11361 else
11362   echo "$ac_t""no" 1>&6
11363 fi
11364 done
11365
11366   fi
11367
11368
11369   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
11370 echo "configure:11371: checking for _fpclass declaration" >&5
11371   if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
11372   echo $ac_n "(cached) $ac_c" 1>&6
11373 else
11374
11375
11376     ac_ext=C
11377 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11378 ac_cpp='$CXXCPP $CPPFLAGS'
11379 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11380 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11381 cross_compiling=$ac_cv_prog_cxx_cross
11382
11383     cat > conftest.$ac_ext <<EOF
11384 #line 11385 "configure"
11385 #include "confdefs.h"
11386 #include <math.h>
11387 int main() {
11388  _fpclass(0);
11389 ; return 0; }
11390 EOF
11391 if { (eval echo configure:11392: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11392   rm -rf conftest*
11393   glibcpp_cv_func__fpclass_use=yes
11394 else
11395   echo "configure: failed program was:" >&5
11396   cat conftest.$ac_ext >&5
11397   rm -rf conftest*
11398   glibcpp_cv_func__fpclass_use=no
11399 fi
11400 rm -f conftest*
11401     ac_ext=c
11402 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11403 ac_cpp='$CPP $CPPFLAGS'
11404 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11405 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11406 cross_compiling=$ac_cv_prog_cc_cross
11407
11408
11409 fi
11410
11411   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
11412   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
11413     for ac_func in _fpclass
11414 do
11415 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11416 echo "configure:11417: checking for $ac_func" >&5
11417 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11418   echo $ac_n "(cached) $ac_c" 1>&6
11419 else
11420   cat > conftest.$ac_ext <<EOF
11421 #line 11422 "configure"
11422 #include "confdefs.h"
11423 /* System header to define __stub macros and hopefully few prototypes,
11424     which can conflict with char $ac_func(); below.  */
11425 #include <assert.h>
11426 /* Override any gcc2 internal prototype to avoid an error.  */
11427 /* We use char because int might match the return type of a gcc2
11428     builtin and then its argument prototype would still apply.  */
11429 char $ac_func();
11430
11431 int main() {
11432
11433 /* The GNU C library defines this for functions which it implements
11434     to always fail with ENOSYS.  Some functions are actually named
11435     something starting with __ and the normal name is an alias.  */
11436 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11437 choke me
11438 #else
11439 $ac_func();
11440 #endif
11441
11442 ; return 0; }
11443 EOF
11444 if { (eval echo configure:11445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11445   rm -rf conftest*
11446   eval "ac_cv_func_$ac_func=yes"
11447 else
11448   echo "configure: failed program was:" >&5
11449   cat conftest.$ac_ext >&5
11450   rm -rf conftest*
11451   eval "ac_cv_func_$ac_func=no"
11452 fi
11453 rm -f conftest*
11454 fi
11455
11456 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11457   echo "$ac_t""yes" 1>&6
11458     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11459   cat >> confdefs.h <<EOF
11460 #define $ac_tr_func 1
11461 EOF
11462
11463 else
11464   echo "$ac_t""no" 1>&6
11465 fi
11466 done
11467
11468   fi
11469
11470
11471   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
11472 echo "configure:11473: checking for _qfpclass declaration" >&5
11473   if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
11474   echo $ac_n "(cached) $ac_c" 1>&6
11475 else
11476
11477
11478     ac_ext=C
11479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11480 ac_cpp='$CXXCPP $CPPFLAGS'
11481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11483 cross_compiling=$ac_cv_prog_cxx_cross
11484
11485     cat > conftest.$ac_ext <<EOF
11486 #line 11487 "configure"
11487 #include "confdefs.h"
11488 #include <math.h>
11489 int main() {
11490  _qfpclass(0);
11491 ; return 0; }
11492 EOF
11493 if { (eval echo configure:11494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11494   rm -rf conftest*
11495   glibcpp_cv_func__qfpclass_use=yes
11496 else
11497   echo "configure: failed program was:" >&5
11498   cat conftest.$ac_ext >&5
11499   rm -rf conftest*
11500   glibcpp_cv_func__qfpclass_use=no
11501 fi
11502 rm -f conftest*
11503     ac_ext=c
11504 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11505 ac_cpp='$CPP $CPPFLAGS'
11506 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11507 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11508 cross_compiling=$ac_cv_prog_cc_cross
11509
11510
11511 fi
11512
11513   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
11514   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
11515     for ac_func in _qfpclass
11516 do
11517 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11518 echo "configure:11519: checking for $ac_func" >&5
11519 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11520   echo $ac_n "(cached) $ac_c" 1>&6
11521 else
11522   cat > conftest.$ac_ext <<EOF
11523 #line 11524 "configure"
11524 #include "confdefs.h"
11525 /* System header to define __stub macros and hopefully few prototypes,
11526     which can conflict with char $ac_func(); below.  */
11527 #include <assert.h>
11528 /* Override any gcc2 internal prototype to avoid an error.  */
11529 /* We use char because int might match the return type of a gcc2
11530     builtin and then its argument prototype would still apply.  */
11531 char $ac_func();
11532
11533 int main() {
11534
11535 /* The GNU C library defines this for functions which it implements
11536     to always fail with ENOSYS.  Some functions are actually named
11537     something starting with __ and the normal name is an alias.  */
11538 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11539 choke me
11540 #else
11541 $ac_func();
11542 #endif
11543
11544 ; return 0; }
11545 EOF
11546 if { (eval echo configure:11547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11547   rm -rf conftest*
11548   eval "ac_cv_func_$ac_func=yes"
11549 else
11550   echo "configure: failed program was:" >&5
11551   cat conftest.$ac_ext >&5
11552   rm -rf conftest*
11553   eval "ac_cv_func_$ac_func=no"
11554 fi
11555 rm -f conftest*
11556 fi
11557
11558 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11559   echo "$ac_t""yes" 1>&6
11560     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11561   cat >> confdefs.h <<EOF
11562 #define $ac_tr_func 1
11563 EOF
11564
11565 else
11566   echo "$ac_t""no" 1>&6
11567 fi
11568 done
11569
11570   fi
11571
11572
11573
11574   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11575 echo "configure:11576: checking for _isnanf declaration" >&5
11576   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
11577   echo $ac_n "(cached) $ac_c" 1>&6
11578 else
11579
11580
11581     ac_ext=C
11582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11583 ac_cpp='$CXXCPP $CPPFLAGS'
11584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11586 cross_compiling=$ac_cv_prog_cxx_cross
11587
11588     cat > conftest.$ac_ext <<EOF
11589 #line 11590 "configure"
11590 #include "confdefs.h"
11591 #include <math.h>
11592 int main() {
11593  _isnanf(0);
11594 ; return 0; }
11595 EOF
11596 if { (eval echo configure:11597: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11597   rm -rf conftest*
11598   glibcpp_cv_func__isnanf_use=yes
11599 else
11600   echo "configure: failed program was:" >&5
11601   cat conftest.$ac_ext >&5
11602   rm -rf conftest*
11603   glibcpp_cv_func__isnanf_use=no
11604 fi
11605 rm -f conftest*
11606     ac_ext=c
11607 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11608 ac_cpp='$CPP $CPPFLAGS'
11609 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11610 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11611 cross_compiling=$ac_cv_prog_cc_cross
11612
11613
11614 fi
11615
11616   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
11617   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
11618     for ac_func in _isnanf
11619 do
11620 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11621 echo "configure:11622: checking for $ac_func" >&5
11622 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11623   echo $ac_n "(cached) $ac_c" 1>&6
11624 else
11625   cat > conftest.$ac_ext <<EOF
11626 #line 11627 "configure"
11627 #include "confdefs.h"
11628 /* System header to define __stub macros and hopefully few prototypes,
11629     which can conflict with char $ac_func(); below.  */
11630 #include <assert.h>
11631 /* Override any gcc2 internal prototype to avoid an error.  */
11632 /* We use char because int might match the return type of a gcc2
11633     builtin and then its argument prototype would still apply.  */
11634 char $ac_func();
11635
11636 int main() {
11637
11638 /* The GNU C library defines this for functions which it implements
11639     to always fail with ENOSYS.  Some functions are actually named
11640     something starting with __ and the normal name is an alias.  */
11641 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11642 choke me
11643 #else
11644 $ac_func();
11645 #endif
11646
11647 ; return 0; }
11648 EOF
11649 if { (eval echo configure:11650: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11650   rm -rf conftest*
11651   eval "ac_cv_func_$ac_func=yes"
11652 else
11653   echo "configure: failed program was:" >&5
11654   cat conftest.$ac_ext >&5
11655   rm -rf conftest*
11656   eval "ac_cv_func_$ac_func=no"
11657 fi
11658 rm -f conftest*
11659 fi
11660
11661 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11662   echo "$ac_t""yes" 1>&6
11663     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11664   cat >> confdefs.h <<EOF
11665 #define $ac_tr_func 1
11666 EOF
11667
11668 else
11669   echo "$ac_t""no" 1>&6
11670 fi
11671 done
11672
11673   fi
11674
11675
11676   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11677 echo "configure:11678: checking for _isinff declaration" >&5
11678   if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
11679   echo $ac_n "(cached) $ac_c" 1>&6
11680 else
11681
11682
11683     ac_ext=C
11684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11685 ac_cpp='$CXXCPP $CPPFLAGS'
11686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11688 cross_compiling=$ac_cv_prog_cxx_cross
11689
11690     cat > conftest.$ac_ext <<EOF
11691 #line 11692 "configure"
11692 #include "confdefs.h"
11693 #include <math.h>
11694 int main() {
11695  _isinff(0);
11696 ; return 0; }
11697 EOF
11698 if { (eval echo configure:11699: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11699   rm -rf conftest*
11700   glibcpp_cv_func__isinff_use=yes
11701 else
11702   echo "configure: failed program was:" >&5
11703   cat conftest.$ac_ext >&5
11704   rm -rf conftest*
11705   glibcpp_cv_func__isinff_use=no
11706 fi
11707 rm -f conftest*
11708     ac_ext=c
11709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11710 ac_cpp='$CPP $CPPFLAGS'
11711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11713 cross_compiling=$ac_cv_prog_cc_cross
11714
11715
11716 fi
11717
11718   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
11719   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
11720     for ac_func in _isinff
11721 do
11722 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11723 echo "configure:11724: checking for $ac_func" >&5
11724 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11725   echo $ac_n "(cached) $ac_c" 1>&6
11726 else
11727   cat > conftest.$ac_ext <<EOF
11728 #line 11729 "configure"
11729 #include "confdefs.h"
11730 /* System header to define __stub macros and hopefully few prototypes,
11731     which can conflict with char $ac_func(); below.  */
11732 #include <assert.h>
11733 /* Override any gcc2 internal prototype to avoid an error.  */
11734 /* We use char because int might match the return type of a gcc2
11735     builtin and then its argument prototype would still apply.  */
11736 char $ac_func();
11737
11738 int main() {
11739
11740 /* The GNU C library defines this for functions which it implements
11741     to always fail with ENOSYS.  Some functions are actually named
11742     something starting with __ and the normal name is an alias.  */
11743 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11744 choke me
11745 #else
11746 $ac_func();
11747 #endif
11748
11749 ; return 0; }
11750 EOF
11751 if { (eval echo configure:11752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11752   rm -rf conftest*
11753   eval "ac_cv_func_$ac_func=yes"
11754 else
11755   echo "configure: failed program was:" >&5
11756   cat conftest.$ac_ext >&5
11757   rm -rf conftest*
11758   eval "ac_cv_func_$ac_func=no"
11759 fi
11760 rm -f conftest*
11761 fi
11762
11763 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11764   echo "$ac_t""yes" 1>&6
11765     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11766   cat >> confdefs.h <<EOF
11767 #define $ac_tr_func 1
11768 EOF
11769
11770 else
11771   echo "$ac_t""no" 1>&6
11772 fi
11773 done
11774
11775   fi
11776
11777
11778   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11779 echo "configure:11780: checking for _acosf declaration" >&5
11780   if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
11781   echo $ac_n "(cached) $ac_c" 1>&6
11782 else
11783
11784
11785     ac_ext=C
11786 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11787 ac_cpp='$CXXCPP $CPPFLAGS'
11788 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11789 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11790 cross_compiling=$ac_cv_prog_cxx_cross
11791
11792     cat > conftest.$ac_ext <<EOF
11793 #line 11794 "configure"
11794 #include "confdefs.h"
11795 #include <math.h>
11796 int main() {
11797  _acosf(0);
11798 ; return 0; }
11799 EOF
11800 if { (eval echo configure:11801: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11801   rm -rf conftest*
11802   glibcpp_cv_func__acosf_use=yes
11803 else
11804   echo "configure: failed program was:" >&5
11805   cat conftest.$ac_ext >&5
11806   rm -rf conftest*
11807   glibcpp_cv_func__acosf_use=no
11808 fi
11809 rm -f conftest*
11810     ac_ext=c
11811 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11812 ac_cpp='$CPP $CPPFLAGS'
11813 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11814 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11815 cross_compiling=$ac_cv_prog_cc_cross
11816
11817
11818 fi
11819
11820   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
11821   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
11822     for ac_func in _acosf
11823 do
11824 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11825 echo "configure:11826: checking for $ac_func" >&5
11826 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11827   echo $ac_n "(cached) $ac_c" 1>&6
11828 else
11829   cat > conftest.$ac_ext <<EOF
11830 #line 11831 "configure"
11831 #include "confdefs.h"
11832 /* System header to define __stub macros and hopefully few prototypes,
11833     which can conflict with char $ac_func(); below.  */
11834 #include <assert.h>
11835 /* Override any gcc2 internal prototype to avoid an error.  */
11836 /* We use char because int might match the return type of a gcc2
11837     builtin and then its argument prototype would still apply.  */
11838 char $ac_func();
11839
11840 int main() {
11841
11842 /* The GNU C library defines this for functions which it implements
11843     to always fail with ENOSYS.  Some functions are actually named
11844     something starting with __ and the normal name is an alias.  */
11845 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11846 choke me
11847 #else
11848 $ac_func();
11849 #endif
11850
11851 ; return 0; }
11852 EOF
11853 if { (eval echo configure:11854: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11854   rm -rf conftest*
11855   eval "ac_cv_func_$ac_func=yes"
11856 else
11857   echo "configure: failed program was:" >&5
11858   cat conftest.$ac_ext >&5
11859   rm -rf conftest*
11860   eval "ac_cv_func_$ac_func=no"
11861 fi
11862 rm -f conftest*
11863 fi
11864
11865 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11866   echo "$ac_t""yes" 1>&6
11867     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11868   cat >> confdefs.h <<EOF
11869 #define $ac_tr_func 1
11870 EOF
11871
11872 else
11873   echo "$ac_t""no" 1>&6
11874 fi
11875 done
11876
11877   fi
11878
11879
11880   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11881 echo "configure:11882: checking for _asinf declaration" >&5
11882   if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
11883   echo $ac_n "(cached) $ac_c" 1>&6
11884 else
11885
11886
11887     ac_ext=C
11888 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11889 ac_cpp='$CXXCPP $CPPFLAGS'
11890 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11891 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11892 cross_compiling=$ac_cv_prog_cxx_cross
11893
11894     cat > conftest.$ac_ext <<EOF
11895 #line 11896 "configure"
11896 #include "confdefs.h"
11897 #include <math.h>
11898 int main() {
11899  _asinf(0);
11900 ; return 0; }
11901 EOF
11902 if { (eval echo configure:11903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11903   rm -rf conftest*
11904   glibcpp_cv_func__asinf_use=yes
11905 else
11906   echo "configure: failed program was:" >&5
11907   cat conftest.$ac_ext >&5
11908   rm -rf conftest*
11909   glibcpp_cv_func__asinf_use=no
11910 fi
11911 rm -f conftest*
11912     ac_ext=c
11913 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11914 ac_cpp='$CPP $CPPFLAGS'
11915 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11916 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11917 cross_compiling=$ac_cv_prog_cc_cross
11918
11919
11920 fi
11921
11922   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
11923   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
11924     for ac_func in _asinf
11925 do
11926 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11927 echo "configure:11928: checking for $ac_func" >&5
11928 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11929   echo $ac_n "(cached) $ac_c" 1>&6
11930 else
11931   cat > conftest.$ac_ext <<EOF
11932 #line 11933 "configure"
11933 #include "confdefs.h"
11934 /* System header to define __stub macros and hopefully few prototypes,
11935     which can conflict with char $ac_func(); below.  */
11936 #include <assert.h>
11937 /* Override any gcc2 internal prototype to avoid an error.  */
11938 /* We use char because int might match the return type of a gcc2
11939     builtin and then its argument prototype would still apply.  */
11940 char $ac_func();
11941
11942 int main() {
11943
11944 /* The GNU C library defines this for functions which it implements
11945     to always fail with ENOSYS.  Some functions are actually named
11946     something starting with __ and the normal name is an alias.  */
11947 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11948 choke me
11949 #else
11950 $ac_func();
11951 #endif
11952
11953 ; return 0; }
11954 EOF
11955 if { (eval echo configure:11956: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11956   rm -rf conftest*
11957   eval "ac_cv_func_$ac_func=yes"
11958 else
11959   echo "configure: failed program was:" >&5
11960   cat conftest.$ac_ext >&5
11961   rm -rf conftest*
11962   eval "ac_cv_func_$ac_func=no"
11963 fi
11964 rm -f conftest*
11965 fi
11966
11967 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11968   echo "$ac_t""yes" 1>&6
11969     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11970   cat >> confdefs.h <<EOF
11971 #define $ac_tr_func 1
11972 EOF
11973
11974 else
11975   echo "$ac_t""no" 1>&6
11976 fi
11977 done
11978
11979   fi
11980
11981
11982   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
11983 echo "configure:11984: checking for _atanf declaration" >&5
11984   if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
11985   echo $ac_n "(cached) $ac_c" 1>&6
11986 else
11987
11988
11989     ac_ext=C
11990 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11991 ac_cpp='$CXXCPP $CPPFLAGS'
11992 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11993 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11994 cross_compiling=$ac_cv_prog_cxx_cross
11995
11996     cat > conftest.$ac_ext <<EOF
11997 #line 11998 "configure"
11998 #include "confdefs.h"
11999 #include <math.h>
12000 int main() {
12001  _atanf(0);
12002 ; return 0; }
12003 EOF
12004 if { (eval echo configure:12005: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12005   rm -rf conftest*
12006   glibcpp_cv_func__atanf_use=yes
12007 else
12008   echo "configure: failed program was:" >&5
12009   cat conftest.$ac_ext >&5
12010   rm -rf conftest*
12011   glibcpp_cv_func__atanf_use=no
12012 fi
12013 rm -f conftest*
12014     ac_ext=c
12015 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12016 ac_cpp='$CPP $CPPFLAGS'
12017 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12018 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12019 cross_compiling=$ac_cv_prog_cc_cross
12020
12021
12022 fi
12023
12024   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
12025   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
12026     for ac_func in _atanf
12027 do
12028 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12029 echo "configure:12030: checking for $ac_func" >&5
12030 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12031   echo $ac_n "(cached) $ac_c" 1>&6
12032 else
12033   cat > conftest.$ac_ext <<EOF
12034 #line 12035 "configure"
12035 #include "confdefs.h"
12036 /* System header to define __stub macros and hopefully few prototypes,
12037     which can conflict with char $ac_func(); below.  */
12038 #include <assert.h>
12039 /* Override any gcc2 internal prototype to avoid an error.  */
12040 /* We use char because int might match the return type of a gcc2
12041     builtin and then its argument prototype would still apply.  */
12042 char $ac_func();
12043
12044 int main() {
12045
12046 /* The GNU C library defines this for functions which it implements
12047     to always fail with ENOSYS.  Some functions are actually named
12048     something starting with __ and the normal name is an alias.  */
12049 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12050 choke me
12051 #else
12052 $ac_func();
12053 #endif
12054
12055 ; return 0; }
12056 EOF
12057 if { (eval echo configure:12058: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12058   rm -rf conftest*
12059   eval "ac_cv_func_$ac_func=yes"
12060 else
12061   echo "configure: failed program was:" >&5
12062   cat conftest.$ac_ext >&5
12063   rm -rf conftest*
12064   eval "ac_cv_func_$ac_func=no"
12065 fi
12066 rm -f conftest*
12067 fi
12068
12069 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12070   echo "$ac_t""yes" 1>&6
12071     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12072   cat >> confdefs.h <<EOF
12073 #define $ac_tr_func 1
12074 EOF
12075
12076 else
12077   echo "$ac_t""no" 1>&6
12078 fi
12079 done
12080
12081   fi
12082
12083
12084   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
12085 echo "configure:12086: checking for _atan2f declaration" >&5
12086   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
12087   echo $ac_n "(cached) $ac_c" 1>&6
12088 else
12089
12090
12091     ac_ext=C
12092 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12093 ac_cpp='$CXXCPP $CPPFLAGS'
12094 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12095 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12096 cross_compiling=$ac_cv_prog_cxx_cross
12097
12098     cat > conftest.$ac_ext <<EOF
12099 #line 12100 "configure"
12100 #include "confdefs.h"
12101 #include <math.h>
12102 int main() {
12103  _atan2f(0, 0);
12104 ; return 0; }
12105 EOF
12106 if { (eval echo configure:12107: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12107   rm -rf conftest*
12108   glibcpp_cv_func__atan2f_use=yes
12109 else
12110   echo "configure: failed program was:" >&5
12111   cat conftest.$ac_ext >&5
12112   rm -rf conftest*
12113   glibcpp_cv_func__atan2f_use=no
12114 fi
12115 rm -f conftest*
12116     ac_ext=c
12117 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12118 ac_cpp='$CPP $CPPFLAGS'
12119 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12120 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12121 cross_compiling=$ac_cv_prog_cc_cross
12122
12123
12124 fi
12125
12126   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
12127   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
12128     for ac_func in _atan2f
12129 do
12130 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12131 echo "configure:12132: checking for $ac_func" >&5
12132 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12133   echo $ac_n "(cached) $ac_c" 1>&6
12134 else
12135   cat > conftest.$ac_ext <<EOF
12136 #line 12137 "configure"
12137 #include "confdefs.h"
12138 /* System header to define __stub macros and hopefully few prototypes,
12139     which can conflict with char $ac_func(); below.  */
12140 #include <assert.h>
12141 /* Override any gcc2 internal prototype to avoid an error.  */
12142 /* We use char because int might match the return type of a gcc2
12143     builtin and then its argument prototype would still apply.  */
12144 char $ac_func();
12145
12146 int main() {
12147
12148 /* The GNU C library defines this for functions which it implements
12149     to always fail with ENOSYS.  Some functions are actually named
12150     something starting with __ and the normal name is an alias.  */
12151 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12152 choke me
12153 #else
12154 $ac_func();
12155 #endif
12156
12157 ; return 0; }
12158 EOF
12159 if { (eval echo configure:12160: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12160   rm -rf conftest*
12161   eval "ac_cv_func_$ac_func=yes"
12162 else
12163   echo "configure: failed program was:" >&5
12164   cat conftest.$ac_ext >&5
12165   rm -rf conftest*
12166   eval "ac_cv_func_$ac_func=no"
12167 fi
12168 rm -f conftest*
12169 fi
12170
12171 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12172   echo "$ac_t""yes" 1>&6
12173     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12174   cat >> confdefs.h <<EOF
12175 #define $ac_tr_func 1
12176 EOF
12177
12178 else
12179   echo "$ac_t""no" 1>&6
12180 fi
12181 done
12182
12183   fi
12184
12185
12186   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
12187 echo "configure:12188: checking for _ceilf declaration" >&5
12188   if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
12189   echo $ac_n "(cached) $ac_c" 1>&6
12190 else
12191
12192
12193     ac_ext=C
12194 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12195 ac_cpp='$CXXCPP $CPPFLAGS'
12196 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12197 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12198 cross_compiling=$ac_cv_prog_cxx_cross
12199
12200     cat > conftest.$ac_ext <<EOF
12201 #line 12202 "configure"
12202 #include "confdefs.h"
12203 #include <math.h>
12204 int main() {
12205  _ceilf(0);
12206 ; return 0; }
12207 EOF
12208 if { (eval echo configure:12209: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12209   rm -rf conftest*
12210   glibcpp_cv_func__ceilf_use=yes
12211 else
12212   echo "configure: failed program was:" >&5
12213   cat conftest.$ac_ext >&5
12214   rm -rf conftest*
12215   glibcpp_cv_func__ceilf_use=no
12216 fi
12217 rm -f conftest*
12218     ac_ext=c
12219 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12220 ac_cpp='$CPP $CPPFLAGS'
12221 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12222 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12223 cross_compiling=$ac_cv_prog_cc_cross
12224
12225
12226 fi
12227
12228   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
12229   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
12230     for ac_func in _ceilf
12231 do
12232 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12233 echo "configure:12234: checking for $ac_func" >&5
12234 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12235   echo $ac_n "(cached) $ac_c" 1>&6
12236 else
12237   cat > conftest.$ac_ext <<EOF
12238 #line 12239 "configure"
12239 #include "confdefs.h"
12240 /* System header to define __stub macros and hopefully few prototypes,
12241     which can conflict with char $ac_func(); below.  */
12242 #include <assert.h>
12243 /* Override any gcc2 internal prototype to avoid an error.  */
12244 /* We use char because int might match the return type of a gcc2
12245     builtin and then its argument prototype would still apply.  */
12246 char $ac_func();
12247
12248 int main() {
12249
12250 /* The GNU C library defines this for functions which it implements
12251     to always fail with ENOSYS.  Some functions are actually named
12252     something starting with __ and the normal name is an alias.  */
12253 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12254 choke me
12255 #else
12256 $ac_func();
12257 #endif
12258
12259 ; return 0; }
12260 EOF
12261 if { (eval echo configure:12262: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12262   rm -rf conftest*
12263   eval "ac_cv_func_$ac_func=yes"
12264 else
12265   echo "configure: failed program was:" >&5
12266   cat conftest.$ac_ext >&5
12267   rm -rf conftest*
12268   eval "ac_cv_func_$ac_func=no"
12269 fi
12270 rm -f conftest*
12271 fi
12272
12273 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12274   echo "$ac_t""yes" 1>&6
12275     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12276   cat >> confdefs.h <<EOF
12277 #define $ac_tr_func 1
12278 EOF
12279
12280 else
12281   echo "$ac_t""no" 1>&6
12282 fi
12283 done
12284
12285   fi
12286
12287
12288   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
12289 echo "configure:12290: checking for _cosf declaration" >&5
12290   if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
12291   echo $ac_n "(cached) $ac_c" 1>&6
12292 else
12293
12294
12295     ac_ext=C
12296 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12297 ac_cpp='$CXXCPP $CPPFLAGS'
12298 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12299 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12300 cross_compiling=$ac_cv_prog_cxx_cross
12301
12302     cat > conftest.$ac_ext <<EOF
12303 #line 12304 "configure"
12304 #include "confdefs.h"
12305 #include <math.h>
12306 int main() {
12307  _cosf(0);
12308 ; return 0; }
12309 EOF
12310 if { (eval echo configure:12311: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12311   rm -rf conftest*
12312   glibcpp_cv_func__cosf_use=yes
12313 else
12314   echo "configure: failed program was:" >&5
12315   cat conftest.$ac_ext >&5
12316   rm -rf conftest*
12317   glibcpp_cv_func__cosf_use=no
12318 fi
12319 rm -f conftest*
12320     ac_ext=c
12321 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12322 ac_cpp='$CPP $CPPFLAGS'
12323 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12324 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12325 cross_compiling=$ac_cv_prog_cc_cross
12326
12327
12328 fi
12329
12330   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
12331   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
12332     for ac_func in _cosf
12333 do
12334 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12335 echo "configure:12336: checking for $ac_func" >&5
12336 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12337   echo $ac_n "(cached) $ac_c" 1>&6
12338 else
12339   cat > conftest.$ac_ext <<EOF
12340 #line 12341 "configure"
12341 #include "confdefs.h"
12342 /* System header to define __stub macros and hopefully few prototypes,
12343     which can conflict with char $ac_func(); below.  */
12344 #include <assert.h>
12345 /* Override any gcc2 internal prototype to avoid an error.  */
12346 /* We use char because int might match the return type of a gcc2
12347     builtin and then its argument prototype would still apply.  */
12348 char $ac_func();
12349
12350 int main() {
12351
12352 /* The GNU C library defines this for functions which it implements
12353     to always fail with ENOSYS.  Some functions are actually named
12354     something starting with __ and the normal name is an alias.  */
12355 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12356 choke me
12357 #else
12358 $ac_func();
12359 #endif
12360
12361 ; return 0; }
12362 EOF
12363 if { (eval echo configure:12364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12364   rm -rf conftest*
12365   eval "ac_cv_func_$ac_func=yes"
12366 else
12367   echo "configure: failed program was:" >&5
12368   cat conftest.$ac_ext >&5
12369   rm -rf conftest*
12370   eval "ac_cv_func_$ac_func=no"
12371 fi
12372 rm -f conftest*
12373 fi
12374
12375 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12376   echo "$ac_t""yes" 1>&6
12377     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12378   cat >> confdefs.h <<EOF
12379 #define $ac_tr_func 1
12380 EOF
12381
12382 else
12383   echo "$ac_t""no" 1>&6
12384 fi
12385 done
12386
12387   fi
12388
12389
12390   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12391 echo "configure:12392: checking for _coshf declaration" >&5
12392   if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
12393   echo $ac_n "(cached) $ac_c" 1>&6
12394 else
12395
12396
12397     ac_ext=C
12398 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12399 ac_cpp='$CXXCPP $CPPFLAGS'
12400 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12401 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12402 cross_compiling=$ac_cv_prog_cxx_cross
12403
12404     cat > conftest.$ac_ext <<EOF
12405 #line 12406 "configure"
12406 #include "confdefs.h"
12407 #include <math.h>
12408 int main() {
12409  _coshf(0);
12410 ; return 0; }
12411 EOF
12412 if { (eval echo configure:12413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12413   rm -rf conftest*
12414   glibcpp_cv_func__coshf_use=yes
12415 else
12416   echo "configure: failed program was:" >&5
12417   cat conftest.$ac_ext >&5
12418   rm -rf conftest*
12419   glibcpp_cv_func__coshf_use=no
12420 fi
12421 rm -f conftest*
12422     ac_ext=c
12423 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12424 ac_cpp='$CPP $CPPFLAGS'
12425 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12426 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12427 cross_compiling=$ac_cv_prog_cc_cross
12428
12429
12430 fi
12431
12432   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
12433   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
12434     for ac_func in _coshf
12435 do
12436 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12437 echo "configure:12438: checking for $ac_func" >&5
12438 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12439   echo $ac_n "(cached) $ac_c" 1>&6
12440 else
12441   cat > conftest.$ac_ext <<EOF
12442 #line 12443 "configure"
12443 #include "confdefs.h"
12444 /* System header to define __stub macros and hopefully few prototypes,
12445     which can conflict with char $ac_func(); below.  */
12446 #include <assert.h>
12447 /* Override any gcc2 internal prototype to avoid an error.  */
12448 /* We use char because int might match the return type of a gcc2
12449     builtin and then its argument prototype would still apply.  */
12450 char $ac_func();
12451
12452 int main() {
12453
12454 /* The GNU C library defines this for functions which it implements
12455     to always fail with ENOSYS.  Some functions are actually named
12456     something starting with __ and the normal name is an alias.  */
12457 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12458 choke me
12459 #else
12460 $ac_func();
12461 #endif
12462
12463 ; return 0; }
12464 EOF
12465 if { (eval echo configure:12466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12466   rm -rf conftest*
12467   eval "ac_cv_func_$ac_func=yes"
12468 else
12469   echo "configure: failed program was:" >&5
12470   cat conftest.$ac_ext >&5
12471   rm -rf conftest*
12472   eval "ac_cv_func_$ac_func=no"
12473 fi
12474 rm -f conftest*
12475 fi
12476
12477 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12478   echo "$ac_t""yes" 1>&6
12479     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12480   cat >> confdefs.h <<EOF
12481 #define $ac_tr_func 1
12482 EOF
12483
12484 else
12485   echo "$ac_t""no" 1>&6
12486 fi
12487 done
12488
12489   fi
12490
12491
12492   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12493 echo "configure:12494: checking for _expf declaration" >&5
12494   if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
12495   echo $ac_n "(cached) $ac_c" 1>&6
12496 else
12497
12498
12499     ac_ext=C
12500 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12501 ac_cpp='$CXXCPP $CPPFLAGS'
12502 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12503 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12504 cross_compiling=$ac_cv_prog_cxx_cross
12505
12506     cat > conftest.$ac_ext <<EOF
12507 #line 12508 "configure"
12508 #include "confdefs.h"
12509 #include <math.h>
12510 int main() {
12511  _expf(0);
12512 ; return 0; }
12513 EOF
12514 if { (eval echo configure:12515: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12515   rm -rf conftest*
12516   glibcpp_cv_func__expf_use=yes
12517 else
12518   echo "configure: failed program was:" >&5
12519   cat conftest.$ac_ext >&5
12520   rm -rf conftest*
12521   glibcpp_cv_func__expf_use=no
12522 fi
12523 rm -f conftest*
12524     ac_ext=c
12525 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12526 ac_cpp='$CPP $CPPFLAGS'
12527 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12528 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12529 cross_compiling=$ac_cv_prog_cc_cross
12530
12531
12532 fi
12533
12534   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
12535   if test x$glibcpp_cv_func__expf_use = x"yes"; then
12536     for ac_func in _expf
12537 do
12538 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12539 echo "configure:12540: checking for $ac_func" >&5
12540 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12541   echo $ac_n "(cached) $ac_c" 1>&6
12542 else
12543   cat > conftest.$ac_ext <<EOF
12544 #line 12545 "configure"
12545 #include "confdefs.h"
12546 /* System header to define __stub macros and hopefully few prototypes,
12547     which can conflict with char $ac_func(); below.  */
12548 #include <assert.h>
12549 /* Override any gcc2 internal prototype to avoid an error.  */
12550 /* We use char because int might match the return type of a gcc2
12551     builtin and then its argument prototype would still apply.  */
12552 char $ac_func();
12553
12554 int main() {
12555
12556 /* The GNU C library defines this for functions which it implements
12557     to always fail with ENOSYS.  Some functions are actually named
12558     something starting with __ and the normal name is an alias.  */
12559 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12560 choke me
12561 #else
12562 $ac_func();
12563 #endif
12564
12565 ; return 0; }
12566 EOF
12567 if { (eval echo configure:12568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12568   rm -rf conftest*
12569   eval "ac_cv_func_$ac_func=yes"
12570 else
12571   echo "configure: failed program was:" >&5
12572   cat conftest.$ac_ext >&5
12573   rm -rf conftest*
12574   eval "ac_cv_func_$ac_func=no"
12575 fi
12576 rm -f conftest*
12577 fi
12578
12579 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12580   echo "$ac_t""yes" 1>&6
12581     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12582   cat >> confdefs.h <<EOF
12583 #define $ac_tr_func 1
12584 EOF
12585
12586 else
12587   echo "$ac_t""no" 1>&6
12588 fi
12589 done
12590
12591   fi
12592
12593
12594   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12595 echo "configure:12596: checking for _fabsf declaration" >&5
12596   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
12597   echo $ac_n "(cached) $ac_c" 1>&6
12598 else
12599
12600
12601     ac_ext=C
12602 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12603 ac_cpp='$CXXCPP $CPPFLAGS'
12604 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12605 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12606 cross_compiling=$ac_cv_prog_cxx_cross
12607
12608     cat > conftest.$ac_ext <<EOF
12609 #line 12610 "configure"
12610 #include "confdefs.h"
12611 #include <math.h>
12612 int main() {
12613  _fabsf(0);
12614 ; return 0; }
12615 EOF
12616 if { (eval echo configure:12617: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12617   rm -rf conftest*
12618   glibcpp_cv_func__fabsf_use=yes
12619 else
12620   echo "configure: failed program was:" >&5
12621   cat conftest.$ac_ext >&5
12622   rm -rf conftest*
12623   glibcpp_cv_func__fabsf_use=no
12624 fi
12625 rm -f conftest*
12626     ac_ext=c
12627 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12628 ac_cpp='$CPP $CPPFLAGS'
12629 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12630 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12631 cross_compiling=$ac_cv_prog_cc_cross
12632
12633
12634 fi
12635
12636   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
12637   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
12638     for ac_func in _fabsf
12639 do
12640 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12641 echo "configure:12642: checking for $ac_func" >&5
12642 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12643   echo $ac_n "(cached) $ac_c" 1>&6
12644 else
12645   cat > conftest.$ac_ext <<EOF
12646 #line 12647 "configure"
12647 #include "confdefs.h"
12648 /* System header to define __stub macros and hopefully few prototypes,
12649     which can conflict with char $ac_func(); below.  */
12650 #include <assert.h>
12651 /* Override any gcc2 internal prototype to avoid an error.  */
12652 /* We use char because int might match the return type of a gcc2
12653     builtin and then its argument prototype would still apply.  */
12654 char $ac_func();
12655
12656 int main() {
12657
12658 /* The GNU C library defines this for functions which it implements
12659     to always fail with ENOSYS.  Some functions are actually named
12660     something starting with __ and the normal name is an alias.  */
12661 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12662 choke me
12663 #else
12664 $ac_func();
12665 #endif
12666
12667 ; return 0; }
12668 EOF
12669 if { (eval echo configure:12670: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12670   rm -rf conftest*
12671   eval "ac_cv_func_$ac_func=yes"
12672 else
12673   echo "configure: failed program was:" >&5
12674   cat conftest.$ac_ext >&5
12675   rm -rf conftest*
12676   eval "ac_cv_func_$ac_func=no"
12677 fi
12678 rm -f conftest*
12679 fi
12680
12681 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12682   echo "$ac_t""yes" 1>&6
12683     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12684   cat >> confdefs.h <<EOF
12685 #define $ac_tr_func 1
12686 EOF
12687
12688 else
12689   echo "$ac_t""no" 1>&6
12690 fi
12691 done
12692
12693   fi
12694
12695
12696   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12697 echo "configure:12698: checking for _floorf declaration" >&5
12698   if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
12699   echo $ac_n "(cached) $ac_c" 1>&6
12700 else
12701
12702
12703     ac_ext=C
12704 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12705 ac_cpp='$CXXCPP $CPPFLAGS'
12706 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12707 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12708 cross_compiling=$ac_cv_prog_cxx_cross
12709
12710     cat > conftest.$ac_ext <<EOF
12711 #line 12712 "configure"
12712 #include "confdefs.h"
12713 #include <math.h>
12714 int main() {
12715  _floorf(0);
12716 ; return 0; }
12717 EOF
12718 if { (eval echo configure:12719: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12719   rm -rf conftest*
12720   glibcpp_cv_func__floorf_use=yes
12721 else
12722   echo "configure: failed program was:" >&5
12723   cat conftest.$ac_ext >&5
12724   rm -rf conftest*
12725   glibcpp_cv_func__floorf_use=no
12726 fi
12727 rm -f conftest*
12728     ac_ext=c
12729 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12730 ac_cpp='$CPP $CPPFLAGS'
12731 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12732 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12733 cross_compiling=$ac_cv_prog_cc_cross
12734
12735
12736 fi
12737
12738   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
12739   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
12740     for ac_func in _floorf
12741 do
12742 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12743 echo "configure:12744: checking for $ac_func" >&5
12744 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12745   echo $ac_n "(cached) $ac_c" 1>&6
12746 else
12747   cat > conftest.$ac_ext <<EOF
12748 #line 12749 "configure"
12749 #include "confdefs.h"
12750 /* System header to define __stub macros and hopefully few prototypes,
12751     which can conflict with char $ac_func(); below.  */
12752 #include <assert.h>
12753 /* Override any gcc2 internal prototype to avoid an error.  */
12754 /* We use char because int might match the return type of a gcc2
12755     builtin and then its argument prototype would still apply.  */
12756 char $ac_func();
12757
12758 int main() {
12759
12760 /* The GNU C library defines this for functions which it implements
12761     to always fail with ENOSYS.  Some functions are actually named
12762     something starting with __ and the normal name is an alias.  */
12763 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12764 choke me
12765 #else
12766 $ac_func();
12767 #endif
12768
12769 ; return 0; }
12770 EOF
12771 if { (eval echo configure:12772: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12772   rm -rf conftest*
12773   eval "ac_cv_func_$ac_func=yes"
12774 else
12775   echo "configure: failed program was:" >&5
12776   cat conftest.$ac_ext >&5
12777   rm -rf conftest*
12778   eval "ac_cv_func_$ac_func=no"
12779 fi
12780 rm -f conftest*
12781 fi
12782
12783 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12784   echo "$ac_t""yes" 1>&6
12785     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12786   cat >> confdefs.h <<EOF
12787 #define $ac_tr_func 1
12788 EOF
12789
12790 else
12791   echo "$ac_t""no" 1>&6
12792 fi
12793 done
12794
12795   fi
12796
12797
12798   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12799 echo "configure:12800: checking for _fmodf declaration" >&5
12800   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
12801   echo $ac_n "(cached) $ac_c" 1>&6
12802 else
12803
12804
12805     ac_ext=C
12806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12807 ac_cpp='$CXXCPP $CPPFLAGS'
12808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12810 cross_compiling=$ac_cv_prog_cxx_cross
12811
12812     cat > conftest.$ac_ext <<EOF
12813 #line 12814 "configure"
12814 #include "confdefs.h"
12815 #include <math.h>
12816 int main() {
12817  _fmodf(0, 0);
12818 ; return 0; }
12819 EOF
12820 if { (eval echo configure:12821: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12821   rm -rf conftest*
12822   glibcpp_cv_func__fmodf_use=yes
12823 else
12824   echo "configure: failed program was:" >&5
12825   cat conftest.$ac_ext >&5
12826   rm -rf conftest*
12827   glibcpp_cv_func__fmodf_use=no
12828 fi
12829 rm -f conftest*
12830     ac_ext=c
12831 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12832 ac_cpp='$CPP $CPPFLAGS'
12833 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12834 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12835 cross_compiling=$ac_cv_prog_cc_cross
12836
12837
12838 fi
12839
12840   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
12841   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
12842     for ac_func in _fmodf
12843 do
12844 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12845 echo "configure:12846: checking for $ac_func" >&5
12846 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12847   echo $ac_n "(cached) $ac_c" 1>&6
12848 else
12849   cat > conftest.$ac_ext <<EOF
12850 #line 12851 "configure"
12851 #include "confdefs.h"
12852 /* System header to define __stub macros and hopefully few prototypes,
12853     which can conflict with char $ac_func(); below.  */
12854 #include <assert.h>
12855 /* Override any gcc2 internal prototype to avoid an error.  */
12856 /* We use char because int might match the return type of a gcc2
12857     builtin and then its argument prototype would still apply.  */
12858 char $ac_func();
12859
12860 int main() {
12861
12862 /* The GNU C library defines this for functions which it implements
12863     to always fail with ENOSYS.  Some functions are actually named
12864     something starting with __ and the normal name is an alias.  */
12865 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12866 choke me
12867 #else
12868 $ac_func();
12869 #endif
12870
12871 ; return 0; }
12872 EOF
12873 if { (eval echo configure:12874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12874   rm -rf conftest*
12875   eval "ac_cv_func_$ac_func=yes"
12876 else
12877   echo "configure: failed program was:" >&5
12878   cat conftest.$ac_ext >&5
12879   rm -rf conftest*
12880   eval "ac_cv_func_$ac_func=no"
12881 fi
12882 rm -f conftest*
12883 fi
12884
12885 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12886   echo "$ac_t""yes" 1>&6
12887     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12888   cat >> confdefs.h <<EOF
12889 #define $ac_tr_func 1
12890 EOF
12891
12892 else
12893   echo "$ac_t""no" 1>&6
12894 fi
12895 done
12896
12897   fi
12898
12899
12900   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12901 echo "configure:12902: checking for _frexpf declaration" >&5
12902   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
12903   echo $ac_n "(cached) $ac_c" 1>&6
12904 else
12905
12906
12907     ac_ext=C
12908 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12909 ac_cpp='$CXXCPP $CPPFLAGS'
12910 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12911 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12912 cross_compiling=$ac_cv_prog_cxx_cross
12913
12914     cat > conftest.$ac_ext <<EOF
12915 #line 12916 "configure"
12916 #include "confdefs.h"
12917 #include <math.h>
12918 int main() {
12919  _frexpf(0, 0);
12920 ; return 0; }
12921 EOF
12922 if { (eval echo configure:12923: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12923   rm -rf conftest*
12924   glibcpp_cv_func__frexpf_use=yes
12925 else
12926   echo "configure: failed program was:" >&5
12927   cat conftest.$ac_ext >&5
12928   rm -rf conftest*
12929   glibcpp_cv_func__frexpf_use=no
12930 fi
12931 rm -f conftest*
12932     ac_ext=c
12933 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12934 ac_cpp='$CPP $CPPFLAGS'
12935 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12936 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12937 cross_compiling=$ac_cv_prog_cc_cross
12938
12939
12940 fi
12941
12942   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
12943   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
12944     for ac_func in _frexpf
12945 do
12946 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12947 echo "configure:12948: checking for $ac_func" >&5
12948 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12949   echo $ac_n "(cached) $ac_c" 1>&6
12950 else
12951   cat > conftest.$ac_ext <<EOF
12952 #line 12953 "configure"
12953 #include "confdefs.h"
12954 /* System header to define __stub macros and hopefully few prototypes,
12955     which can conflict with char $ac_func(); below.  */
12956 #include <assert.h>
12957 /* Override any gcc2 internal prototype to avoid an error.  */
12958 /* We use char because int might match the return type of a gcc2
12959     builtin and then its argument prototype would still apply.  */
12960 char $ac_func();
12961
12962 int main() {
12963
12964 /* The GNU C library defines this for functions which it implements
12965     to always fail with ENOSYS.  Some functions are actually named
12966     something starting with __ and the normal name is an alias.  */
12967 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12968 choke me
12969 #else
12970 $ac_func();
12971 #endif
12972
12973 ; return 0; }
12974 EOF
12975 if { (eval echo configure:12976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12976   rm -rf conftest*
12977   eval "ac_cv_func_$ac_func=yes"
12978 else
12979   echo "configure: failed program was:" >&5
12980   cat conftest.$ac_ext >&5
12981   rm -rf conftest*
12982   eval "ac_cv_func_$ac_func=no"
12983 fi
12984 rm -f conftest*
12985 fi
12986
12987 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12988   echo "$ac_t""yes" 1>&6
12989     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12990   cat >> confdefs.h <<EOF
12991 #define $ac_tr_func 1
12992 EOF
12993
12994 else
12995   echo "$ac_t""no" 1>&6
12996 fi
12997 done
12998
12999   fi
13000
13001
13002   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13003 echo "configure:13004: checking for _ldexpf declaration" >&5
13004   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13005   echo $ac_n "(cached) $ac_c" 1>&6
13006 else
13007
13008
13009     ac_ext=C
13010 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13011 ac_cpp='$CXXCPP $CPPFLAGS'
13012 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13013 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13014 cross_compiling=$ac_cv_prog_cxx_cross
13015
13016     cat > conftest.$ac_ext <<EOF
13017 #line 13018 "configure"
13018 #include "confdefs.h"
13019 #include <math.h>
13020 int main() {
13021  _ldexpf(0, 0);
13022 ; return 0; }
13023 EOF
13024 if { (eval echo configure:13025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13025   rm -rf conftest*
13026   glibcpp_cv_func__ldexpf_use=yes
13027 else
13028   echo "configure: failed program was:" >&5
13029   cat conftest.$ac_ext >&5
13030   rm -rf conftest*
13031   glibcpp_cv_func__ldexpf_use=no
13032 fi
13033 rm -f conftest*
13034     ac_ext=c
13035 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13036 ac_cpp='$CPP $CPPFLAGS'
13037 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13038 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13039 cross_compiling=$ac_cv_prog_cc_cross
13040
13041
13042 fi
13043
13044   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13045   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13046     for ac_func in _ldexpf
13047 do
13048 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13049 echo "configure:13050: checking for $ac_func" >&5
13050 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13051   echo $ac_n "(cached) $ac_c" 1>&6
13052 else
13053   cat > conftest.$ac_ext <<EOF
13054 #line 13055 "configure"
13055 #include "confdefs.h"
13056 /* System header to define __stub macros and hopefully few prototypes,
13057     which can conflict with char $ac_func(); below.  */
13058 #include <assert.h>
13059 /* Override any gcc2 internal prototype to avoid an error.  */
13060 /* We use char because int might match the return type of a gcc2
13061     builtin and then its argument prototype would still apply.  */
13062 char $ac_func();
13063
13064 int main() {
13065
13066 /* The GNU C library defines this for functions which it implements
13067     to always fail with ENOSYS.  Some functions are actually named
13068     something starting with __ and the normal name is an alias.  */
13069 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13070 choke me
13071 #else
13072 $ac_func();
13073 #endif
13074
13075 ; return 0; }
13076 EOF
13077 if { (eval echo configure:13078: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13078   rm -rf conftest*
13079   eval "ac_cv_func_$ac_func=yes"
13080 else
13081   echo "configure: failed program was:" >&5
13082   cat conftest.$ac_ext >&5
13083   rm -rf conftest*
13084   eval "ac_cv_func_$ac_func=no"
13085 fi
13086 rm -f conftest*
13087 fi
13088
13089 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13090   echo "$ac_t""yes" 1>&6
13091     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13092   cat >> confdefs.h <<EOF
13093 #define $ac_tr_func 1
13094 EOF
13095
13096 else
13097   echo "$ac_t""no" 1>&6
13098 fi
13099 done
13100
13101   fi
13102
13103
13104   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
13105 echo "configure:13106: checking for _logf declaration" >&5
13106   if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
13107   echo $ac_n "(cached) $ac_c" 1>&6
13108 else
13109
13110
13111     ac_ext=C
13112 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13113 ac_cpp='$CXXCPP $CPPFLAGS'
13114 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13115 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13116 cross_compiling=$ac_cv_prog_cxx_cross
13117
13118     cat > conftest.$ac_ext <<EOF
13119 #line 13120 "configure"
13120 #include "confdefs.h"
13121 #include <math.h>
13122 int main() {
13123  _logf(0);
13124 ; return 0; }
13125 EOF
13126 if { (eval echo configure:13127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13127   rm -rf conftest*
13128   glibcpp_cv_func__logf_use=yes
13129 else
13130   echo "configure: failed program was:" >&5
13131   cat conftest.$ac_ext >&5
13132   rm -rf conftest*
13133   glibcpp_cv_func__logf_use=no
13134 fi
13135 rm -f conftest*
13136     ac_ext=c
13137 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13138 ac_cpp='$CPP $CPPFLAGS'
13139 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13140 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13141 cross_compiling=$ac_cv_prog_cc_cross
13142
13143
13144 fi
13145
13146   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
13147   if test x$glibcpp_cv_func__logf_use = x"yes"; then
13148     for ac_func in _logf
13149 do
13150 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13151 echo "configure:13152: checking for $ac_func" >&5
13152 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13153   echo $ac_n "(cached) $ac_c" 1>&6
13154 else
13155   cat > conftest.$ac_ext <<EOF
13156 #line 13157 "configure"
13157 #include "confdefs.h"
13158 /* System header to define __stub macros and hopefully few prototypes,
13159     which can conflict with char $ac_func(); below.  */
13160 #include <assert.h>
13161 /* Override any gcc2 internal prototype to avoid an error.  */
13162 /* We use char because int might match the return type of a gcc2
13163     builtin and then its argument prototype would still apply.  */
13164 char $ac_func();
13165
13166 int main() {
13167
13168 /* The GNU C library defines this for functions which it implements
13169     to always fail with ENOSYS.  Some functions are actually named
13170     something starting with __ and the normal name is an alias.  */
13171 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13172 choke me
13173 #else
13174 $ac_func();
13175 #endif
13176
13177 ; return 0; }
13178 EOF
13179 if { (eval echo configure:13180: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13180   rm -rf conftest*
13181   eval "ac_cv_func_$ac_func=yes"
13182 else
13183   echo "configure: failed program was:" >&5
13184   cat conftest.$ac_ext >&5
13185   rm -rf conftest*
13186   eval "ac_cv_func_$ac_func=no"
13187 fi
13188 rm -f conftest*
13189 fi
13190
13191 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13192   echo "$ac_t""yes" 1>&6
13193     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13194   cat >> confdefs.h <<EOF
13195 #define $ac_tr_func 1
13196 EOF
13197
13198 else
13199   echo "$ac_t""no" 1>&6
13200 fi
13201 done
13202
13203   fi
13204
13205
13206   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
13207 echo "configure:13208: checking for _log10f declaration" >&5
13208   if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
13209   echo $ac_n "(cached) $ac_c" 1>&6
13210 else
13211
13212
13213     ac_ext=C
13214 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13215 ac_cpp='$CXXCPP $CPPFLAGS'
13216 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13217 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13218 cross_compiling=$ac_cv_prog_cxx_cross
13219
13220     cat > conftest.$ac_ext <<EOF
13221 #line 13222 "configure"
13222 #include "confdefs.h"
13223 #include <math.h>
13224 int main() {
13225  _log10f(0);
13226 ; return 0; }
13227 EOF
13228 if { (eval echo configure:13229: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13229   rm -rf conftest*
13230   glibcpp_cv_func__log10f_use=yes
13231 else
13232   echo "configure: failed program was:" >&5
13233   cat conftest.$ac_ext >&5
13234   rm -rf conftest*
13235   glibcpp_cv_func__log10f_use=no
13236 fi
13237 rm -f conftest*
13238     ac_ext=c
13239 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13240 ac_cpp='$CPP $CPPFLAGS'
13241 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13242 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13243 cross_compiling=$ac_cv_prog_cc_cross
13244
13245
13246 fi
13247
13248   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
13249   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
13250     for ac_func in _log10f
13251 do
13252 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13253 echo "configure:13254: checking for $ac_func" >&5
13254 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13255   echo $ac_n "(cached) $ac_c" 1>&6
13256 else
13257   cat > conftest.$ac_ext <<EOF
13258 #line 13259 "configure"
13259 #include "confdefs.h"
13260 /* System header to define __stub macros and hopefully few prototypes,
13261     which can conflict with char $ac_func(); below.  */
13262 #include <assert.h>
13263 /* Override any gcc2 internal prototype to avoid an error.  */
13264 /* We use char because int might match the return type of a gcc2
13265     builtin and then its argument prototype would still apply.  */
13266 char $ac_func();
13267
13268 int main() {
13269
13270 /* The GNU C library defines this for functions which it implements
13271     to always fail with ENOSYS.  Some functions are actually named
13272     something starting with __ and the normal name is an alias.  */
13273 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13274 choke me
13275 #else
13276 $ac_func();
13277 #endif
13278
13279 ; return 0; }
13280 EOF
13281 if { (eval echo configure:13282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13282   rm -rf conftest*
13283   eval "ac_cv_func_$ac_func=yes"
13284 else
13285   echo "configure: failed program was:" >&5
13286   cat conftest.$ac_ext >&5
13287   rm -rf conftest*
13288   eval "ac_cv_func_$ac_func=no"
13289 fi
13290 rm -f conftest*
13291 fi
13292
13293 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13294   echo "$ac_t""yes" 1>&6
13295     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13296   cat >> confdefs.h <<EOF
13297 #define $ac_tr_func 1
13298 EOF
13299
13300 else
13301   echo "$ac_t""no" 1>&6
13302 fi
13303 done
13304
13305   fi
13306
13307
13308   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
13309 echo "configure:13310: checking for _modff declaration" >&5
13310   if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
13311   echo $ac_n "(cached) $ac_c" 1>&6
13312 else
13313
13314
13315     ac_ext=C
13316 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13317 ac_cpp='$CXXCPP $CPPFLAGS'
13318 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13319 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13320 cross_compiling=$ac_cv_prog_cxx_cross
13321
13322     cat > conftest.$ac_ext <<EOF
13323 #line 13324 "configure"
13324 #include "confdefs.h"
13325 #include <math.h>
13326 int main() {
13327  _modff(0, 0);
13328 ; return 0; }
13329 EOF
13330 if { (eval echo configure:13331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13331   rm -rf conftest*
13332   glibcpp_cv_func__modff_use=yes
13333 else
13334   echo "configure: failed program was:" >&5
13335   cat conftest.$ac_ext >&5
13336   rm -rf conftest*
13337   glibcpp_cv_func__modff_use=no
13338 fi
13339 rm -f conftest*
13340     ac_ext=c
13341 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13342 ac_cpp='$CPP $CPPFLAGS'
13343 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13344 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13345 cross_compiling=$ac_cv_prog_cc_cross
13346
13347
13348 fi
13349
13350   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
13351   if test x$glibcpp_cv_func__modff_use = x"yes"; then
13352     for ac_func in _modff
13353 do
13354 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13355 echo "configure:13356: checking for $ac_func" >&5
13356 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13357   echo $ac_n "(cached) $ac_c" 1>&6
13358 else
13359   cat > conftest.$ac_ext <<EOF
13360 #line 13361 "configure"
13361 #include "confdefs.h"
13362 /* System header to define __stub macros and hopefully few prototypes,
13363     which can conflict with char $ac_func(); below.  */
13364 #include <assert.h>
13365 /* Override any gcc2 internal prototype to avoid an error.  */
13366 /* We use char because int might match the return type of a gcc2
13367     builtin and then its argument prototype would still apply.  */
13368 char $ac_func();
13369
13370 int main() {
13371
13372 /* The GNU C library defines this for functions which it implements
13373     to always fail with ENOSYS.  Some functions are actually named
13374     something starting with __ and the normal name is an alias.  */
13375 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13376 choke me
13377 #else
13378 $ac_func();
13379 #endif
13380
13381 ; return 0; }
13382 EOF
13383 if { (eval echo configure:13384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13384   rm -rf conftest*
13385   eval "ac_cv_func_$ac_func=yes"
13386 else
13387   echo "configure: failed program was:" >&5
13388   cat conftest.$ac_ext >&5
13389   rm -rf conftest*
13390   eval "ac_cv_func_$ac_func=no"
13391 fi
13392 rm -f conftest*
13393 fi
13394
13395 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13396   echo "$ac_t""yes" 1>&6
13397     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13398   cat >> confdefs.h <<EOF
13399 #define $ac_tr_func 1
13400 EOF
13401
13402 else
13403   echo "$ac_t""no" 1>&6
13404 fi
13405 done
13406
13407   fi
13408
13409
13410   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
13411 echo "configure:13412: checking for _powf declaration" >&5
13412   if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
13413   echo $ac_n "(cached) $ac_c" 1>&6
13414 else
13415
13416
13417     ac_ext=C
13418 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13419 ac_cpp='$CXXCPP $CPPFLAGS'
13420 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13421 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13422 cross_compiling=$ac_cv_prog_cxx_cross
13423
13424     cat > conftest.$ac_ext <<EOF
13425 #line 13426 "configure"
13426 #include "confdefs.h"
13427 #include <math.h>
13428 int main() {
13429  _powf(0, 0);
13430 ; return 0; }
13431 EOF
13432 if { (eval echo configure:13433: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13433   rm -rf conftest*
13434   glibcpp_cv_func__powf_use=yes
13435 else
13436   echo "configure: failed program was:" >&5
13437   cat conftest.$ac_ext >&5
13438   rm -rf conftest*
13439   glibcpp_cv_func__powf_use=no
13440 fi
13441 rm -f conftest*
13442     ac_ext=c
13443 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13444 ac_cpp='$CPP $CPPFLAGS'
13445 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13446 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13447 cross_compiling=$ac_cv_prog_cc_cross
13448
13449
13450 fi
13451
13452   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
13453   if test x$glibcpp_cv_func__powf_use = x"yes"; then
13454     for ac_func in _powf
13455 do
13456 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13457 echo "configure:13458: checking for $ac_func" >&5
13458 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13459   echo $ac_n "(cached) $ac_c" 1>&6
13460 else
13461   cat > conftest.$ac_ext <<EOF
13462 #line 13463 "configure"
13463 #include "confdefs.h"
13464 /* System header to define __stub macros and hopefully few prototypes,
13465     which can conflict with char $ac_func(); below.  */
13466 #include <assert.h>
13467 /* Override any gcc2 internal prototype to avoid an error.  */
13468 /* We use char because int might match the return type of a gcc2
13469     builtin and then its argument prototype would still apply.  */
13470 char $ac_func();
13471
13472 int main() {
13473
13474 /* The GNU C library defines this for functions which it implements
13475     to always fail with ENOSYS.  Some functions are actually named
13476     something starting with __ and the normal name is an alias.  */
13477 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13478 choke me
13479 #else
13480 $ac_func();
13481 #endif
13482
13483 ; return 0; }
13484 EOF
13485 if { (eval echo configure:13486: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13486   rm -rf conftest*
13487   eval "ac_cv_func_$ac_func=yes"
13488 else
13489   echo "configure: failed program was:" >&5
13490   cat conftest.$ac_ext >&5
13491   rm -rf conftest*
13492   eval "ac_cv_func_$ac_func=no"
13493 fi
13494 rm -f conftest*
13495 fi
13496
13497 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13498   echo "$ac_t""yes" 1>&6
13499     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13500   cat >> confdefs.h <<EOF
13501 #define $ac_tr_func 1
13502 EOF
13503
13504 else
13505   echo "$ac_t""no" 1>&6
13506 fi
13507 done
13508
13509   fi
13510
13511
13512   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
13513 echo "configure:13514: checking for _sinf declaration" >&5
13514   if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
13515   echo $ac_n "(cached) $ac_c" 1>&6
13516 else
13517
13518
13519     ac_ext=C
13520 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13521 ac_cpp='$CXXCPP $CPPFLAGS'
13522 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13523 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13524 cross_compiling=$ac_cv_prog_cxx_cross
13525
13526     cat > conftest.$ac_ext <<EOF
13527 #line 13528 "configure"
13528 #include "confdefs.h"
13529 #include <math.h>
13530 int main() {
13531  _sinf(0);
13532 ; return 0; }
13533 EOF
13534 if { (eval echo configure:13535: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13535   rm -rf conftest*
13536   glibcpp_cv_func__sinf_use=yes
13537 else
13538   echo "configure: failed program was:" >&5
13539   cat conftest.$ac_ext >&5
13540   rm -rf conftest*
13541   glibcpp_cv_func__sinf_use=no
13542 fi
13543 rm -f conftest*
13544     ac_ext=c
13545 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13546 ac_cpp='$CPP $CPPFLAGS'
13547 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13548 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13549 cross_compiling=$ac_cv_prog_cc_cross
13550
13551
13552 fi
13553
13554   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
13555   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
13556     for ac_func in _sinf
13557 do
13558 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13559 echo "configure:13560: checking for $ac_func" >&5
13560 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13561   echo $ac_n "(cached) $ac_c" 1>&6
13562 else
13563   cat > conftest.$ac_ext <<EOF
13564 #line 13565 "configure"
13565 #include "confdefs.h"
13566 /* System header to define __stub macros and hopefully few prototypes,
13567     which can conflict with char $ac_func(); below.  */
13568 #include <assert.h>
13569 /* Override any gcc2 internal prototype to avoid an error.  */
13570 /* We use char because int might match the return type of a gcc2
13571     builtin and then its argument prototype would still apply.  */
13572 char $ac_func();
13573
13574 int main() {
13575
13576 /* The GNU C library defines this for functions which it implements
13577     to always fail with ENOSYS.  Some functions are actually named
13578     something starting with __ and the normal name is an alias.  */
13579 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13580 choke me
13581 #else
13582 $ac_func();
13583 #endif
13584
13585 ; return 0; }
13586 EOF
13587 if { (eval echo configure:13588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13588   rm -rf conftest*
13589   eval "ac_cv_func_$ac_func=yes"
13590 else
13591   echo "configure: failed program was:" >&5
13592   cat conftest.$ac_ext >&5
13593   rm -rf conftest*
13594   eval "ac_cv_func_$ac_func=no"
13595 fi
13596 rm -f conftest*
13597 fi
13598
13599 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13600   echo "$ac_t""yes" 1>&6
13601     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13602   cat >> confdefs.h <<EOF
13603 #define $ac_tr_func 1
13604 EOF
13605
13606 else
13607   echo "$ac_t""no" 1>&6
13608 fi
13609 done
13610
13611   fi
13612
13613
13614   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
13615 echo "configure:13616: checking for _sinhf declaration" >&5
13616   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
13617   echo $ac_n "(cached) $ac_c" 1>&6
13618 else
13619
13620
13621     ac_ext=C
13622 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13623 ac_cpp='$CXXCPP $CPPFLAGS'
13624 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13625 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13626 cross_compiling=$ac_cv_prog_cxx_cross
13627
13628     cat > conftest.$ac_ext <<EOF
13629 #line 13630 "configure"
13630 #include "confdefs.h"
13631 #include <math.h>
13632 int main() {
13633  _sinhf(0);
13634 ; return 0; }
13635 EOF
13636 if { (eval echo configure:13637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13637   rm -rf conftest*
13638   glibcpp_cv_func__sinhf_use=yes
13639 else
13640   echo "configure: failed program was:" >&5
13641   cat conftest.$ac_ext >&5
13642   rm -rf conftest*
13643   glibcpp_cv_func__sinhf_use=no
13644 fi
13645 rm -f conftest*
13646     ac_ext=c
13647 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13648 ac_cpp='$CPP $CPPFLAGS'
13649 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13650 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13651 cross_compiling=$ac_cv_prog_cc_cross
13652
13653
13654 fi
13655
13656   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
13657   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
13658     for ac_func in _sinhf
13659 do
13660 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13661 echo "configure:13662: checking for $ac_func" >&5
13662 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13663   echo $ac_n "(cached) $ac_c" 1>&6
13664 else
13665   cat > conftest.$ac_ext <<EOF
13666 #line 13667 "configure"
13667 #include "confdefs.h"
13668 /* System header to define __stub macros and hopefully few prototypes,
13669     which can conflict with char $ac_func(); below.  */
13670 #include <assert.h>
13671 /* Override any gcc2 internal prototype to avoid an error.  */
13672 /* We use char because int might match the return type of a gcc2
13673     builtin and then its argument prototype would still apply.  */
13674 char $ac_func();
13675
13676 int main() {
13677
13678 /* The GNU C library defines this for functions which it implements
13679     to always fail with ENOSYS.  Some functions are actually named
13680     something starting with __ and the normal name is an alias.  */
13681 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13682 choke me
13683 #else
13684 $ac_func();
13685 #endif
13686
13687 ; return 0; }
13688 EOF
13689 if { (eval echo configure:13690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13690   rm -rf conftest*
13691   eval "ac_cv_func_$ac_func=yes"
13692 else
13693   echo "configure: failed program was:" >&5
13694   cat conftest.$ac_ext >&5
13695   rm -rf conftest*
13696   eval "ac_cv_func_$ac_func=no"
13697 fi
13698 rm -f conftest*
13699 fi
13700
13701 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13702   echo "$ac_t""yes" 1>&6
13703     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13704   cat >> confdefs.h <<EOF
13705 #define $ac_tr_func 1
13706 EOF
13707
13708 else
13709   echo "$ac_t""no" 1>&6
13710 fi
13711 done
13712
13713   fi
13714
13715
13716   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
13717 echo "configure:13718: checking for _sqrtf declaration" >&5
13718   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
13719   echo $ac_n "(cached) $ac_c" 1>&6
13720 else
13721
13722
13723     ac_ext=C
13724 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13725 ac_cpp='$CXXCPP $CPPFLAGS'
13726 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13727 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13728 cross_compiling=$ac_cv_prog_cxx_cross
13729
13730     cat > conftest.$ac_ext <<EOF
13731 #line 13732 "configure"
13732 #include "confdefs.h"
13733 #include <math.h>
13734 int main() {
13735  _sqrtf(0);
13736 ; return 0; }
13737 EOF
13738 if { (eval echo configure:13739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13739   rm -rf conftest*
13740   glibcpp_cv_func__sqrtf_use=yes
13741 else
13742   echo "configure: failed program was:" >&5
13743   cat conftest.$ac_ext >&5
13744   rm -rf conftest*
13745   glibcpp_cv_func__sqrtf_use=no
13746 fi
13747 rm -f conftest*
13748     ac_ext=c
13749 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13750 ac_cpp='$CPP $CPPFLAGS'
13751 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13752 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13753 cross_compiling=$ac_cv_prog_cc_cross
13754
13755
13756 fi
13757
13758   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
13759   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
13760     for ac_func in _sqrtf
13761 do
13762 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13763 echo "configure:13764: checking for $ac_func" >&5
13764 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13765   echo $ac_n "(cached) $ac_c" 1>&6
13766 else
13767   cat > conftest.$ac_ext <<EOF
13768 #line 13769 "configure"
13769 #include "confdefs.h"
13770 /* System header to define __stub macros and hopefully few prototypes,
13771     which can conflict with char $ac_func(); below.  */
13772 #include <assert.h>
13773 /* Override any gcc2 internal prototype to avoid an error.  */
13774 /* We use char because int might match the return type of a gcc2
13775     builtin and then its argument prototype would still apply.  */
13776 char $ac_func();
13777
13778 int main() {
13779
13780 /* The GNU C library defines this for functions which it implements
13781     to always fail with ENOSYS.  Some functions are actually named
13782     something starting with __ and the normal name is an alias.  */
13783 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13784 choke me
13785 #else
13786 $ac_func();
13787 #endif
13788
13789 ; return 0; }
13790 EOF
13791 if { (eval echo configure:13792: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13792   rm -rf conftest*
13793   eval "ac_cv_func_$ac_func=yes"
13794 else
13795   echo "configure: failed program was:" >&5
13796   cat conftest.$ac_ext >&5
13797   rm -rf conftest*
13798   eval "ac_cv_func_$ac_func=no"
13799 fi
13800 rm -f conftest*
13801 fi
13802
13803 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13804   echo "$ac_t""yes" 1>&6
13805     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13806   cat >> confdefs.h <<EOF
13807 #define $ac_tr_func 1
13808 EOF
13809
13810 else
13811   echo "$ac_t""no" 1>&6
13812 fi
13813 done
13814
13815   fi
13816
13817
13818   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
13819 echo "configure:13820: checking for _tanf declaration" >&5
13820   if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
13821   echo $ac_n "(cached) $ac_c" 1>&6
13822 else
13823
13824
13825     ac_ext=C
13826 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13827 ac_cpp='$CXXCPP $CPPFLAGS'
13828 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13829 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13830 cross_compiling=$ac_cv_prog_cxx_cross
13831
13832     cat > conftest.$ac_ext <<EOF
13833 #line 13834 "configure"
13834 #include "confdefs.h"
13835 #include <math.h>
13836 int main() {
13837  _tanf(0);
13838 ; return 0; }
13839 EOF
13840 if { (eval echo configure:13841: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13841   rm -rf conftest*
13842   glibcpp_cv_func__tanf_use=yes
13843 else
13844   echo "configure: failed program was:" >&5
13845   cat conftest.$ac_ext >&5
13846   rm -rf conftest*
13847   glibcpp_cv_func__tanf_use=no
13848 fi
13849 rm -f conftest*
13850     ac_ext=c
13851 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13852 ac_cpp='$CPP $CPPFLAGS'
13853 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13854 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13855 cross_compiling=$ac_cv_prog_cc_cross
13856
13857
13858 fi
13859
13860   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
13861   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
13862     for ac_func in _tanf
13863 do
13864 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13865 echo "configure:13866: checking for $ac_func" >&5
13866 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13867   echo $ac_n "(cached) $ac_c" 1>&6
13868 else
13869   cat > conftest.$ac_ext <<EOF
13870 #line 13871 "configure"
13871 #include "confdefs.h"
13872 /* System header to define __stub macros and hopefully few prototypes,
13873     which can conflict with char $ac_func(); below.  */
13874 #include <assert.h>
13875 /* Override any gcc2 internal prototype to avoid an error.  */
13876 /* We use char because int might match the return type of a gcc2
13877     builtin and then its argument prototype would still apply.  */
13878 char $ac_func();
13879
13880 int main() {
13881
13882 /* The GNU C library defines this for functions which it implements
13883     to always fail with ENOSYS.  Some functions are actually named
13884     something starting with __ and the normal name is an alias.  */
13885 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13886 choke me
13887 #else
13888 $ac_func();
13889 #endif
13890
13891 ; return 0; }
13892 EOF
13893 if { (eval echo configure:13894: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13894   rm -rf conftest*
13895   eval "ac_cv_func_$ac_func=yes"
13896 else
13897   echo "configure: failed program was:" >&5
13898   cat conftest.$ac_ext >&5
13899   rm -rf conftest*
13900   eval "ac_cv_func_$ac_func=no"
13901 fi
13902 rm -f conftest*
13903 fi
13904
13905 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13906   echo "$ac_t""yes" 1>&6
13907     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13908   cat >> confdefs.h <<EOF
13909 #define $ac_tr_func 1
13910 EOF
13911
13912 else
13913   echo "$ac_t""no" 1>&6
13914 fi
13915 done
13916
13917   fi
13918
13919
13920   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
13921 echo "configure:13922: checking for _tanhf declaration" >&5
13922   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
13923   echo $ac_n "(cached) $ac_c" 1>&6
13924 else
13925
13926
13927     ac_ext=C
13928 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13929 ac_cpp='$CXXCPP $CPPFLAGS'
13930 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13931 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13932 cross_compiling=$ac_cv_prog_cxx_cross
13933
13934     cat > conftest.$ac_ext <<EOF
13935 #line 13936 "configure"
13936 #include "confdefs.h"
13937 #include <math.h>
13938 int main() {
13939  _tanhf(0);
13940 ; return 0; }
13941 EOF
13942 if { (eval echo configure:13943: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13943   rm -rf conftest*
13944   glibcpp_cv_func__tanhf_use=yes
13945 else
13946   echo "configure: failed program was:" >&5
13947   cat conftest.$ac_ext >&5
13948   rm -rf conftest*
13949   glibcpp_cv_func__tanhf_use=no
13950 fi
13951 rm -f conftest*
13952     ac_ext=c
13953 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13954 ac_cpp='$CPP $CPPFLAGS'
13955 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13956 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13957 cross_compiling=$ac_cv_prog_cc_cross
13958
13959
13960 fi
13961
13962   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
13963   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
13964     for ac_func in _tanhf
13965 do
13966 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13967 echo "configure:13968: checking for $ac_func" >&5
13968 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13969   echo $ac_n "(cached) $ac_c" 1>&6
13970 else
13971   cat > conftest.$ac_ext <<EOF
13972 #line 13973 "configure"
13973 #include "confdefs.h"
13974 /* System header to define __stub macros and hopefully few prototypes,
13975     which can conflict with char $ac_func(); below.  */
13976 #include <assert.h>
13977 /* Override any gcc2 internal prototype to avoid an error.  */
13978 /* We use char because int might match the return type of a gcc2
13979     builtin and then its argument prototype would still apply.  */
13980 char $ac_func();
13981
13982 int main() {
13983
13984 /* The GNU C library defines this for functions which it implements
13985     to always fail with ENOSYS.  Some functions are actually named
13986     something starting with __ and the normal name is an alias.  */
13987 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13988 choke me
13989 #else
13990 $ac_func();
13991 #endif
13992
13993 ; return 0; }
13994 EOF
13995 if { (eval echo configure:13996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13996   rm -rf conftest*
13997   eval "ac_cv_func_$ac_func=yes"
13998 else
13999   echo "configure: failed program was:" >&5
14000   cat conftest.$ac_ext >&5
14001   rm -rf conftest*
14002   eval "ac_cv_func_$ac_func=no"
14003 fi
14004 rm -f conftest*
14005 fi
14006
14007 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14008   echo "$ac_t""yes" 1>&6
14009     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14010   cat >> confdefs.h <<EOF
14011 #define $ac_tr_func 1
14012 EOF
14013
14014 else
14015   echo "$ac_t""no" 1>&6
14016 fi
14017 done
14018
14019   fi
14020
14021
14022   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14023 echo "configure:14024: checking for _sincosf declaration" >&5
14024   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14025   echo $ac_n "(cached) $ac_c" 1>&6
14026 else
14027
14028
14029     ac_ext=C
14030 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14031 ac_cpp='$CXXCPP $CPPFLAGS'
14032 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14033 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14034 cross_compiling=$ac_cv_prog_cxx_cross
14035
14036     cat > conftest.$ac_ext <<EOF
14037 #line 14038 "configure"
14038 #include "confdefs.h"
14039 #include <math.h>
14040 int main() {
14041  _sincosf(0, 0, 0);
14042 ; return 0; }
14043 EOF
14044 if { (eval echo configure:14045: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14045   rm -rf conftest*
14046   glibcpp_cv_func__sincosf_use=yes
14047 else
14048   echo "configure: failed program was:" >&5
14049   cat conftest.$ac_ext >&5
14050   rm -rf conftest*
14051   glibcpp_cv_func__sincosf_use=no
14052 fi
14053 rm -f conftest*
14054     ac_ext=c
14055 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14056 ac_cpp='$CPP $CPPFLAGS'
14057 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14058 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14059 cross_compiling=$ac_cv_prog_cc_cross
14060
14061
14062 fi
14063
14064   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
14065   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
14066     for ac_func in _sincosf
14067 do
14068 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14069 echo "configure:14070: checking for $ac_func" >&5
14070 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14071   echo $ac_n "(cached) $ac_c" 1>&6
14072 else
14073   cat > conftest.$ac_ext <<EOF
14074 #line 14075 "configure"
14075 #include "confdefs.h"
14076 /* System header to define __stub macros and hopefully few prototypes,
14077     which can conflict with char $ac_func(); below.  */
14078 #include <assert.h>
14079 /* Override any gcc2 internal prototype to avoid an error.  */
14080 /* We use char because int might match the return type of a gcc2
14081     builtin and then its argument prototype would still apply.  */
14082 char $ac_func();
14083
14084 int main() {
14085
14086 /* The GNU C library defines this for functions which it implements
14087     to always fail with ENOSYS.  Some functions are actually named
14088     something starting with __ and the normal name is an alias.  */
14089 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14090 choke me
14091 #else
14092 $ac_func();
14093 #endif
14094
14095 ; return 0; }
14096 EOF
14097 if { (eval echo configure:14098: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14098   rm -rf conftest*
14099   eval "ac_cv_func_$ac_func=yes"
14100 else
14101   echo "configure: failed program was:" >&5
14102   cat conftest.$ac_ext >&5
14103   rm -rf conftest*
14104   eval "ac_cv_func_$ac_func=no"
14105 fi
14106 rm -f conftest*
14107 fi
14108
14109 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14110   echo "$ac_t""yes" 1>&6
14111     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14112   cat >> confdefs.h <<EOF
14113 #define $ac_tr_func 1
14114 EOF
14115
14116 else
14117   echo "$ac_t""no" 1>&6
14118 fi
14119 done
14120
14121   fi
14122
14123
14124   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
14125 echo "configure:14126: checking for _finitef declaration" >&5
14126   if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
14127   echo $ac_n "(cached) $ac_c" 1>&6
14128 else
14129
14130
14131     ac_ext=C
14132 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14133 ac_cpp='$CXXCPP $CPPFLAGS'
14134 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14135 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14136 cross_compiling=$ac_cv_prog_cxx_cross
14137
14138     cat > conftest.$ac_ext <<EOF
14139 #line 14140 "configure"
14140 #include "confdefs.h"
14141 #include <math.h>
14142 int main() {
14143  _finitef(0);
14144 ; return 0; }
14145 EOF
14146 if { (eval echo configure:14147: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14147   rm -rf conftest*
14148   glibcpp_cv_func__finitef_use=yes
14149 else
14150   echo "configure: failed program was:" >&5
14151   cat conftest.$ac_ext >&5
14152   rm -rf conftest*
14153   glibcpp_cv_func__finitef_use=no
14154 fi
14155 rm -f conftest*
14156     ac_ext=c
14157 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14158 ac_cpp='$CPP $CPPFLAGS'
14159 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14160 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14161 cross_compiling=$ac_cv_prog_cc_cross
14162
14163
14164 fi
14165
14166   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
14167   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
14168     for ac_func in _finitef
14169 do
14170 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14171 echo "configure:14172: checking for $ac_func" >&5
14172 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14173   echo $ac_n "(cached) $ac_c" 1>&6
14174 else
14175   cat > conftest.$ac_ext <<EOF
14176 #line 14177 "configure"
14177 #include "confdefs.h"
14178 /* System header to define __stub macros and hopefully few prototypes,
14179     which can conflict with char $ac_func(); below.  */
14180 #include <assert.h>
14181 /* Override any gcc2 internal prototype to avoid an error.  */
14182 /* We use char because int might match the return type of a gcc2
14183     builtin and then its argument prototype would still apply.  */
14184 char $ac_func();
14185
14186 int main() {
14187
14188 /* The GNU C library defines this for functions which it implements
14189     to always fail with ENOSYS.  Some functions are actually named
14190     something starting with __ and the normal name is an alias.  */
14191 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14192 choke me
14193 #else
14194 $ac_func();
14195 #endif
14196
14197 ; return 0; }
14198 EOF
14199 if { (eval echo configure:14200: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14200   rm -rf conftest*
14201   eval "ac_cv_func_$ac_func=yes"
14202 else
14203   echo "configure: failed program was:" >&5
14204   cat conftest.$ac_ext >&5
14205   rm -rf conftest*
14206   eval "ac_cv_func_$ac_func=no"
14207 fi
14208 rm -f conftest*
14209 fi
14210
14211 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14212   echo "$ac_t""yes" 1>&6
14213     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14214   cat >> confdefs.h <<EOF
14215 #define $ac_tr_func 1
14216 EOF
14217
14218 else
14219   echo "$ac_t""no" 1>&6
14220 fi
14221 done
14222
14223   fi
14224
14225
14226
14227   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
14228 echo "configure:14229: checking for _isnanl declaration" >&5
14229   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
14230   echo $ac_n "(cached) $ac_c" 1>&6
14231 else
14232
14233
14234     ac_ext=C
14235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14236 ac_cpp='$CXXCPP $CPPFLAGS'
14237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14239 cross_compiling=$ac_cv_prog_cxx_cross
14240
14241     cat > conftest.$ac_ext <<EOF
14242 #line 14243 "configure"
14243 #include "confdefs.h"
14244 #include <math.h>
14245 int main() {
14246  _isnanl(0);
14247 ; return 0; }
14248 EOF
14249 if { (eval echo configure:14250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14250   rm -rf conftest*
14251   glibcpp_cv_func__isnanl_use=yes
14252 else
14253   echo "configure: failed program was:" >&5
14254   cat conftest.$ac_ext >&5
14255   rm -rf conftest*
14256   glibcpp_cv_func__isnanl_use=no
14257 fi
14258 rm -f conftest*
14259     ac_ext=c
14260 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14261 ac_cpp='$CPP $CPPFLAGS'
14262 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14263 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14264 cross_compiling=$ac_cv_prog_cc_cross
14265
14266
14267 fi
14268
14269   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
14270   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
14271     for ac_func in _isnanl
14272 do
14273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14274 echo "configure:14275: checking for $ac_func" >&5
14275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14276   echo $ac_n "(cached) $ac_c" 1>&6
14277 else
14278   cat > conftest.$ac_ext <<EOF
14279 #line 14280 "configure"
14280 #include "confdefs.h"
14281 /* System header to define __stub macros and hopefully few prototypes,
14282     which can conflict with char $ac_func(); below.  */
14283 #include <assert.h>
14284 /* Override any gcc2 internal prototype to avoid an error.  */
14285 /* We use char because int might match the return type of a gcc2
14286     builtin and then its argument prototype would still apply.  */
14287 char $ac_func();
14288
14289 int main() {
14290
14291 /* The GNU C library defines this for functions which it implements
14292     to always fail with ENOSYS.  Some functions are actually named
14293     something starting with __ and the normal name is an alias.  */
14294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14295 choke me
14296 #else
14297 $ac_func();
14298 #endif
14299
14300 ; return 0; }
14301 EOF
14302 if { (eval echo configure:14303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14303   rm -rf conftest*
14304   eval "ac_cv_func_$ac_func=yes"
14305 else
14306   echo "configure: failed program was:" >&5
14307   cat conftest.$ac_ext >&5
14308   rm -rf conftest*
14309   eval "ac_cv_func_$ac_func=no"
14310 fi
14311 rm -f conftest*
14312 fi
14313
14314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14315   echo "$ac_t""yes" 1>&6
14316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14317   cat >> confdefs.h <<EOF
14318 #define $ac_tr_func 1
14319 EOF
14320
14321 else
14322   echo "$ac_t""no" 1>&6
14323 fi
14324 done
14325
14326   fi
14327
14328
14329   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
14330 echo "configure:14331: checking for _isinfl declaration" >&5
14331   if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
14332   echo $ac_n "(cached) $ac_c" 1>&6
14333 else
14334
14335
14336     ac_ext=C
14337 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14338 ac_cpp='$CXXCPP $CPPFLAGS'
14339 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14340 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14341 cross_compiling=$ac_cv_prog_cxx_cross
14342
14343     cat > conftest.$ac_ext <<EOF
14344 #line 14345 "configure"
14345 #include "confdefs.h"
14346 #include <math.h>
14347 int main() {
14348  _isinfl(0);
14349 ; return 0; }
14350 EOF
14351 if { (eval echo configure:14352: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14352   rm -rf conftest*
14353   glibcpp_cv_func__isinfl_use=yes
14354 else
14355   echo "configure: failed program was:" >&5
14356   cat conftest.$ac_ext >&5
14357   rm -rf conftest*
14358   glibcpp_cv_func__isinfl_use=no
14359 fi
14360 rm -f conftest*
14361     ac_ext=c
14362 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14363 ac_cpp='$CPP $CPPFLAGS'
14364 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14365 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14366 cross_compiling=$ac_cv_prog_cc_cross
14367
14368
14369 fi
14370
14371   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
14372   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
14373     for ac_func in _isinfl
14374 do
14375 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14376 echo "configure:14377: checking for $ac_func" >&5
14377 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14378   echo $ac_n "(cached) $ac_c" 1>&6
14379 else
14380   cat > conftest.$ac_ext <<EOF
14381 #line 14382 "configure"
14382 #include "confdefs.h"
14383 /* System header to define __stub macros and hopefully few prototypes,
14384     which can conflict with char $ac_func(); below.  */
14385 #include <assert.h>
14386 /* Override any gcc2 internal prototype to avoid an error.  */
14387 /* We use char because int might match the return type of a gcc2
14388     builtin and then its argument prototype would still apply.  */
14389 char $ac_func();
14390
14391 int main() {
14392
14393 /* The GNU C library defines this for functions which it implements
14394     to always fail with ENOSYS.  Some functions are actually named
14395     something starting with __ and the normal name is an alias.  */
14396 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14397 choke me
14398 #else
14399 $ac_func();
14400 #endif
14401
14402 ; return 0; }
14403 EOF
14404 if { (eval echo configure:14405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14405   rm -rf conftest*
14406   eval "ac_cv_func_$ac_func=yes"
14407 else
14408   echo "configure: failed program was:" >&5
14409   cat conftest.$ac_ext >&5
14410   rm -rf conftest*
14411   eval "ac_cv_func_$ac_func=no"
14412 fi
14413 rm -f conftest*
14414 fi
14415
14416 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14417   echo "$ac_t""yes" 1>&6
14418     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14419   cat >> confdefs.h <<EOF
14420 #define $ac_tr_func 1
14421 EOF
14422
14423 else
14424   echo "$ac_t""no" 1>&6
14425 fi
14426 done
14427
14428   fi
14429
14430
14431   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
14432 echo "configure:14433: checking for _copysignl declaration" >&5
14433   if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
14434   echo $ac_n "(cached) $ac_c" 1>&6
14435 else
14436
14437
14438     ac_ext=C
14439 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14440 ac_cpp='$CXXCPP $CPPFLAGS'
14441 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14442 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14443 cross_compiling=$ac_cv_prog_cxx_cross
14444
14445     cat > conftest.$ac_ext <<EOF
14446 #line 14447 "configure"
14447 #include "confdefs.h"
14448 #include <math.h>
14449 int main() {
14450  _copysignl(0, 0);
14451 ; return 0; }
14452 EOF
14453 if { (eval echo configure:14454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14454   rm -rf conftest*
14455   glibcpp_cv_func__copysignl_use=yes
14456 else
14457   echo "configure: failed program was:" >&5
14458   cat conftest.$ac_ext >&5
14459   rm -rf conftest*
14460   glibcpp_cv_func__copysignl_use=no
14461 fi
14462 rm -f conftest*
14463     ac_ext=c
14464 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14465 ac_cpp='$CPP $CPPFLAGS'
14466 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14467 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14468 cross_compiling=$ac_cv_prog_cc_cross
14469
14470
14471 fi
14472
14473   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
14474   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
14475     for ac_func in _copysignl
14476 do
14477 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14478 echo "configure:14479: checking for $ac_func" >&5
14479 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14480   echo $ac_n "(cached) $ac_c" 1>&6
14481 else
14482   cat > conftest.$ac_ext <<EOF
14483 #line 14484 "configure"
14484 #include "confdefs.h"
14485 /* System header to define __stub macros and hopefully few prototypes,
14486     which can conflict with char $ac_func(); below.  */
14487 #include <assert.h>
14488 /* Override any gcc2 internal prototype to avoid an error.  */
14489 /* We use char because int might match the return type of a gcc2
14490     builtin and then its argument prototype would still apply.  */
14491 char $ac_func();
14492
14493 int main() {
14494
14495 /* The GNU C library defines this for functions which it implements
14496     to always fail with ENOSYS.  Some functions are actually named
14497     something starting with __ and the normal name is an alias.  */
14498 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14499 choke me
14500 #else
14501 $ac_func();
14502 #endif
14503
14504 ; return 0; }
14505 EOF
14506 if { (eval echo configure:14507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14507   rm -rf conftest*
14508   eval "ac_cv_func_$ac_func=yes"
14509 else
14510   echo "configure: failed program was:" >&5
14511   cat conftest.$ac_ext >&5
14512   rm -rf conftest*
14513   eval "ac_cv_func_$ac_func=no"
14514 fi
14515 rm -f conftest*
14516 fi
14517
14518 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14519   echo "$ac_t""yes" 1>&6
14520     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14521   cat >> confdefs.h <<EOF
14522 #define $ac_tr_func 1
14523 EOF
14524
14525 else
14526   echo "$ac_t""no" 1>&6
14527 fi
14528 done
14529
14530   fi
14531
14532
14533   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14534 echo "configure:14535: checking for _acosl declaration" >&5
14535   if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
14536   echo $ac_n "(cached) $ac_c" 1>&6
14537 else
14538
14539
14540     ac_ext=C
14541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14542 ac_cpp='$CXXCPP $CPPFLAGS'
14543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14545 cross_compiling=$ac_cv_prog_cxx_cross
14546
14547     cat > conftest.$ac_ext <<EOF
14548 #line 14549 "configure"
14549 #include "confdefs.h"
14550 #include <math.h>
14551 int main() {
14552  _acosl(0);
14553 ; return 0; }
14554 EOF
14555 if { (eval echo configure:14556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14556   rm -rf conftest*
14557   glibcpp_cv_func__acosl_use=yes
14558 else
14559   echo "configure: failed program was:" >&5
14560   cat conftest.$ac_ext >&5
14561   rm -rf conftest*
14562   glibcpp_cv_func__acosl_use=no
14563 fi
14564 rm -f conftest*
14565     ac_ext=c
14566 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14567 ac_cpp='$CPP $CPPFLAGS'
14568 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14569 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14570 cross_compiling=$ac_cv_prog_cc_cross
14571
14572
14573 fi
14574
14575   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
14576   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
14577     for ac_func in _acosl
14578 do
14579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14580 echo "configure:14581: checking for $ac_func" >&5
14581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14582   echo $ac_n "(cached) $ac_c" 1>&6
14583 else
14584   cat > conftest.$ac_ext <<EOF
14585 #line 14586 "configure"
14586 #include "confdefs.h"
14587 /* System header to define __stub macros and hopefully few prototypes,
14588     which can conflict with char $ac_func(); below.  */
14589 #include <assert.h>
14590 /* Override any gcc2 internal prototype to avoid an error.  */
14591 /* We use char because int might match the return type of a gcc2
14592     builtin and then its argument prototype would still apply.  */
14593 char $ac_func();
14594
14595 int main() {
14596
14597 /* The GNU C library defines this for functions which it implements
14598     to always fail with ENOSYS.  Some functions are actually named
14599     something starting with __ and the normal name is an alias.  */
14600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14601 choke me
14602 #else
14603 $ac_func();
14604 #endif
14605
14606 ; return 0; }
14607 EOF
14608 if { (eval echo configure:14609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14609   rm -rf conftest*
14610   eval "ac_cv_func_$ac_func=yes"
14611 else
14612   echo "configure: failed program was:" >&5
14613   cat conftest.$ac_ext >&5
14614   rm -rf conftest*
14615   eval "ac_cv_func_$ac_func=no"
14616 fi
14617 rm -f conftest*
14618 fi
14619
14620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14621   echo "$ac_t""yes" 1>&6
14622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14623   cat >> confdefs.h <<EOF
14624 #define $ac_tr_func 1
14625 EOF
14626
14627 else
14628   echo "$ac_t""no" 1>&6
14629 fi
14630 done
14631
14632   fi
14633
14634
14635   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14636 echo "configure:14637: checking for _asinl declaration" >&5
14637   if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
14638   echo $ac_n "(cached) $ac_c" 1>&6
14639 else
14640
14641
14642     ac_ext=C
14643 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14644 ac_cpp='$CXXCPP $CPPFLAGS'
14645 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14646 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14647 cross_compiling=$ac_cv_prog_cxx_cross
14648
14649     cat > conftest.$ac_ext <<EOF
14650 #line 14651 "configure"
14651 #include "confdefs.h"
14652 #include <math.h>
14653 int main() {
14654  _asinl(0);
14655 ; return 0; }
14656 EOF
14657 if { (eval echo configure:14658: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14658   rm -rf conftest*
14659   glibcpp_cv_func__asinl_use=yes
14660 else
14661   echo "configure: failed program was:" >&5
14662   cat conftest.$ac_ext >&5
14663   rm -rf conftest*
14664   glibcpp_cv_func__asinl_use=no
14665 fi
14666 rm -f conftest*
14667     ac_ext=c
14668 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14669 ac_cpp='$CPP $CPPFLAGS'
14670 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14671 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14672 cross_compiling=$ac_cv_prog_cc_cross
14673
14674
14675 fi
14676
14677   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
14678   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
14679     for ac_func in _asinl
14680 do
14681 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14682 echo "configure:14683: checking for $ac_func" >&5
14683 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14684   echo $ac_n "(cached) $ac_c" 1>&6
14685 else
14686   cat > conftest.$ac_ext <<EOF
14687 #line 14688 "configure"
14688 #include "confdefs.h"
14689 /* System header to define __stub macros and hopefully few prototypes,
14690     which can conflict with char $ac_func(); below.  */
14691 #include <assert.h>
14692 /* Override any gcc2 internal prototype to avoid an error.  */
14693 /* We use char because int might match the return type of a gcc2
14694     builtin and then its argument prototype would still apply.  */
14695 char $ac_func();
14696
14697 int main() {
14698
14699 /* The GNU C library defines this for functions which it implements
14700     to always fail with ENOSYS.  Some functions are actually named
14701     something starting with __ and the normal name is an alias.  */
14702 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14703 choke me
14704 #else
14705 $ac_func();
14706 #endif
14707
14708 ; return 0; }
14709 EOF
14710 if { (eval echo configure:14711: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14711   rm -rf conftest*
14712   eval "ac_cv_func_$ac_func=yes"
14713 else
14714   echo "configure: failed program was:" >&5
14715   cat conftest.$ac_ext >&5
14716   rm -rf conftest*
14717   eval "ac_cv_func_$ac_func=no"
14718 fi
14719 rm -f conftest*
14720 fi
14721
14722 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14723   echo "$ac_t""yes" 1>&6
14724     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14725   cat >> confdefs.h <<EOF
14726 #define $ac_tr_func 1
14727 EOF
14728
14729 else
14730   echo "$ac_t""no" 1>&6
14731 fi
14732 done
14733
14734   fi
14735
14736
14737   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14738 echo "configure:14739: checking for _atanl declaration" >&5
14739   if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
14740   echo $ac_n "(cached) $ac_c" 1>&6
14741 else
14742
14743
14744     ac_ext=C
14745 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14746 ac_cpp='$CXXCPP $CPPFLAGS'
14747 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14748 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14749 cross_compiling=$ac_cv_prog_cxx_cross
14750
14751     cat > conftest.$ac_ext <<EOF
14752 #line 14753 "configure"
14753 #include "confdefs.h"
14754 #include <math.h>
14755 int main() {
14756  _atanl(0);
14757 ; return 0; }
14758 EOF
14759 if { (eval echo configure:14760: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14760   rm -rf conftest*
14761   glibcpp_cv_func__atanl_use=yes
14762 else
14763   echo "configure: failed program was:" >&5
14764   cat conftest.$ac_ext >&5
14765   rm -rf conftest*
14766   glibcpp_cv_func__atanl_use=no
14767 fi
14768 rm -f conftest*
14769     ac_ext=c
14770 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14771 ac_cpp='$CPP $CPPFLAGS'
14772 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14773 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14774 cross_compiling=$ac_cv_prog_cc_cross
14775
14776
14777 fi
14778
14779   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
14780   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
14781     for ac_func in _atanl
14782 do
14783 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14784 echo "configure:14785: checking for $ac_func" >&5
14785 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14786   echo $ac_n "(cached) $ac_c" 1>&6
14787 else
14788   cat > conftest.$ac_ext <<EOF
14789 #line 14790 "configure"
14790 #include "confdefs.h"
14791 /* System header to define __stub macros and hopefully few prototypes,
14792     which can conflict with char $ac_func(); below.  */
14793 #include <assert.h>
14794 /* Override any gcc2 internal prototype to avoid an error.  */
14795 /* We use char because int might match the return type of a gcc2
14796     builtin and then its argument prototype would still apply.  */
14797 char $ac_func();
14798
14799 int main() {
14800
14801 /* The GNU C library defines this for functions which it implements
14802     to always fail with ENOSYS.  Some functions are actually named
14803     something starting with __ and the normal name is an alias.  */
14804 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14805 choke me
14806 #else
14807 $ac_func();
14808 #endif
14809
14810 ; return 0; }
14811 EOF
14812 if { (eval echo configure:14813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14813   rm -rf conftest*
14814   eval "ac_cv_func_$ac_func=yes"
14815 else
14816   echo "configure: failed program was:" >&5
14817   cat conftest.$ac_ext >&5
14818   rm -rf conftest*
14819   eval "ac_cv_func_$ac_func=no"
14820 fi
14821 rm -f conftest*
14822 fi
14823
14824 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14825   echo "$ac_t""yes" 1>&6
14826     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14827   cat >> confdefs.h <<EOF
14828 #define $ac_tr_func 1
14829 EOF
14830
14831 else
14832   echo "$ac_t""no" 1>&6
14833 fi
14834 done
14835
14836   fi
14837
14838
14839   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14840 echo "configure:14841: checking for _atan2l declaration" >&5
14841   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
14842   echo $ac_n "(cached) $ac_c" 1>&6
14843 else
14844
14845
14846     ac_ext=C
14847 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14848 ac_cpp='$CXXCPP $CPPFLAGS'
14849 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14850 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14851 cross_compiling=$ac_cv_prog_cxx_cross
14852
14853     cat > conftest.$ac_ext <<EOF
14854 #line 14855 "configure"
14855 #include "confdefs.h"
14856 #include <math.h>
14857 int main() {
14858  _atan2l(0, 0);
14859 ; return 0; }
14860 EOF
14861 if { (eval echo configure:14862: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14862   rm -rf conftest*
14863   glibcpp_cv_func__atan2l_use=yes
14864 else
14865   echo "configure: failed program was:" >&5
14866   cat conftest.$ac_ext >&5
14867   rm -rf conftest*
14868   glibcpp_cv_func__atan2l_use=no
14869 fi
14870 rm -f conftest*
14871     ac_ext=c
14872 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14873 ac_cpp='$CPP $CPPFLAGS'
14874 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14875 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14876 cross_compiling=$ac_cv_prog_cc_cross
14877
14878
14879 fi
14880
14881   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
14882   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
14883     for ac_func in _atan2l
14884 do
14885 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14886 echo "configure:14887: checking for $ac_func" >&5
14887 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14888   echo $ac_n "(cached) $ac_c" 1>&6
14889 else
14890   cat > conftest.$ac_ext <<EOF
14891 #line 14892 "configure"
14892 #include "confdefs.h"
14893 /* System header to define __stub macros and hopefully few prototypes,
14894     which can conflict with char $ac_func(); below.  */
14895 #include <assert.h>
14896 /* Override any gcc2 internal prototype to avoid an error.  */
14897 /* We use char because int might match the return type of a gcc2
14898     builtin and then its argument prototype would still apply.  */
14899 char $ac_func();
14900
14901 int main() {
14902
14903 /* The GNU C library defines this for functions which it implements
14904     to always fail with ENOSYS.  Some functions are actually named
14905     something starting with __ and the normal name is an alias.  */
14906 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14907 choke me
14908 #else
14909 $ac_func();
14910 #endif
14911
14912 ; return 0; }
14913 EOF
14914 if { (eval echo configure:14915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14915   rm -rf conftest*
14916   eval "ac_cv_func_$ac_func=yes"
14917 else
14918   echo "configure: failed program was:" >&5
14919   cat conftest.$ac_ext >&5
14920   rm -rf conftest*
14921   eval "ac_cv_func_$ac_func=no"
14922 fi
14923 rm -f conftest*
14924 fi
14925
14926 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14927   echo "$ac_t""yes" 1>&6
14928     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14929   cat >> confdefs.h <<EOF
14930 #define $ac_tr_func 1
14931 EOF
14932
14933 else
14934   echo "$ac_t""no" 1>&6
14935 fi
14936 done
14937
14938   fi
14939
14940
14941   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
14942 echo "configure:14943: checking for _ceill declaration" >&5
14943   if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
14944   echo $ac_n "(cached) $ac_c" 1>&6
14945 else
14946
14947
14948     ac_ext=C
14949 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14950 ac_cpp='$CXXCPP $CPPFLAGS'
14951 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14952 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14953 cross_compiling=$ac_cv_prog_cxx_cross
14954
14955     cat > conftest.$ac_ext <<EOF
14956 #line 14957 "configure"
14957 #include "confdefs.h"
14958 #include <math.h>
14959 int main() {
14960  _ceill(0);
14961 ; return 0; }
14962 EOF
14963 if { (eval echo configure:14964: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14964   rm -rf conftest*
14965   glibcpp_cv_func__ceill_use=yes
14966 else
14967   echo "configure: failed program was:" >&5
14968   cat conftest.$ac_ext >&5
14969   rm -rf conftest*
14970   glibcpp_cv_func__ceill_use=no
14971 fi
14972 rm -f conftest*
14973     ac_ext=c
14974 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14975 ac_cpp='$CPP $CPPFLAGS'
14976 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14977 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14978 cross_compiling=$ac_cv_prog_cc_cross
14979
14980
14981 fi
14982
14983   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
14984   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
14985     for ac_func in _ceill
14986 do
14987 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14988 echo "configure:14989: checking for $ac_func" >&5
14989 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14990   echo $ac_n "(cached) $ac_c" 1>&6
14991 else
14992   cat > conftest.$ac_ext <<EOF
14993 #line 14994 "configure"
14994 #include "confdefs.h"
14995 /* System header to define __stub macros and hopefully few prototypes,
14996     which can conflict with char $ac_func(); below.  */
14997 #include <assert.h>
14998 /* Override any gcc2 internal prototype to avoid an error.  */
14999 /* We use char because int might match the return type of a gcc2
15000     builtin and then its argument prototype would still apply.  */
15001 char $ac_func();
15002
15003 int main() {
15004
15005 /* The GNU C library defines this for functions which it implements
15006     to always fail with ENOSYS.  Some functions are actually named
15007     something starting with __ and the normal name is an alias.  */
15008 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15009 choke me
15010 #else
15011 $ac_func();
15012 #endif
15013
15014 ; return 0; }
15015 EOF
15016 if { (eval echo configure:15017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15017   rm -rf conftest*
15018   eval "ac_cv_func_$ac_func=yes"
15019 else
15020   echo "configure: failed program was:" >&5
15021   cat conftest.$ac_ext >&5
15022   rm -rf conftest*
15023   eval "ac_cv_func_$ac_func=no"
15024 fi
15025 rm -f conftest*
15026 fi
15027
15028 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15029   echo "$ac_t""yes" 1>&6
15030     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15031   cat >> confdefs.h <<EOF
15032 #define $ac_tr_func 1
15033 EOF
15034
15035 else
15036   echo "$ac_t""no" 1>&6
15037 fi
15038 done
15039
15040   fi
15041
15042
15043   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
15044 echo "configure:15045: checking for _cosl declaration" >&5
15045   if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
15046   echo $ac_n "(cached) $ac_c" 1>&6
15047 else
15048
15049
15050     ac_ext=C
15051 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15052 ac_cpp='$CXXCPP $CPPFLAGS'
15053 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15054 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15055 cross_compiling=$ac_cv_prog_cxx_cross
15056
15057     cat > conftest.$ac_ext <<EOF
15058 #line 15059 "configure"
15059 #include "confdefs.h"
15060 #include <math.h>
15061 int main() {
15062  _cosl(0);
15063 ; return 0; }
15064 EOF
15065 if { (eval echo configure:15066: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15066   rm -rf conftest*
15067   glibcpp_cv_func__cosl_use=yes
15068 else
15069   echo "configure: failed program was:" >&5
15070   cat conftest.$ac_ext >&5
15071   rm -rf conftest*
15072   glibcpp_cv_func__cosl_use=no
15073 fi
15074 rm -f conftest*
15075     ac_ext=c
15076 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15077 ac_cpp='$CPP $CPPFLAGS'
15078 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15079 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15080 cross_compiling=$ac_cv_prog_cc_cross
15081
15082
15083 fi
15084
15085   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
15086   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
15087     for ac_func in _cosl
15088 do
15089 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15090 echo "configure:15091: checking for $ac_func" >&5
15091 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15092   echo $ac_n "(cached) $ac_c" 1>&6
15093 else
15094   cat > conftest.$ac_ext <<EOF
15095 #line 15096 "configure"
15096 #include "confdefs.h"
15097 /* System header to define __stub macros and hopefully few prototypes,
15098     which can conflict with char $ac_func(); below.  */
15099 #include <assert.h>
15100 /* Override any gcc2 internal prototype to avoid an error.  */
15101 /* We use char because int might match the return type of a gcc2
15102     builtin and then its argument prototype would still apply.  */
15103 char $ac_func();
15104
15105 int main() {
15106
15107 /* The GNU C library defines this for functions which it implements
15108     to always fail with ENOSYS.  Some functions are actually named
15109     something starting with __ and the normal name is an alias.  */
15110 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15111 choke me
15112 #else
15113 $ac_func();
15114 #endif
15115
15116 ; return 0; }
15117 EOF
15118 if { (eval echo configure:15119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15119   rm -rf conftest*
15120   eval "ac_cv_func_$ac_func=yes"
15121 else
15122   echo "configure: failed program was:" >&5
15123   cat conftest.$ac_ext >&5
15124   rm -rf conftest*
15125   eval "ac_cv_func_$ac_func=no"
15126 fi
15127 rm -f conftest*
15128 fi
15129
15130 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15131   echo "$ac_t""yes" 1>&6
15132     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15133   cat >> confdefs.h <<EOF
15134 #define $ac_tr_func 1
15135 EOF
15136
15137 else
15138   echo "$ac_t""no" 1>&6
15139 fi
15140 done
15141
15142   fi
15143
15144
15145   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
15146 echo "configure:15147: checking for _coshl declaration" >&5
15147   if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
15148   echo $ac_n "(cached) $ac_c" 1>&6
15149 else
15150
15151
15152     ac_ext=C
15153 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15154 ac_cpp='$CXXCPP $CPPFLAGS'
15155 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15156 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15157 cross_compiling=$ac_cv_prog_cxx_cross
15158
15159     cat > conftest.$ac_ext <<EOF
15160 #line 15161 "configure"
15161 #include "confdefs.h"
15162 #include <math.h>
15163 int main() {
15164  _coshl(0);
15165 ; return 0; }
15166 EOF
15167 if { (eval echo configure:15168: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15168   rm -rf conftest*
15169   glibcpp_cv_func__coshl_use=yes
15170 else
15171   echo "configure: failed program was:" >&5
15172   cat conftest.$ac_ext >&5
15173   rm -rf conftest*
15174   glibcpp_cv_func__coshl_use=no
15175 fi
15176 rm -f conftest*
15177     ac_ext=c
15178 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15179 ac_cpp='$CPP $CPPFLAGS'
15180 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15181 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15182 cross_compiling=$ac_cv_prog_cc_cross
15183
15184
15185 fi
15186
15187   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
15188   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
15189     for ac_func in _coshl
15190 do
15191 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15192 echo "configure:15193: checking for $ac_func" >&5
15193 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15194   echo $ac_n "(cached) $ac_c" 1>&6
15195 else
15196   cat > conftest.$ac_ext <<EOF
15197 #line 15198 "configure"
15198 #include "confdefs.h"
15199 /* System header to define __stub macros and hopefully few prototypes,
15200     which can conflict with char $ac_func(); below.  */
15201 #include <assert.h>
15202 /* Override any gcc2 internal prototype to avoid an error.  */
15203 /* We use char because int might match the return type of a gcc2
15204     builtin and then its argument prototype would still apply.  */
15205 char $ac_func();
15206
15207 int main() {
15208
15209 /* The GNU C library defines this for functions which it implements
15210     to always fail with ENOSYS.  Some functions are actually named
15211     something starting with __ and the normal name is an alias.  */
15212 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15213 choke me
15214 #else
15215 $ac_func();
15216 #endif
15217
15218 ; return 0; }
15219 EOF
15220 if { (eval echo configure:15221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15221   rm -rf conftest*
15222   eval "ac_cv_func_$ac_func=yes"
15223 else
15224   echo "configure: failed program was:" >&5
15225   cat conftest.$ac_ext >&5
15226   rm -rf conftest*
15227   eval "ac_cv_func_$ac_func=no"
15228 fi
15229 rm -f conftest*
15230 fi
15231
15232 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15233   echo "$ac_t""yes" 1>&6
15234     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15235   cat >> confdefs.h <<EOF
15236 #define $ac_tr_func 1
15237 EOF
15238
15239 else
15240   echo "$ac_t""no" 1>&6
15241 fi
15242 done
15243
15244   fi
15245
15246
15247   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
15248 echo "configure:15249: checking for _expl declaration" >&5
15249   if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
15250   echo $ac_n "(cached) $ac_c" 1>&6
15251 else
15252
15253
15254     ac_ext=C
15255 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15256 ac_cpp='$CXXCPP $CPPFLAGS'
15257 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15258 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15259 cross_compiling=$ac_cv_prog_cxx_cross
15260
15261     cat > conftest.$ac_ext <<EOF
15262 #line 15263 "configure"
15263 #include "confdefs.h"
15264 #include <math.h>
15265 int main() {
15266  _expl(0);
15267 ; return 0; }
15268 EOF
15269 if { (eval echo configure:15270: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15270   rm -rf conftest*
15271   glibcpp_cv_func__expl_use=yes
15272 else
15273   echo "configure: failed program was:" >&5
15274   cat conftest.$ac_ext >&5
15275   rm -rf conftest*
15276   glibcpp_cv_func__expl_use=no
15277 fi
15278 rm -f conftest*
15279     ac_ext=c
15280 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15281 ac_cpp='$CPP $CPPFLAGS'
15282 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15283 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15284 cross_compiling=$ac_cv_prog_cc_cross
15285
15286
15287 fi
15288
15289   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
15290   if test x$glibcpp_cv_func__expl_use = x"yes"; then
15291     for ac_func in _expl
15292 do
15293 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15294 echo "configure:15295: checking for $ac_func" >&5
15295 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15296   echo $ac_n "(cached) $ac_c" 1>&6
15297 else
15298   cat > conftest.$ac_ext <<EOF
15299 #line 15300 "configure"
15300 #include "confdefs.h"
15301 /* System header to define __stub macros and hopefully few prototypes,
15302     which can conflict with char $ac_func(); below.  */
15303 #include <assert.h>
15304 /* Override any gcc2 internal prototype to avoid an error.  */
15305 /* We use char because int might match the return type of a gcc2
15306     builtin and then its argument prototype would still apply.  */
15307 char $ac_func();
15308
15309 int main() {
15310
15311 /* The GNU C library defines this for functions which it implements
15312     to always fail with ENOSYS.  Some functions are actually named
15313     something starting with __ and the normal name is an alias.  */
15314 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15315 choke me
15316 #else
15317 $ac_func();
15318 #endif
15319
15320 ; return 0; }
15321 EOF
15322 if { (eval echo configure:15323: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15323   rm -rf conftest*
15324   eval "ac_cv_func_$ac_func=yes"
15325 else
15326   echo "configure: failed program was:" >&5
15327   cat conftest.$ac_ext >&5
15328   rm -rf conftest*
15329   eval "ac_cv_func_$ac_func=no"
15330 fi
15331 rm -f conftest*
15332 fi
15333
15334 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15335   echo "$ac_t""yes" 1>&6
15336     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15337   cat >> confdefs.h <<EOF
15338 #define $ac_tr_func 1
15339 EOF
15340
15341 else
15342   echo "$ac_t""no" 1>&6
15343 fi
15344 done
15345
15346   fi
15347
15348
15349   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
15350 echo "configure:15351: checking for _fabsl declaration" >&5
15351   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
15352   echo $ac_n "(cached) $ac_c" 1>&6
15353 else
15354
15355
15356     ac_ext=C
15357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15358 ac_cpp='$CXXCPP $CPPFLAGS'
15359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15361 cross_compiling=$ac_cv_prog_cxx_cross
15362
15363     cat > conftest.$ac_ext <<EOF
15364 #line 15365 "configure"
15365 #include "confdefs.h"
15366 #include <math.h>
15367 int main() {
15368  _fabsl(0);
15369 ; return 0; }
15370 EOF
15371 if { (eval echo configure:15372: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15372   rm -rf conftest*
15373   glibcpp_cv_func__fabsl_use=yes
15374 else
15375   echo "configure: failed program was:" >&5
15376   cat conftest.$ac_ext >&5
15377   rm -rf conftest*
15378   glibcpp_cv_func__fabsl_use=no
15379 fi
15380 rm -f conftest*
15381     ac_ext=c
15382 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15383 ac_cpp='$CPP $CPPFLAGS'
15384 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15385 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15386 cross_compiling=$ac_cv_prog_cc_cross
15387
15388
15389 fi
15390
15391   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
15392   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
15393     for ac_func in _fabsl
15394 do
15395 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15396 echo "configure:15397: checking for $ac_func" >&5
15397 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15398   echo $ac_n "(cached) $ac_c" 1>&6
15399 else
15400   cat > conftest.$ac_ext <<EOF
15401 #line 15402 "configure"
15402 #include "confdefs.h"
15403 /* System header to define __stub macros and hopefully few prototypes,
15404     which can conflict with char $ac_func(); below.  */
15405 #include <assert.h>
15406 /* Override any gcc2 internal prototype to avoid an error.  */
15407 /* We use char because int might match the return type of a gcc2
15408     builtin and then its argument prototype would still apply.  */
15409 char $ac_func();
15410
15411 int main() {
15412
15413 /* The GNU C library defines this for functions which it implements
15414     to always fail with ENOSYS.  Some functions are actually named
15415     something starting with __ and the normal name is an alias.  */
15416 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15417 choke me
15418 #else
15419 $ac_func();
15420 #endif
15421
15422 ; return 0; }
15423 EOF
15424 if { (eval echo configure:15425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15425   rm -rf conftest*
15426   eval "ac_cv_func_$ac_func=yes"
15427 else
15428   echo "configure: failed program was:" >&5
15429   cat conftest.$ac_ext >&5
15430   rm -rf conftest*
15431   eval "ac_cv_func_$ac_func=no"
15432 fi
15433 rm -f conftest*
15434 fi
15435
15436 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15437   echo "$ac_t""yes" 1>&6
15438     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15439   cat >> confdefs.h <<EOF
15440 #define $ac_tr_func 1
15441 EOF
15442
15443 else
15444   echo "$ac_t""no" 1>&6
15445 fi
15446 done
15447
15448   fi
15449
15450
15451   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
15452 echo "configure:15453: checking for _floorl declaration" >&5
15453   if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
15454   echo $ac_n "(cached) $ac_c" 1>&6
15455 else
15456
15457
15458     ac_ext=C
15459 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15460 ac_cpp='$CXXCPP $CPPFLAGS'
15461 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15462 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15463 cross_compiling=$ac_cv_prog_cxx_cross
15464
15465     cat > conftest.$ac_ext <<EOF
15466 #line 15467 "configure"
15467 #include "confdefs.h"
15468 #include <math.h>
15469 int main() {
15470  _floorl(0);
15471 ; return 0; }
15472 EOF
15473 if { (eval echo configure:15474: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15474   rm -rf conftest*
15475   glibcpp_cv_func__floorl_use=yes
15476 else
15477   echo "configure: failed program was:" >&5
15478   cat conftest.$ac_ext >&5
15479   rm -rf conftest*
15480   glibcpp_cv_func__floorl_use=no
15481 fi
15482 rm -f conftest*
15483     ac_ext=c
15484 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15485 ac_cpp='$CPP $CPPFLAGS'
15486 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15487 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15488 cross_compiling=$ac_cv_prog_cc_cross
15489
15490
15491 fi
15492
15493   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
15494   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
15495     for ac_func in _floorl
15496 do
15497 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15498 echo "configure:15499: checking for $ac_func" >&5
15499 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15500   echo $ac_n "(cached) $ac_c" 1>&6
15501 else
15502   cat > conftest.$ac_ext <<EOF
15503 #line 15504 "configure"
15504 #include "confdefs.h"
15505 /* System header to define __stub macros and hopefully few prototypes,
15506     which can conflict with char $ac_func(); below.  */
15507 #include <assert.h>
15508 /* Override any gcc2 internal prototype to avoid an error.  */
15509 /* We use char because int might match the return type of a gcc2
15510     builtin and then its argument prototype would still apply.  */
15511 char $ac_func();
15512
15513 int main() {
15514
15515 /* The GNU C library defines this for functions which it implements
15516     to always fail with ENOSYS.  Some functions are actually named
15517     something starting with __ and the normal name is an alias.  */
15518 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15519 choke me
15520 #else
15521 $ac_func();
15522 #endif
15523
15524 ; return 0; }
15525 EOF
15526 if { (eval echo configure:15527: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15527   rm -rf conftest*
15528   eval "ac_cv_func_$ac_func=yes"
15529 else
15530   echo "configure: failed program was:" >&5
15531   cat conftest.$ac_ext >&5
15532   rm -rf conftest*
15533   eval "ac_cv_func_$ac_func=no"
15534 fi
15535 rm -f conftest*
15536 fi
15537
15538 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15539   echo "$ac_t""yes" 1>&6
15540     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15541   cat >> confdefs.h <<EOF
15542 #define $ac_tr_func 1
15543 EOF
15544
15545 else
15546   echo "$ac_t""no" 1>&6
15547 fi
15548 done
15549
15550   fi
15551
15552
15553   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
15554 echo "configure:15555: checking for _fmodl declaration" >&5
15555   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
15556   echo $ac_n "(cached) $ac_c" 1>&6
15557 else
15558
15559
15560     ac_ext=C
15561 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15562 ac_cpp='$CXXCPP $CPPFLAGS'
15563 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15564 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15565 cross_compiling=$ac_cv_prog_cxx_cross
15566
15567     cat > conftest.$ac_ext <<EOF
15568 #line 15569 "configure"
15569 #include "confdefs.h"
15570 #include <math.h>
15571 int main() {
15572  _fmodl(0, 0);
15573 ; return 0; }
15574 EOF
15575 if { (eval echo configure:15576: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15576   rm -rf conftest*
15577   glibcpp_cv_func__fmodl_use=yes
15578 else
15579   echo "configure: failed program was:" >&5
15580   cat conftest.$ac_ext >&5
15581   rm -rf conftest*
15582   glibcpp_cv_func__fmodl_use=no
15583 fi
15584 rm -f conftest*
15585     ac_ext=c
15586 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15587 ac_cpp='$CPP $CPPFLAGS'
15588 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15589 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15590 cross_compiling=$ac_cv_prog_cc_cross
15591
15592
15593 fi
15594
15595   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
15596   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
15597     for ac_func in _fmodl
15598 do
15599 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15600 echo "configure:15601: checking for $ac_func" >&5
15601 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15602   echo $ac_n "(cached) $ac_c" 1>&6
15603 else
15604   cat > conftest.$ac_ext <<EOF
15605 #line 15606 "configure"
15606 #include "confdefs.h"
15607 /* System header to define __stub macros and hopefully few prototypes,
15608     which can conflict with char $ac_func(); below.  */
15609 #include <assert.h>
15610 /* Override any gcc2 internal prototype to avoid an error.  */
15611 /* We use char because int might match the return type of a gcc2
15612     builtin and then its argument prototype would still apply.  */
15613 char $ac_func();
15614
15615 int main() {
15616
15617 /* The GNU C library defines this for functions which it implements
15618     to always fail with ENOSYS.  Some functions are actually named
15619     something starting with __ and the normal name is an alias.  */
15620 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15621 choke me
15622 #else
15623 $ac_func();
15624 #endif
15625
15626 ; return 0; }
15627 EOF
15628 if { (eval echo configure:15629: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15629   rm -rf conftest*
15630   eval "ac_cv_func_$ac_func=yes"
15631 else
15632   echo "configure: failed program was:" >&5
15633   cat conftest.$ac_ext >&5
15634   rm -rf conftest*
15635   eval "ac_cv_func_$ac_func=no"
15636 fi
15637 rm -f conftest*
15638 fi
15639
15640 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15641   echo "$ac_t""yes" 1>&6
15642     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15643   cat >> confdefs.h <<EOF
15644 #define $ac_tr_func 1
15645 EOF
15646
15647 else
15648   echo "$ac_t""no" 1>&6
15649 fi
15650 done
15651
15652   fi
15653
15654
15655   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15656 echo "configure:15657: checking for _frexpl declaration" >&5
15657   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
15658   echo $ac_n "(cached) $ac_c" 1>&6
15659 else
15660
15661
15662     ac_ext=C
15663 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15664 ac_cpp='$CXXCPP $CPPFLAGS'
15665 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15666 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15667 cross_compiling=$ac_cv_prog_cxx_cross
15668
15669     cat > conftest.$ac_ext <<EOF
15670 #line 15671 "configure"
15671 #include "confdefs.h"
15672 #include <math.h>
15673 int main() {
15674  _frexpl(0, 0);
15675 ; return 0; }
15676 EOF
15677 if { (eval echo configure:15678: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15678   rm -rf conftest*
15679   glibcpp_cv_func__frexpl_use=yes
15680 else
15681   echo "configure: failed program was:" >&5
15682   cat conftest.$ac_ext >&5
15683   rm -rf conftest*
15684   glibcpp_cv_func__frexpl_use=no
15685 fi
15686 rm -f conftest*
15687     ac_ext=c
15688 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15689 ac_cpp='$CPP $CPPFLAGS'
15690 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15691 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15692 cross_compiling=$ac_cv_prog_cc_cross
15693
15694
15695 fi
15696
15697   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
15698   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
15699     for ac_func in _frexpl
15700 do
15701 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15702 echo "configure:15703: checking for $ac_func" >&5
15703 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15704   echo $ac_n "(cached) $ac_c" 1>&6
15705 else
15706   cat > conftest.$ac_ext <<EOF
15707 #line 15708 "configure"
15708 #include "confdefs.h"
15709 /* System header to define __stub macros and hopefully few prototypes,
15710     which can conflict with char $ac_func(); below.  */
15711 #include <assert.h>
15712 /* Override any gcc2 internal prototype to avoid an error.  */
15713 /* We use char because int might match the return type of a gcc2
15714     builtin and then its argument prototype would still apply.  */
15715 char $ac_func();
15716
15717 int main() {
15718
15719 /* The GNU C library defines this for functions which it implements
15720     to always fail with ENOSYS.  Some functions are actually named
15721     something starting with __ and the normal name is an alias.  */
15722 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15723 choke me
15724 #else
15725 $ac_func();
15726 #endif
15727
15728 ; return 0; }
15729 EOF
15730 if { (eval echo configure:15731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15731   rm -rf conftest*
15732   eval "ac_cv_func_$ac_func=yes"
15733 else
15734   echo "configure: failed program was:" >&5
15735   cat conftest.$ac_ext >&5
15736   rm -rf conftest*
15737   eval "ac_cv_func_$ac_func=no"
15738 fi
15739 rm -f conftest*
15740 fi
15741
15742 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15743   echo "$ac_t""yes" 1>&6
15744     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15745   cat >> confdefs.h <<EOF
15746 #define $ac_tr_func 1
15747 EOF
15748
15749 else
15750   echo "$ac_t""no" 1>&6
15751 fi
15752 done
15753
15754   fi
15755
15756
15757   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15758 echo "configure:15759: checking for _ldexpl declaration" >&5
15759   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
15760   echo $ac_n "(cached) $ac_c" 1>&6
15761 else
15762
15763
15764     ac_ext=C
15765 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15766 ac_cpp='$CXXCPP $CPPFLAGS'
15767 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15768 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15769 cross_compiling=$ac_cv_prog_cxx_cross
15770
15771     cat > conftest.$ac_ext <<EOF
15772 #line 15773 "configure"
15773 #include "confdefs.h"
15774 #include <math.h>
15775 int main() {
15776  _ldexpl(0, 0);
15777 ; return 0; }
15778 EOF
15779 if { (eval echo configure:15780: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15780   rm -rf conftest*
15781   glibcpp_cv_func__ldexpl_use=yes
15782 else
15783   echo "configure: failed program was:" >&5
15784   cat conftest.$ac_ext >&5
15785   rm -rf conftest*
15786   glibcpp_cv_func__ldexpl_use=no
15787 fi
15788 rm -f conftest*
15789     ac_ext=c
15790 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15791 ac_cpp='$CPP $CPPFLAGS'
15792 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15793 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15794 cross_compiling=$ac_cv_prog_cc_cross
15795
15796
15797 fi
15798
15799   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
15800   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
15801     for ac_func in _ldexpl
15802 do
15803 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15804 echo "configure:15805: checking for $ac_func" >&5
15805 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15806   echo $ac_n "(cached) $ac_c" 1>&6
15807 else
15808   cat > conftest.$ac_ext <<EOF
15809 #line 15810 "configure"
15810 #include "confdefs.h"
15811 /* System header to define __stub macros and hopefully few prototypes,
15812     which can conflict with char $ac_func(); below.  */
15813 #include <assert.h>
15814 /* Override any gcc2 internal prototype to avoid an error.  */
15815 /* We use char because int might match the return type of a gcc2
15816     builtin and then its argument prototype would still apply.  */
15817 char $ac_func();
15818
15819 int main() {
15820
15821 /* The GNU C library defines this for functions which it implements
15822     to always fail with ENOSYS.  Some functions are actually named
15823     something starting with __ and the normal name is an alias.  */
15824 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15825 choke me
15826 #else
15827 $ac_func();
15828 #endif
15829
15830 ; return 0; }
15831 EOF
15832 if { (eval echo configure:15833: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15833   rm -rf conftest*
15834   eval "ac_cv_func_$ac_func=yes"
15835 else
15836   echo "configure: failed program was:" >&5
15837   cat conftest.$ac_ext >&5
15838   rm -rf conftest*
15839   eval "ac_cv_func_$ac_func=no"
15840 fi
15841 rm -f conftest*
15842 fi
15843
15844 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15845   echo "$ac_t""yes" 1>&6
15846     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15847   cat >> confdefs.h <<EOF
15848 #define $ac_tr_func 1
15849 EOF
15850
15851 else
15852   echo "$ac_t""no" 1>&6
15853 fi
15854 done
15855
15856   fi
15857
15858
15859   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15860 echo "configure:15861: checking for _logl declaration" >&5
15861   if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
15862   echo $ac_n "(cached) $ac_c" 1>&6
15863 else
15864
15865
15866     ac_ext=C
15867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15868 ac_cpp='$CXXCPP $CPPFLAGS'
15869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15871 cross_compiling=$ac_cv_prog_cxx_cross
15872
15873     cat > conftest.$ac_ext <<EOF
15874 #line 15875 "configure"
15875 #include "confdefs.h"
15876 #include <math.h>
15877 int main() {
15878  _logl(0);
15879 ; return 0; }
15880 EOF
15881 if { (eval echo configure:15882: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15882   rm -rf conftest*
15883   glibcpp_cv_func__logl_use=yes
15884 else
15885   echo "configure: failed program was:" >&5
15886   cat conftest.$ac_ext >&5
15887   rm -rf conftest*
15888   glibcpp_cv_func__logl_use=no
15889 fi
15890 rm -f conftest*
15891     ac_ext=c
15892 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15893 ac_cpp='$CPP $CPPFLAGS'
15894 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15895 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15896 cross_compiling=$ac_cv_prog_cc_cross
15897
15898
15899 fi
15900
15901   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
15902   if test x$glibcpp_cv_func__logl_use = x"yes"; then
15903     for ac_func in _logl
15904 do
15905 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15906 echo "configure:15907: checking for $ac_func" >&5
15907 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15908   echo $ac_n "(cached) $ac_c" 1>&6
15909 else
15910   cat > conftest.$ac_ext <<EOF
15911 #line 15912 "configure"
15912 #include "confdefs.h"
15913 /* System header to define __stub macros and hopefully few prototypes,
15914     which can conflict with char $ac_func(); below.  */
15915 #include <assert.h>
15916 /* Override any gcc2 internal prototype to avoid an error.  */
15917 /* We use char because int might match the return type of a gcc2
15918     builtin and then its argument prototype would still apply.  */
15919 char $ac_func();
15920
15921 int main() {
15922
15923 /* The GNU C library defines this for functions which it implements
15924     to always fail with ENOSYS.  Some functions are actually named
15925     something starting with __ and the normal name is an alias.  */
15926 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15927 choke me
15928 #else
15929 $ac_func();
15930 #endif
15931
15932 ; return 0; }
15933 EOF
15934 if { (eval echo configure:15935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15935   rm -rf conftest*
15936   eval "ac_cv_func_$ac_func=yes"
15937 else
15938   echo "configure: failed program was:" >&5
15939   cat conftest.$ac_ext >&5
15940   rm -rf conftest*
15941   eval "ac_cv_func_$ac_func=no"
15942 fi
15943 rm -f conftest*
15944 fi
15945
15946 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15947   echo "$ac_t""yes" 1>&6
15948     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15949   cat >> confdefs.h <<EOF
15950 #define $ac_tr_func 1
15951 EOF
15952
15953 else
15954   echo "$ac_t""no" 1>&6
15955 fi
15956 done
15957
15958   fi
15959
15960
15961   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
15962 echo "configure:15963: checking for _log10l declaration" >&5
15963   if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
15964   echo $ac_n "(cached) $ac_c" 1>&6
15965 else
15966
15967
15968     ac_ext=C
15969 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15970 ac_cpp='$CXXCPP $CPPFLAGS'
15971 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15972 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15973 cross_compiling=$ac_cv_prog_cxx_cross
15974
15975     cat > conftest.$ac_ext <<EOF
15976 #line 15977 "configure"
15977 #include "confdefs.h"
15978 #include <math.h>
15979 int main() {
15980  _log10l(0);
15981 ; return 0; }
15982 EOF
15983 if { (eval echo configure:15984: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15984   rm -rf conftest*
15985   glibcpp_cv_func__log10l_use=yes
15986 else
15987   echo "configure: failed program was:" >&5
15988   cat conftest.$ac_ext >&5
15989   rm -rf conftest*
15990   glibcpp_cv_func__log10l_use=no
15991 fi
15992 rm -f conftest*
15993     ac_ext=c
15994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15995 ac_cpp='$CPP $CPPFLAGS'
15996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15998 cross_compiling=$ac_cv_prog_cc_cross
15999
16000
16001 fi
16002
16003   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16004   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16005     for ac_func in _log10l
16006 do
16007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16008 echo "configure:16009: checking for $ac_func" >&5
16009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16010   echo $ac_n "(cached) $ac_c" 1>&6
16011 else
16012   cat > conftest.$ac_ext <<EOF
16013 #line 16014 "configure"
16014 #include "confdefs.h"
16015 /* System header to define __stub macros and hopefully few prototypes,
16016     which can conflict with char $ac_func(); below.  */
16017 #include <assert.h>
16018 /* Override any gcc2 internal prototype to avoid an error.  */
16019 /* We use char because int might match the return type of a gcc2
16020     builtin and then its argument prototype would still apply.  */
16021 char $ac_func();
16022
16023 int main() {
16024
16025 /* The GNU C library defines this for functions which it implements
16026     to always fail with ENOSYS.  Some functions are actually named
16027     something starting with __ and the normal name is an alias.  */
16028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16029 choke me
16030 #else
16031 $ac_func();
16032 #endif
16033
16034 ; return 0; }
16035 EOF
16036 if { (eval echo configure:16037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16037   rm -rf conftest*
16038   eval "ac_cv_func_$ac_func=yes"
16039 else
16040   echo "configure: failed program was:" >&5
16041   cat conftest.$ac_ext >&5
16042   rm -rf conftest*
16043   eval "ac_cv_func_$ac_func=no"
16044 fi
16045 rm -f conftest*
16046 fi
16047
16048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16049   echo "$ac_t""yes" 1>&6
16050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16051   cat >> confdefs.h <<EOF
16052 #define $ac_tr_func 1
16053 EOF
16054
16055 else
16056   echo "$ac_t""no" 1>&6
16057 fi
16058 done
16059
16060   fi
16061
16062
16063   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
16064 echo "configure:16065: checking for _modfl declaration" >&5
16065   if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
16066   echo $ac_n "(cached) $ac_c" 1>&6
16067 else
16068
16069
16070     ac_ext=C
16071 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16072 ac_cpp='$CXXCPP $CPPFLAGS'
16073 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16074 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16075 cross_compiling=$ac_cv_prog_cxx_cross
16076
16077     cat > conftest.$ac_ext <<EOF
16078 #line 16079 "configure"
16079 #include "confdefs.h"
16080 #include <math.h>
16081 int main() {
16082  _modfl(0, 0);
16083 ; return 0; }
16084 EOF
16085 if { (eval echo configure:16086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16086   rm -rf conftest*
16087   glibcpp_cv_func__modfl_use=yes
16088 else
16089   echo "configure: failed program was:" >&5
16090   cat conftest.$ac_ext >&5
16091   rm -rf conftest*
16092   glibcpp_cv_func__modfl_use=no
16093 fi
16094 rm -f conftest*
16095     ac_ext=c
16096 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16097 ac_cpp='$CPP $CPPFLAGS'
16098 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16099 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16100 cross_compiling=$ac_cv_prog_cc_cross
16101
16102
16103 fi
16104
16105   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
16106   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
16107     for ac_func in _modfl
16108 do
16109 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16110 echo "configure:16111: checking for $ac_func" >&5
16111 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16112   echo $ac_n "(cached) $ac_c" 1>&6
16113 else
16114   cat > conftest.$ac_ext <<EOF
16115 #line 16116 "configure"
16116 #include "confdefs.h"
16117 /* System header to define __stub macros and hopefully few prototypes,
16118     which can conflict with char $ac_func(); below.  */
16119 #include <assert.h>
16120 /* Override any gcc2 internal prototype to avoid an error.  */
16121 /* We use char because int might match the return type of a gcc2
16122     builtin and then its argument prototype would still apply.  */
16123 char $ac_func();
16124
16125 int main() {
16126
16127 /* The GNU C library defines this for functions which it implements
16128     to always fail with ENOSYS.  Some functions are actually named
16129     something starting with __ and the normal name is an alias.  */
16130 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16131 choke me
16132 #else
16133 $ac_func();
16134 #endif
16135
16136 ; return 0; }
16137 EOF
16138 if { (eval echo configure:16139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16139   rm -rf conftest*
16140   eval "ac_cv_func_$ac_func=yes"
16141 else
16142   echo "configure: failed program was:" >&5
16143   cat conftest.$ac_ext >&5
16144   rm -rf conftest*
16145   eval "ac_cv_func_$ac_func=no"
16146 fi
16147 rm -f conftest*
16148 fi
16149
16150 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16151   echo "$ac_t""yes" 1>&6
16152     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16153   cat >> confdefs.h <<EOF
16154 #define $ac_tr_func 1
16155 EOF
16156
16157 else
16158   echo "$ac_t""no" 1>&6
16159 fi
16160 done
16161
16162   fi
16163
16164
16165   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
16166 echo "configure:16167: checking for _powl declaration" >&5
16167   if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
16168   echo $ac_n "(cached) $ac_c" 1>&6
16169 else
16170
16171
16172     ac_ext=C
16173 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16174 ac_cpp='$CXXCPP $CPPFLAGS'
16175 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16176 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16177 cross_compiling=$ac_cv_prog_cxx_cross
16178
16179     cat > conftest.$ac_ext <<EOF
16180 #line 16181 "configure"
16181 #include "confdefs.h"
16182 #include <math.h>
16183 int main() {
16184  _powl(0, 0);
16185 ; return 0; }
16186 EOF
16187 if { (eval echo configure:16188: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16188   rm -rf conftest*
16189   glibcpp_cv_func__powl_use=yes
16190 else
16191   echo "configure: failed program was:" >&5
16192   cat conftest.$ac_ext >&5
16193   rm -rf conftest*
16194   glibcpp_cv_func__powl_use=no
16195 fi
16196 rm -f conftest*
16197     ac_ext=c
16198 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16199 ac_cpp='$CPP $CPPFLAGS'
16200 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16201 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16202 cross_compiling=$ac_cv_prog_cc_cross
16203
16204
16205 fi
16206
16207   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
16208   if test x$glibcpp_cv_func__powl_use = x"yes"; then
16209     for ac_func in _powl
16210 do
16211 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16212 echo "configure:16213: checking for $ac_func" >&5
16213 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16214   echo $ac_n "(cached) $ac_c" 1>&6
16215 else
16216   cat > conftest.$ac_ext <<EOF
16217 #line 16218 "configure"
16218 #include "confdefs.h"
16219 /* System header to define __stub macros and hopefully few prototypes,
16220     which can conflict with char $ac_func(); below.  */
16221 #include <assert.h>
16222 /* Override any gcc2 internal prototype to avoid an error.  */
16223 /* We use char because int might match the return type of a gcc2
16224     builtin and then its argument prototype would still apply.  */
16225 char $ac_func();
16226
16227 int main() {
16228
16229 /* The GNU C library defines this for functions which it implements
16230     to always fail with ENOSYS.  Some functions are actually named
16231     something starting with __ and the normal name is an alias.  */
16232 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16233 choke me
16234 #else
16235 $ac_func();
16236 #endif
16237
16238 ; return 0; }
16239 EOF
16240 if { (eval echo configure:16241: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16241   rm -rf conftest*
16242   eval "ac_cv_func_$ac_func=yes"
16243 else
16244   echo "configure: failed program was:" >&5
16245   cat conftest.$ac_ext >&5
16246   rm -rf conftest*
16247   eval "ac_cv_func_$ac_func=no"
16248 fi
16249 rm -f conftest*
16250 fi
16251
16252 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16253   echo "$ac_t""yes" 1>&6
16254     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16255   cat >> confdefs.h <<EOF
16256 #define $ac_tr_func 1
16257 EOF
16258
16259 else
16260   echo "$ac_t""no" 1>&6
16261 fi
16262 done
16263
16264   fi
16265
16266
16267   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
16268 echo "configure:16269: checking for _sinl declaration" >&5
16269   if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
16270   echo $ac_n "(cached) $ac_c" 1>&6
16271 else
16272
16273
16274     ac_ext=C
16275 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16276 ac_cpp='$CXXCPP $CPPFLAGS'
16277 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16278 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16279 cross_compiling=$ac_cv_prog_cxx_cross
16280
16281     cat > conftest.$ac_ext <<EOF
16282 #line 16283 "configure"
16283 #include "confdefs.h"
16284 #include <math.h>
16285 int main() {
16286  _sinl(0);
16287 ; return 0; }
16288 EOF
16289 if { (eval echo configure:16290: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16290   rm -rf conftest*
16291   glibcpp_cv_func__sinl_use=yes
16292 else
16293   echo "configure: failed program was:" >&5
16294   cat conftest.$ac_ext >&5
16295   rm -rf conftest*
16296   glibcpp_cv_func__sinl_use=no
16297 fi
16298 rm -f conftest*
16299     ac_ext=c
16300 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16301 ac_cpp='$CPP $CPPFLAGS'
16302 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16303 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16304 cross_compiling=$ac_cv_prog_cc_cross
16305
16306
16307 fi
16308
16309   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
16310   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
16311     for ac_func in _sinl
16312 do
16313 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16314 echo "configure:16315: checking for $ac_func" >&5
16315 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16316   echo $ac_n "(cached) $ac_c" 1>&6
16317 else
16318   cat > conftest.$ac_ext <<EOF
16319 #line 16320 "configure"
16320 #include "confdefs.h"
16321 /* System header to define __stub macros and hopefully few prototypes,
16322     which can conflict with char $ac_func(); below.  */
16323 #include <assert.h>
16324 /* Override any gcc2 internal prototype to avoid an error.  */
16325 /* We use char because int might match the return type of a gcc2
16326     builtin and then its argument prototype would still apply.  */
16327 char $ac_func();
16328
16329 int main() {
16330
16331 /* The GNU C library defines this for functions which it implements
16332     to always fail with ENOSYS.  Some functions are actually named
16333     something starting with __ and the normal name is an alias.  */
16334 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16335 choke me
16336 #else
16337 $ac_func();
16338 #endif
16339
16340 ; return 0; }
16341 EOF
16342 if { (eval echo configure:16343: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16343   rm -rf conftest*
16344   eval "ac_cv_func_$ac_func=yes"
16345 else
16346   echo "configure: failed program was:" >&5
16347   cat conftest.$ac_ext >&5
16348   rm -rf conftest*
16349   eval "ac_cv_func_$ac_func=no"
16350 fi
16351 rm -f conftest*
16352 fi
16353
16354 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16355   echo "$ac_t""yes" 1>&6
16356     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16357   cat >> confdefs.h <<EOF
16358 #define $ac_tr_func 1
16359 EOF
16360
16361 else
16362   echo "$ac_t""no" 1>&6
16363 fi
16364 done
16365
16366   fi
16367
16368
16369   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
16370 echo "configure:16371: checking for _sinhl declaration" >&5
16371   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
16372   echo $ac_n "(cached) $ac_c" 1>&6
16373 else
16374
16375
16376     ac_ext=C
16377 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16378 ac_cpp='$CXXCPP $CPPFLAGS'
16379 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16380 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16381 cross_compiling=$ac_cv_prog_cxx_cross
16382
16383     cat > conftest.$ac_ext <<EOF
16384 #line 16385 "configure"
16385 #include "confdefs.h"
16386 #include <math.h>
16387 int main() {
16388  _sinhl(0);
16389 ; return 0; }
16390 EOF
16391 if { (eval echo configure:16392: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16392   rm -rf conftest*
16393   glibcpp_cv_func__sinhl_use=yes
16394 else
16395   echo "configure: failed program was:" >&5
16396   cat conftest.$ac_ext >&5
16397   rm -rf conftest*
16398   glibcpp_cv_func__sinhl_use=no
16399 fi
16400 rm -f conftest*
16401     ac_ext=c
16402 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16403 ac_cpp='$CPP $CPPFLAGS'
16404 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16405 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16406 cross_compiling=$ac_cv_prog_cc_cross
16407
16408
16409 fi
16410
16411   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
16412   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
16413     for ac_func in _sinhl
16414 do
16415 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16416 echo "configure:16417: checking for $ac_func" >&5
16417 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16418   echo $ac_n "(cached) $ac_c" 1>&6
16419 else
16420   cat > conftest.$ac_ext <<EOF
16421 #line 16422 "configure"
16422 #include "confdefs.h"
16423 /* System header to define __stub macros and hopefully few prototypes,
16424     which can conflict with char $ac_func(); below.  */
16425 #include <assert.h>
16426 /* Override any gcc2 internal prototype to avoid an error.  */
16427 /* We use char because int might match the return type of a gcc2
16428     builtin and then its argument prototype would still apply.  */
16429 char $ac_func();
16430
16431 int main() {
16432
16433 /* The GNU C library defines this for functions which it implements
16434     to always fail with ENOSYS.  Some functions are actually named
16435     something starting with __ and the normal name is an alias.  */
16436 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16437 choke me
16438 #else
16439 $ac_func();
16440 #endif
16441
16442 ; return 0; }
16443 EOF
16444 if { (eval echo configure:16445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16445   rm -rf conftest*
16446   eval "ac_cv_func_$ac_func=yes"
16447 else
16448   echo "configure: failed program was:" >&5
16449   cat conftest.$ac_ext >&5
16450   rm -rf conftest*
16451   eval "ac_cv_func_$ac_func=no"
16452 fi
16453 rm -f conftest*
16454 fi
16455
16456 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16457   echo "$ac_t""yes" 1>&6
16458     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16459   cat >> confdefs.h <<EOF
16460 #define $ac_tr_func 1
16461 EOF
16462
16463 else
16464   echo "$ac_t""no" 1>&6
16465 fi
16466 done
16467
16468   fi
16469
16470
16471   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
16472 echo "configure:16473: checking for _sqrtl declaration" >&5
16473   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
16474   echo $ac_n "(cached) $ac_c" 1>&6
16475 else
16476
16477
16478     ac_ext=C
16479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16480 ac_cpp='$CXXCPP $CPPFLAGS'
16481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16483 cross_compiling=$ac_cv_prog_cxx_cross
16484
16485     cat > conftest.$ac_ext <<EOF
16486 #line 16487 "configure"
16487 #include "confdefs.h"
16488 #include <math.h>
16489 int main() {
16490  _sqrtl(0);
16491 ; return 0; }
16492 EOF
16493 if { (eval echo configure:16494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16494   rm -rf conftest*
16495   glibcpp_cv_func__sqrtl_use=yes
16496 else
16497   echo "configure: failed program was:" >&5
16498   cat conftest.$ac_ext >&5
16499   rm -rf conftest*
16500   glibcpp_cv_func__sqrtl_use=no
16501 fi
16502 rm -f conftest*
16503     ac_ext=c
16504 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16505 ac_cpp='$CPP $CPPFLAGS'
16506 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16507 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16508 cross_compiling=$ac_cv_prog_cc_cross
16509
16510
16511 fi
16512
16513   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
16514   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
16515     for ac_func in _sqrtl
16516 do
16517 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16518 echo "configure:16519: checking for $ac_func" >&5
16519 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16520   echo $ac_n "(cached) $ac_c" 1>&6
16521 else
16522   cat > conftest.$ac_ext <<EOF
16523 #line 16524 "configure"
16524 #include "confdefs.h"
16525 /* System header to define __stub macros and hopefully few prototypes,
16526     which can conflict with char $ac_func(); below.  */
16527 #include <assert.h>
16528 /* Override any gcc2 internal prototype to avoid an error.  */
16529 /* We use char because int might match the return type of a gcc2
16530     builtin and then its argument prototype would still apply.  */
16531 char $ac_func();
16532
16533 int main() {
16534
16535 /* The GNU C library defines this for functions which it implements
16536     to always fail with ENOSYS.  Some functions are actually named
16537     something starting with __ and the normal name is an alias.  */
16538 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16539 choke me
16540 #else
16541 $ac_func();
16542 #endif
16543
16544 ; return 0; }
16545 EOF
16546 if { (eval echo configure:16547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16547   rm -rf conftest*
16548   eval "ac_cv_func_$ac_func=yes"
16549 else
16550   echo "configure: failed program was:" >&5
16551   cat conftest.$ac_ext >&5
16552   rm -rf conftest*
16553   eval "ac_cv_func_$ac_func=no"
16554 fi
16555 rm -f conftest*
16556 fi
16557
16558 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16559   echo "$ac_t""yes" 1>&6
16560     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16561   cat >> confdefs.h <<EOF
16562 #define $ac_tr_func 1
16563 EOF
16564
16565 else
16566   echo "$ac_t""no" 1>&6
16567 fi
16568 done
16569
16570   fi
16571
16572
16573   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
16574 echo "configure:16575: checking for _tanl declaration" >&5
16575   if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
16576   echo $ac_n "(cached) $ac_c" 1>&6
16577 else
16578
16579
16580     ac_ext=C
16581 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16582 ac_cpp='$CXXCPP $CPPFLAGS'
16583 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16584 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16585 cross_compiling=$ac_cv_prog_cxx_cross
16586
16587     cat > conftest.$ac_ext <<EOF
16588 #line 16589 "configure"
16589 #include "confdefs.h"
16590 #include <math.h>
16591 int main() {
16592  _tanl(0);
16593 ; return 0; }
16594 EOF
16595 if { (eval echo configure:16596: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16596   rm -rf conftest*
16597   glibcpp_cv_func__tanl_use=yes
16598 else
16599   echo "configure: failed program was:" >&5
16600   cat conftest.$ac_ext >&5
16601   rm -rf conftest*
16602   glibcpp_cv_func__tanl_use=no
16603 fi
16604 rm -f conftest*
16605     ac_ext=c
16606 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16607 ac_cpp='$CPP $CPPFLAGS'
16608 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16609 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16610 cross_compiling=$ac_cv_prog_cc_cross
16611
16612
16613 fi
16614
16615   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
16616   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
16617     for ac_func in _tanl
16618 do
16619 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16620 echo "configure:16621: checking for $ac_func" >&5
16621 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16622   echo $ac_n "(cached) $ac_c" 1>&6
16623 else
16624   cat > conftest.$ac_ext <<EOF
16625 #line 16626 "configure"
16626 #include "confdefs.h"
16627 /* System header to define __stub macros and hopefully few prototypes,
16628     which can conflict with char $ac_func(); below.  */
16629 #include <assert.h>
16630 /* Override any gcc2 internal prototype to avoid an error.  */
16631 /* We use char because int might match the return type of a gcc2
16632     builtin and then its argument prototype would still apply.  */
16633 char $ac_func();
16634
16635 int main() {
16636
16637 /* The GNU C library defines this for functions which it implements
16638     to always fail with ENOSYS.  Some functions are actually named
16639     something starting with __ and the normal name is an alias.  */
16640 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16641 choke me
16642 #else
16643 $ac_func();
16644 #endif
16645
16646 ; return 0; }
16647 EOF
16648 if { (eval echo configure:16649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16649   rm -rf conftest*
16650   eval "ac_cv_func_$ac_func=yes"
16651 else
16652   echo "configure: failed program was:" >&5
16653   cat conftest.$ac_ext >&5
16654   rm -rf conftest*
16655   eval "ac_cv_func_$ac_func=no"
16656 fi
16657 rm -f conftest*
16658 fi
16659
16660 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16661   echo "$ac_t""yes" 1>&6
16662     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16663   cat >> confdefs.h <<EOF
16664 #define $ac_tr_func 1
16665 EOF
16666
16667 else
16668   echo "$ac_t""no" 1>&6
16669 fi
16670 done
16671
16672   fi
16673
16674
16675   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16676 echo "configure:16677: checking for _tanhl declaration" >&5
16677   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
16678   echo $ac_n "(cached) $ac_c" 1>&6
16679 else
16680
16681
16682     ac_ext=C
16683 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16684 ac_cpp='$CXXCPP $CPPFLAGS'
16685 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16686 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16687 cross_compiling=$ac_cv_prog_cxx_cross
16688
16689     cat > conftest.$ac_ext <<EOF
16690 #line 16691 "configure"
16691 #include "confdefs.h"
16692 #include <math.h>
16693 int main() {
16694  _tanhl(0);
16695 ; return 0; }
16696 EOF
16697 if { (eval echo configure:16698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16698   rm -rf conftest*
16699   glibcpp_cv_func__tanhl_use=yes
16700 else
16701   echo "configure: failed program was:" >&5
16702   cat conftest.$ac_ext >&5
16703   rm -rf conftest*
16704   glibcpp_cv_func__tanhl_use=no
16705 fi
16706 rm -f conftest*
16707     ac_ext=c
16708 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16709 ac_cpp='$CPP $CPPFLAGS'
16710 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16711 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16712 cross_compiling=$ac_cv_prog_cc_cross
16713
16714
16715 fi
16716
16717   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
16718   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
16719     for ac_func in _tanhl
16720 do
16721 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16722 echo "configure:16723: checking for $ac_func" >&5
16723 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16724   echo $ac_n "(cached) $ac_c" 1>&6
16725 else
16726   cat > conftest.$ac_ext <<EOF
16727 #line 16728 "configure"
16728 #include "confdefs.h"
16729 /* System header to define __stub macros and hopefully few prototypes,
16730     which can conflict with char $ac_func(); below.  */
16731 #include <assert.h>
16732 /* Override any gcc2 internal prototype to avoid an error.  */
16733 /* We use char because int might match the return type of a gcc2
16734     builtin and then its argument prototype would still apply.  */
16735 char $ac_func();
16736
16737 int main() {
16738
16739 /* The GNU C library defines this for functions which it implements
16740     to always fail with ENOSYS.  Some functions are actually named
16741     something starting with __ and the normal name is an alias.  */
16742 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16743 choke me
16744 #else
16745 $ac_func();
16746 #endif
16747
16748 ; return 0; }
16749 EOF
16750 if { (eval echo configure:16751: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16751   rm -rf conftest*
16752   eval "ac_cv_func_$ac_func=yes"
16753 else
16754   echo "configure: failed program was:" >&5
16755   cat conftest.$ac_ext >&5
16756   rm -rf conftest*
16757   eval "ac_cv_func_$ac_func=no"
16758 fi
16759 rm -f conftest*
16760 fi
16761
16762 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16763   echo "$ac_t""yes" 1>&6
16764     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16765   cat >> confdefs.h <<EOF
16766 #define $ac_tr_func 1
16767 EOF
16768
16769 else
16770   echo "$ac_t""no" 1>&6
16771 fi
16772 done
16773
16774   fi
16775
16776
16777   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16778 echo "configure:16779: checking for _sincosl declaration" >&5
16779   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
16780   echo $ac_n "(cached) $ac_c" 1>&6
16781 else
16782
16783
16784     ac_ext=C
16785 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16786 ac_cpp='$CXXCPP $CPPFLAGS'
16787 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16788 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16789 cross_compiling=$ac_cv_prog_cxx_cross
16790
16791     cat > conftest.$ac_ext <<EOF
16792 #line 16793 "configure"
16793 #include "confdefs.h"
16794 #include <math.h>
16795 int main() {
16796  _sincosl(0, 0, 0);
16797 ; return 0; }
16798 EOF
16799 if { (eval echo configure:16800: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16800   rm -rf conftest*
16801   glibcpp_cv_func__sincosl_use=yes
16802 else
16803   echo "configure: failed program was:" >&5
16804   cat conftest.$ac_ext >&5
16805   rm -rf conftest*
16806   glibcpp_cv_func__sincosl_use=no
16807 fi
16808 rm -f conftest*
16809     ac_ext=c
16810 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16811 ac_cpp='$CPP $CPPFLAGS'
16812 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16813 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16814 cross_compiling=$ac_cv_prog_cc_cross
16815
16816
16817 fi
16818
16819   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
16820   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
16821     for ac_func in _sincosl
16822 do
16823 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16824 echo "configure:16825: checking for $ac_func" >&5
16825 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16826   echo $ac_n "(cached) $ac_c" 1>&6
16827 else
16828   cat > conftest.$ac_ext <<EOF
16829 #line 16830 "configure"
16830 #include "confdefs.h"
16831 /* System header to define __stub macros and hopefully few prototypes,
16832     which can conflict with char $ac_func(); below.  */
16833 #include <assert.h>
16834 /* Override any gcc2 internal prototype to avoid an error.  */
16835 /* We use char because int might match the return type of a gcc2
16836     builtin and then its argument prototype would still apply.  */
16837 char $ac_func();
16838
16839 int main() {
16840
16841 /* The GNU C library defines this for functions which it implements
16842     to always fail with ENOSYS.  Some functions are actually named
16843     something starting with __ and the normal name is an alias.  */
16844 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16845 choke me
16846 #else
16847 $ac_func();
16848 #endif
16849
16850 ; return 0; }
16851 EOF
16852 if { (eval echo configure:16853: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16853   rm -rf conftest*
16854   eval "ac_cv_func_$ac_func=yes"
16855 else
16856   echo "configure: failed program was:" >&5
16857   cat conftest.$ac_ext >&5
16858   rm -rf conftest*
16859   eval "ac_cv_func_$ac_func=no"
16860 fi
16861 rm -f conftest*
16862 fi
16863
16864 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16865   echo "$ac_t""yes" 1>&6
16866     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16867   cat >> confdefs.h <<EOF
16868 #define $ac_tr_func 1
16869 EOF
16870
16871 else
16872   echo "$ac_t""no" 1>&6
16873 fi
16874 done
16875
16876   fi
16877
16878
16879   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16880 echo "configure:16881: checking for _finitel declaration" >&5
16881   if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
16882   echo $ac_n "(cached) $ac_c" 1>&6
16883 else
16884
16885
16886     ac_ext=C
16887 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16888 ac_cpp='$CXXCPP $CPPFLAGS'
16889 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16890 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16891 cross_compiling=$ac_cv_prog_cxx_cross
16892
16893     cat > conftest.$ac_ext <<EOF
16894 #line 16895 "configure"
16895 #include "confdefs.h"
16896 #include <math.h>
16897 int main() {
16898  _finitel(0);
16899 ; return 0; }
16900 EOF
16901 if { (eval echo configure:16902: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16902   rm -rf conftest*
16903   glibcpp_cv_func__finitel_use=yes
16904 else
16905   echo "configure: failed program was:" >&5
16906   cat conftest.$ac_ext >&5
16907   rm -rf conftest*
16908   glibcpp_cv_func__finitel_use=no
16909 fi
16910 rm -f conftest*
16911     ac_ext=c
16912 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16913 ac_cpp='$CPP $CPPFLAGS'
16914 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16915 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16916 cross_compiling=$ac_cv_prog_cc_cross
16917
16918
16919 fi
16920
16921   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
16922   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
16923     for ac_func in _finitel
16924 do
16925 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16926 echo "configure:16927: checking for $ac_func" >&5
16927 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16928   echo $ac_n "(cached) $ac_c" 1>&6
16929 else
16930   cat > conftest.$ac_ext <<EOF
16931 #line 16932 "configure"
16932 #include "confdefs.h"
16933 /* System header to define __stub macros and hopefully few prototypes,
16934     which can conflict with char $ac_func(); below.  */
16935 #include <assert.h>
16936 /* Override any gcc2 internal prototype to avoid an error.  */
16937 /* We use char because int might match the return type of a gcc2
16938     builtin and then its argument prototype would still apply.  */
16939 char $ac_func();
16940
16941 int main() {
16942
16943 /* The GNU C library defines this for functions which it implements
16944     to always fail with ENOSYS.  Some functions are actually named
16945     something starting with __ and the normal name is an alias.  */
16946 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16947 choke me
16948 #else
16949 $ac_func();
16950 #endif
16951
16952 ; return 0; }
16953 EOF
16954 if { (eval echo configure:16955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16955   rm -rf conftest*
16956   eval "ac_cv_func_$ac_func=yes"
16957 else
16958   echo "configure: failed program was:" >&5
16959   cat conftest.$ac_ext >&5
16960   rm -rf conftest*
16961   eval "ac_cv_func_$ac_func=no"
16962 fi
16963 rm -f conftest*
16964 fi
16965
16966 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16967   echo "$ac_t""yes" 1>&6
16968     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16969   cat >> confdefs.h <<EOF
16970 #define $ac_tr_func 1
16971 EOF
16972
16973 else
16974   echo "$ac_t""no" 1>&6
16975 fi
16976 done
16977
16978   fi
16979
16980
16981   LIBS="$ac_save_LIBS"
16982   CXXFLAGS="$ac_save_CXXFLAGS"
16983
16984
16985     for ac_hdr in complex.h
16986 do
16987 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16988 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16989 echo "configure:16990: checking for $ac_hdr" >&5
16990 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16991   echo $ac_n "(cached) $ac_c" 1>&6
16992 else
16993   cat > conftest.$ac_ext <<EOF
16994 #line 16995 "configure"
16995 #include "confdefs.h"
16996 #include <$ac_hdr>
16997 EOF
16998 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16999 { (eval echo configure:17000: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17000 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17001 if test -z "$ac_err"; then
17002   rm -rf conftest*
17003   eval "ac_cv_header_$ac_safe=yes"
17004 else
17005   echo "$ac_err" >&5
17006   echo "configure: failed program was:" >&5
17007   cat conftest.$ac_ext >&5
17008   rm -rf conftest*
17009   eval "ac_cv_header_$ac_safe=no"
17010 fi
17011 rm -f conftest*
17012 fi
17013 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17014   echo "$ac_t""yes" 1>&6
17015     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17016   cat >> confdefs.h <<EOF
17017 #define $ac_tr_hdr 1
17018 EOF
17019
17020 else
17021   echo "$ac_t""no" 1>&6
17022 fi
17023 done
17024
17025   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17026 echo "configure:17027: checking for main in -lm" >&5
17027 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17028 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17029   echo $ac_n "(cached) $ac_c" 1>&6
17030 else
17031   ac_save_LIBS="$LIBS"
17032 LIBS="-lm  $LIBS"
17033 cat > conftest.$ac_ext <<EOF
17034 #line 17035 "configure"
17035 #include "confdefs.h"
17036
17037 int main() {
17038 main()
17039 ; return 0; }
17040 EOF
17041 if { (eval echo configure:17042: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17042   rm -rf conftest*
17043   eval "ac_cv_lib_$ac_lib_var=yes"
17044 else
17045   echo "configure: failed program was:" >&5
17046   cat conftest.$ac_ext >&5
17047   rm -rf conftest*
17048   eval "ac_cv_lib_$ac_lib_var=no"
17049 fi
17050 rm -f conftest*
17051 LIBS="$ac_save_LIBS"
17052
17053 fi
17054 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17055   echo "$ac_t""yes" 1>&6
17056     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
17057     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
17058   cat >> confdefs.h <<EOF
17059 #define $ac_tr_lib 1
17060 EOF
17061
17062   LIBS="-lm $LIBS"
17063
17064 else
17065   echo "$ac_t""no" 1>&6
17066 fi
17067
17068   for ac_func in cabs cabsf ccos ccosf ccosh ccoshf cexp cexpf \
17069   c_log c_logf clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt \
17070   csqrtf ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf \
17071   copysignf
17072 do
17073 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17074 echo "configure:17075: checking for $ac_func" >&5
17075 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17076   echo $ac_n "(cached) $ac_c" 1>&6
17077 else
17078   cat > conftest.$ac_ext <<EOF
17079 #line 17080 "configure"
17080 #include "confdefs.h"
17081 /* System header to define __stub macros and hopefully few prototypes,
17082     which can conflict with char $ac_func(); below.  */
17083 #include <assert.h>
17084 /* Override any gcc2 internal prototype to avoid an error.  */
17085 /* We use char because int might match the return type of a gcc2
17086     builtin and then its argument prototype would still apply.  */
17087 char $ac_func();
17088
17089 int main() {
17090
17091 /* The GNU C library defines this for functions which it implements
17092     to always fail with ENOSYS.  Some functions are actually named
17093     something starting with __ and the normal name is an alias.  */
17094 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17095 choke me
17096 #else
17097 $ac_func();
17098 #endif
17099
17100 ; return 0; }
17101 EOF
17102 if { (eval echo configure:17103: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17103   rm -rf conftest*
17104   eval "ac_cv_func_$ac_func=yes"
17105 else
17106   echo "configure: failed program was:" >&5
17107   cat conftest.$ac_ext >&5
17108   rm -rf conftest*
17109   eval "ac_cv_func_$ac_func=no"
17110 fi
17111 rm -f conftest*
17112 fi
17113
17114 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17115   echo "$ac_t""yes" 1>&6
17116     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17117   cat >> confdefs.h <<EOF
17118 #define $ac_tr_func 1
17119 EOF
17120
17121 else
17122   echo "$ac_t""no" 1>&6
17123 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17124 fi
17125 done
17126
17127
17128
17129           USE_COMPLEX_LONG_DOUBLE=no
17130   if test x$ac_cv_func_atan2l = x"yes" \
17131      && test x$ac_cv_func_copysignl = x"yes"; then
17132     USE_COMPLEX_LONG_DOUBLE=yes
17133     for ac_func in cabsl ccoshl ccosl cexpl cpowl csinhl csinl \
17134     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
17135 do
17136 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17137 echo "configure:17138: checking for $ac_func" >&5
17138 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17139   echo $ac_n "(cached) $ac_c" 1>&6
17140 else
17141   cat > conftest.$ac_ext <<EOF
17142 #line 17143 "configure"
17143 #include "confdefs.h"
17144 /* System header to define __stub macros and hopefully few prototypes,
17145     which can conflict with char $ac_func(); below.  */
17146 #include <assert.h>
17147 /* Override any gcc2 internal prototype to avoid an error.  */
17148 /* We use char because int might match the return type of a gcc2
17149     builtin and then its argument prototype would still apply.  */
17150 char $ac_func();
17151
17152 int main() {
17153
17154 /* The GNU C library defines this for functions which it implements
17155     to always fail with ENOSYS.  Some functions are actually named
17156     something starting with __ and the normal name is an alias.  */
17157 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17158 choke me
17159 #else
17160 $ac_func();
17161 #endif
17162
17163 ; return 0; }
17164 EOF
17165 if { (eval echo configure:17166: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17166   rm -rf conftest*
17167   eval "ac_cv_func_$ac_func=yes"
17168 else
17169   echo "configure: failed program was:" >&5
17170   cat conftest.$ac_ext >&5
17171   rm -rf conftest*
17172   eval "ac_cv_func_$ac_func=no"
17173 fi
17174 rm -f conftest*
17175 fi
17176
17177 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17178   echo "$ac_t""yes" 1>&6
17179     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17180   cat >> confdefs.h <<EOF
17181 #define $ac_tr_func 1
17182 EOF
17183
17184 else
17185   echo "$ac_t""no" 1>&6
17186 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17187 fi
17188 done
17189
17190
17191   fi
17192
17193
17194
17195
17196
17197
17198   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
17199 echo "configure:17200: checking for GNU C++ __complex__ support" >&5
17200   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
17201   echo $ac_n "(cached) $ac_c" 1>&6
17202 else
17203
17204
17205     ac_ext=C
17206 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17207 ac_cpp='$CXXCPP $CPPFLAGS'
17208 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17209 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17210 cross_compiling=$ac_cv_prog_cxx_cross
17211
17212     cat > conftest.$ac_ext <<EOF
17213 #line 17214 "configure"
17214 #include "confdefs.h"
17215 struct dcomplex { __complex__ double x; }; \
17216                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
17217 int main() {
17218 \
17219                      dcomplex x; f(x);
17220 ; return 0; }
17221 EOF
17222 if { (eval echo configure:17223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17223   rm -rf conftest*
17224   glibcpp_cv_complex=ok
17225 else
17226   echo "configure: failed program was:" >&5
17227   cat conftest.$ac_ext >&5
17228   rm -rf conftest*
17229   glibcpp_cv_complex=buggy
17230
17231 fi
17232 rm -f conftest*
17233     ac_ext=c
17234 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17235 ac_cpp='$CPP $CPPFLAGS'
17236 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17237 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17238 cross_compiling=$ac_cv_prog_cc_cross
17239
17240
17241 fi
17242
17243   echo "$ac_t""$glibcpp_cv_complex" 1>&6
17244   if test $glibcpp_cv_complex = buggy; then
17245     cat >> confdefs.h <<\EOF
17246 #define _GLIBCPP_BUGGY_COMPLEX 1
17247 EOF
17248
17249   fi
17250
17251   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
17252 echo "configure:17253: checking for GNU C++ __complex__ float support" >&5
17253   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
17254   echo $ac_n "(cached) $ac_c" 1>&6
17255 else
17256
17257
17258     ac_ext=C
17259 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17260 ac_cpp='$CXXCPP $CPPFLAGS'
17261 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17262 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17263 cross_compiling=$ac_cv_prog_cxx_cross
17264
17265     rm -f conftest.h
17266     cat > conftest.h <<EOB
17267       //
17268       // Check for buggy __complex__ that causes ICE in most versions of egcs
17269       // and gcc-2.95.x on certain platforms (eg., x86-win32).
17270       //
17271       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
17272       // more info on the bug itself.
17273       //
17274       struct
17275       float_complex
17276       {
17277        __complex__ float m_value;
17278        float_complex (float = 0.0f, float = 0.0f);
17279        float_complex (__complex__ float val) : m_value (val) {}
17280        float_complex foo (const float_complex &val)
17281          { return float_complex (~val.m_value); }
17282       };
17283 EOB
17284     cat > conftest.$ac_ext <<EOF
17285 #line 17286 "configure"
17286 #include "confdefs.h"
17287 #include "conftest.h"
17288 int main() {
17289
17290 ; return 0; }
17291 EOF
17292 if { (eval echo configure:17293: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17293   rm -rf conftest*
17294   glibcpp_cv_float_complex=ok
17295 else
17296   echo "configure: failed program was:" >&5
17297   cat conftest.$ac_ext >&5
17298   rm -rf conftest*
17299   glibcpp_cv_float_complex=buggy
17300
17301 fi
17302 rm -f conftest*
17303     ac_ext=c
17304 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17305 ac_cpp='$CPP $CPPFLAGS'
17306 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17307 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17308 cross_compiling=$ac_cv_prog_cc_cross
17309
17310
17311 fi
17312
17313   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
17314   if test $glibcpp_cv_float_complex = buggy; then
17315     cat >> confdefs.h <<\EOF
17316 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
17317 EOF
17318
17319   fi
17320
17321
17322   if test x$enable_c_mbchar != xno; then
17323
17324         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
17325 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
17326 echo "configure:17327: checking for wchar.h" >&5
17327 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17328   echo $ac_n "(cached) $ac_c" 1>&6
17329 else
17330   cat > conftest.$ac_ext <<EOF
17331 #line 17332 "configure"
17332 #include "confdefs.h"
17333 #include <wchar.h>
17334 EOF
17335 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17336 { (eval echo configure:17337: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17337 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17338 if test -z "$ac_err"; then
17339   rm -rf conftest*
17340   eval "ac_cv_header_$ac_safe=yes"
17341 else
17342   echo "$ac_err" >&5
17343   echo "configure: failed program was:" >&5
17344   cat conftest.$ac_ext >&5
17345   rm -rf conftest*
17346   eval "ac_cv_header_$ac_safe=no"
17347 fi
17348 rm -f conftest*
17349 fi
17350 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17351   echo "$ac_t""yes" 1>&6
17352   ac_has_wchar_h=yes
17353 else
17354   echo "$ac_t""no" 1>&6
17355 ac_has_wchar_h=no
17356 fi
17357
17358     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
17359 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
17360 echo "configure:17361: checking for wctype.h" >&5
17361 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17362   echo $ac_n "(cached) $ac_c" 1>&6
17363 else
17364   cat > conftest.$ac_ext <<EOF
17365 #line 17366 "configure"
17366 #include "confdefs.h"
17367 #include <wctype.h>
17368 EOF
17369 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17370 { (eval echo configure:17371: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17371 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17372 if test -z "$ac_err"; then
17373   rm -rf conftest*
17374   eval "ac_cv_header_$ac_safe=yes"
17375 else
17376   echo "$ac_err" >&5
17377   echo "configure: failed program was:" >&5
17378   cat conftest.$ac_ext >&5
17379   rm -rf conftest*
17380   eval "ac_cv_header_$ac_safe=no"
17381 fi
17382 rm -f conftest*
17383 fi
17384 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17385   echo "$ac_t""yes" 1>&6
17386   ac_has_wctype_h=yes
17387 else
17388   echo "$ac_t""no" 1>&6
17389 ac_has_wctype_h=no
17390 fi
17391
17392
17393         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
17394
17395                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
17396 echo "configure:17397: checking for mbstate_t" >&5
17397       cat > conftest.$ac_ext <<EOF
17398 #line 17399 "configure"
17399 #include "confdefs.h"
17400 #include <wchar.h>
17401 int main() {
17402 mbstate_t teststate;
17403 ; return 0; }
17404 EOF
17405 if { (eval echo configure:17406: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17406   rm -rf conftest*
17407   use_native_mbstatet=yes
17408 else
17409   echo "configure: failed program was:" >&5
17410   cat conftest.$ac_ext >&5
17411   rm -rf conftest*
17412   use_native_mbstatet=no
17413 fi
17414 rm -f conftest*
17415       echo "$ac_t""$use_native_mbstatet" 1>&6
17416       if test x"$use_native_mbstatet" = xno; then
17417         cat >> confdefs.h <<\EOF
17418 #define _GLIBCPP_NEED_MBSTATE_T 1
17419 EOF
17420
17421       fi
17422
17423                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
17424 echo "configure:17425: checking for WCHAR_MIN and WCHAR_MAX" >&5
17425       cat > conftest.$ac_ext <<EOF
17426 #line 17427 "configure"
17427 #include "confdefs.h"
17428 #include <wchar.h>
17429 int main() {
17430 int i = WCHAR_MIN; int j = WCHAR_MAX;
17431 ; return 0; }
17432 EOF
17433 if { (eval echo configure:17434: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17434   rm -rf conftest*
17435   has_wchar_minmax=yes
17436 else
17437   echo "configure: failed program was:" >&5
17438   cat conftest.$ac_ext >&5
17439   rm -rf conftest*
17440   has_wchar_minmax=no
17441 fi
17442 rm -f conftest*
17443       echo "$ac_t""$has_wchar_minmax" 1>&6
17444
17445                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
17446 echo "configure:17447: checking for WEOF" >&5
17447       cat > conftest.$ac_ext <<EOF
17448 #line 17449 "configure"
17449 #include "confdefs.h"
17450
17451         #include <wchar.h>
17452         #include <stddef.h>
17453 int main() {
17454 wint_t i = WEOF;
17455 ; return 0; }
17456 EOF
17457 if { (eval echo configure:17458: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17458   rm -rf conftest*
17459   has_weof=yes
17460 else
17461   echo "configure: failed program was:" >&5
17462   cat conftest.$ac_ext >&5
17463   rm -rf conftest*
17464   has_weof=no
17465 fi
17466 rm -f conftest*
17467       echo "$ac_t""$has_weof" 1>&6
17468
17469             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
17470       wcsrtombs mbsrtowcs
17471 do
17472 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17473 echo "configure:17474: checking for $ac_func" >&5
17474 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17475   echo $ac_n "(cached) $ac_c" 1>&6
17476 else
17477   cat > conftest.$ac_ext <<EOF
17478 #line 17479 "configure"
17479 #include "confdefs.h"
17480 /* System header to define __stub macros and hopefully few prototypes,
17481     which can conflict with char $ac_func(); below.  */
17482 #include <assert.h>
17483 /* Override any gcc2 internal prototype to avoid an error.  */
17484 /* We use char because int might match the return type of a gcc2
17485     builtin and then its argument prototype would still apply.  */
17486 char $ac_func();
17487
17488 int main() {
17489
17490 /* The GNU C library defines this for functions which it implements
17491     to always fail with ENOSYS.  Some functions are actually named
17492     something starting with __ and the normal name is an alias.  */
17493 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17494 choke me
17495 #else
17496 $ac_func();
17497 #endif
17498
17499 ; return 0; }
17500 EOF
17501 if { (eval echo configure:17502: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17502   rm -rf conftest*
17503   eval "ac_cv_func_$ac_func=yes"
17504 else
17505   echo "configure: failed program was:" >&5
17506   cat conftest.$ac_ext >&5
17507   rm -rf conftest*
17508   eval "ac_cv_func_$ac_func=no"
17509 fi
17510 rm -f conftest*
17511 fi
17512
17513 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17514   echo "$ac_t""yes" 1>&6
17515     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17516   cat >> confdefs.h <<EOF
17517 #define $ac_tr_func 1
17518 EOF
17519  ac_wfuncs=yes
17520 else
17521   echo "$ac_t""no" 1>&6
17522 ac_wfuncs=no
17523 fi
17524 done
17525
17526
17527       echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
17528 echo "configure:17529: checking for ISO C9X wchar_t support" >&5
17529       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
17530          && test x"$ac_wfuncs" = xyes; then
17531         ac_isoC9X_wchar_t=yes
17532       else
17533         ac_isoC9X_wchar_t=no
17534       fi
17535       echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
17536
17537                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
17538 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
17539 echo "configure:17540: checking for iconv.h" >&5
17540 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17541   echo $ac_n "(cached) $ac_c" 1>&6
17542 else
17543   cat > conftest.$ac_ext <<EOF
17544 #line 17545 "configure"
17545 #include "confdefs.h"
17546 #include <iconv.h>
17547 EOF
17548 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17549 { (eval echo configure:17550: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17550 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17551 if test -z "$ac_err"; then
17552   rm -rf conftest*
17553   eval "ac_cv_header_$ac_safe=yes"
17554 else
17555   echo "$ac_err" >&5
17556   echo "configure: failed program was:" >&5
17557   cat conftest.$ac_ext >&5
17558   rm -rf conftest*
17559   eval "ac_cv_header_$ac_safe=no"
17560 fi
17561 rm -f conftest*
17562 fi
17563 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17564   echo "$ac_t""yes" 1>&6
17565   ac_has_iconv_h=yes
17566 else
17567   echo "$ac_t""no" 1>&6
17568 ac_has_iconv_h=no
17569 fi
17570
17571       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
17572 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
17573 echo "configure:17574: checking for langinfo.h" >&5
17574 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17575   echo $ac_n "(cached) $ac_c" 1>&6
17576 else
17577   cat > conftest.$ac_ext <<EOF
17578 #line 17579 "configure"
17579 #include "confdefs.h"
17580 #include <langinfo.h>
17581 EOF
17582 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17583 { (eval echo configure:17584: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17584 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17585 if test -z "$ac_err"; then
17586   rm -rf conftest*
17587   eval "ac_cv_header_$ac_safe=yes"
17588 else
17589   echo "$ac_err" >&5
17590   echo "configure: failed program was:" >&5
17591   cat conftest.$ac_ext >&5
17592   rm -rf conftest*
17593   eval "ac_cv_header_$ac_safe=no"
17594 fi
17595 rm -f conftest*
17596 fi
17597 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17598   echo "$ac_t""yes" 1>&6
17599   ac_has_langinfo_h=yes
17600 else
17601   echo "$ac_t""no" 1>&6
17602 ac_has_langinfo_h=no
17603 fi
17604
17605
17606             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
17607 echo "configure:17608: checking for iconv in -liconv" >&5
17608 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
17609 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17610   echo $ac_n "(cached) $ac_c" 1>&6
17611 else
17612   ac_save_LIBS="$LIBS"
17613 LIBS="-liconv  $LIBS"
17614 cat > conftest.$ac_ext <<EOF
17615 #line 17616 "configure"
17616 #include "confdefs.h"
17617 /* Override any gcc2 internal prototype to avoid an error.  */
17618 /* We use char because int might match the return type of a gcc2
17619     builtin and then its argument prototype would still apply.  */
17620 char iconv();
17621
17622 int main() {
17623 iconv()
17624 ; return 0; }
17625 EOF
17626 if { (eval echo configure:17627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17627   rm -rf conftest*
17628   eval "ac_cv_lib_$ac_lib_var=yes"
17629 else
17630   echo "configure: failed program was:" >&5
17631   cat conftest.$ac_ext >&5
17632   rm -rf conftest*
17633   eval "ac_cv_lib_$ac_lib_var=no"
17634 fi
17635 rm -f conftest*
17636 LIBS="$ac_save_LIBS"
17637
17638 fi
17639 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17640   echo "$ac_t""yes" 1>&6
17641   libiconv="-liconv"
17642 else
17643   echo "$ac_t""no" 1>&6
17644 fi
17645
17646       ac_save_LIBS="$LIBS"
17647       LIBS="$LIBS $libiconv"
17648
17649       for ac_func in iconv_open iconv_close iconv nl_langinfo
17650 do
17651 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17652 echo "configure:17653: checking for $ac_func" >&5
17653 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17654   echo $ac_n "(cached) $ac_c" 1>&6
17655 else
17656   cat > conftest.$ac_ext <<EOF
17657 #line 17658 "configure"
17658 #include "confdefs.h"
17659 /* System header to define __stub macros and hopefully few prototypes,
17660     which can conflict with char $ac_func(); below.  */
17661 #include <assert.h>
17662 /* Override any gcc2 internal prototype to avoid an error.  */
17663 /* We use char because int might match the return type of a gcc2
17664     builtin and then its argument prototype would still apply.  */
17665 char $ac_func();
17666
17667 int main() {
17668
17669 /* The GNU C library defines this for functions which it implements
17670     to always fail with ENOSYS.  Some functions are actually named
17671     something starting with __ and the normal name is an alias.  */
17672 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17673 choke me
17674 #else
17675 $ac_func();
17676 #endif
17677
17678 ; return 0; }
17679 EOF
17680 if { (eval echo configure:17681: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17681   rm -rf conftest*
17682   eval "ac_cv_func_$ac_func=yes"
17683 else
17684   echo "configure: failed program was:" >&5
17685   cat conftest.$ac_ext >&5
17686   rm -rf conftest*
17687   eval "ac_cv_func_$ac_func=no"
17688 fi
17689 rm -f conftest*
17690 fi
17691
17692 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17693   echo "$ac_t""yes" 1>&6
17694     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17695   cat >> confdefs.h <<EOF
17696 #define $ac_tr_func 1
17697 EOF
17698  \
17699       ac_XPG2funcs=yes
17700 else
17701   echo "$ac_t""no" 1>&6
17702 ac_XPG2funcs=no
17703 fi
17704 done
17705
17706
17707       LIBS="$ac_save_LIBS"
17708
17709       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
17710 echo "configure:17711: checking for XPG2 wchar_t support" >&5
17711       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
17712          && test x"$ac_XPG2funcs" = xyes; then
17713         ac_XPG2_wchar_t=yes
17714       else
17715         ac_XPG2_wchar_t=no
17716       fi
17717       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
17718
17719                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
17720 echo "configure:17721: checking for enabled wchar_t specializations" >&5
17721       if test x"$ac_isoC9X_wchar_t" = xyes \
17722          && test x"$ac_XPG2_wchar_t" = xyes; then
17723         libinst_wstring_la="libinst-wstring.la"
17724         cat >> confdefs.h <<\EOF
17725 #define _GLIBCPP_USE_WCHAR_T 1
17726 EOF
17727
17728         echo "$ac_t"""yes"" 1>&6
17729       else
17730         libinst_wstring_la=""
17731         echo "$ac_t"""no"" 1>&6
17732       fi
17733
17734
17735     else
17736       echo "configure: warning: <wchar.h> not found" 1>&2
17737       cat >> confdefs.h <<\EOF
17738 #define _GLIBCPP_NEED_MBSTATE_T 1
17739 EOF
17740
17741     fi
17742
17743   else
17744         :
17745   fi
17746
17747
17748   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
17749 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
17750 echo "configure:17751: checking for ctype.h" >&5
17751 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17752   echo $ac_n "(cached) $ac_c" 1>&6
17753 else
17754   cat > conftest.$ac_ext <<EOF
17755 #line 17756 "configure"
17756 #include "confdefs.h"
17757 #include <ctype.h>
17758 EOF
17759 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17760 { (eval echo configure:17761: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17761 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17762 if test -z "$ac_err"; then
17763   rm -rf conftest*
17764   eval "ac_cv_header_$ac_safe=yes"
17765 else
17766   echo "$ac_err" >&5
17767   echo "configure: failed program was:" >&5
17768   cat conftest.$ac_ext >&5
17769   rm -rf conftest*
17770   eval "ac_cv_header_$ac_safe=no"
17771 fi
17772 rm -f conftest*
17773 fi
17774 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17775   echo "$ac_t""yes" 1>&6
17776
17777
17778         ctype_default=yes
17779
17780         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
17781 echo "configure:17782: checking <ctype> for GNU/Linux" >&5
17782     cat > conftest.$ac_ext <<EOF
17783 #line 17784 "configure"
17784 #include "confdefs.h"
17785 #include <ctype.h>
17786 int main() {
17787 int
17788     foo (int a)
17789     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
17790         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
17791         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17792 ; return 0; }
17793 EOF
17794 if { (eval echo configure:17795: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17795   rm -rf conftest*
17796   \
17797     ctype_linux=yes
17798 else
17799   echo "configure: failed program was:" >&5
17800   cat conftest.$ac_ext >&5
17801   rm -rf conftest*
17802   ctype_linux=no
17803 fi
17804 rm -f conftest*
17805     echo "$ac_t""$ctype_linux" 1>&6
17806     if test $ctype_linux = "yes"; then
17807       ctype_include_dir="config/os/gnu-linux"
17808       ctype_default=no
17809     fi
17810
17811         if test $ctype_default = "yes"; then
17812     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
17813 echo "configure:17814: checking <ctype> for FreeBSD 4.0" >&5
17814     cat > conftest.$ac_ext <<EOF
17815 #line 17816 "configure"
17816 #include "confdefs.h"
17817 #include <ctype.h>
17818 int main() {
17819 int
17820     foo (int a)
17821     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17822         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17823 ; return 0; }
17824 EOF
17825 if { (eval echo configure:17826: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17826   rm -rf conftest*
17827   \
17828     ctype_bsd=yes
17829 else
17830   echo "configure: failed program was:" >&5
17831   cat conftest.$ac_ext >&5
17832   rm -rf conftest*
17833   ctype_bsd=no
17834 fi
17835 rm -f conftest*
17836     echo "$ac_t""$ctype_bsd" 1>&6
17837     if test $ctype_bsd = "yes"; then
17838       ctype_include_dir="config/os/bsd"
17839       ctype_default=no
17840     fi
17841     fi
17842
17843         if test $ctype_default = "yes"; then
17844     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
17845 echo "configure:17846: checking <ctype> for FreeBSD 3.4" >&5
17846     cat > conftest.$ac_ext <<EOF
17847 #line 17848 "configure"
17848 #include "confdefs.h"
17849 #include <ctype.h>
17850 int main() {
17851 int
17852     foo (int a)
17853     { return _S + _R + _C + _U + _L + _A \
17854       + _D + _P + _X + _G + __istype (a, 0);}
17855 ; return 0; }
17856 EOF
17857 if { (eval echo configure:17858: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17858   rm -rf conftest*
17859   \
17860     ctype_freebsd34=yes
17861 else
17862   echo "configure: failed program was:" >&5
17863   cat conftest.$ac_ext >&5
17864   rm -rf conftest*
17865   ctype_freebsd34=no
17866 fi
17867 rm -f conftest*
17868     echo "$ac_t""$ctype_freebsd34" 1>&6
17869     if test $ctype_freebsd34 = "yes"; then
17870       ctype_include_dir="config/os/bsd"
17871       ctype_default=no
17872     fi
17873     fi
17874
17875         if test $ctype_default = "yes"; then
17876     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
17877 echo "configure:17878: checking <ctype> for Solaris 2.6,7,8" >&5
17878     cat > conftest.$ac_ext <<EOF
17879 #line 17880 "configure"
17880 #include "confdefs.h"
17881 #include <ctype.h>
17882 int main() {
17883 int
17884     foo (int a)
17885     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17886         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17887         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17888 ; return 0; }
17889 EOF
17890 if { (eval echo configure:17891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17891   rm -rf conftest*
17892   \
17893     ctype_solaris=yes
17894 else
17895   echo "configure: failed program was:" >&5
17896   cat conftest.$ac_ext >&5
17897   rm -rf conftest*
17898   ctype_solaris=no
17899 fi
17900 rm -f conftest*
17901     echo "$ac_t""$ctype_solaris" 1>&6
17902
17903     if test $ctype_solaris = "yes"; then
17904       echo $ac_n "checking   for version""... $ac_c" 1>&6
17905 echo "configure:17906: checking   for version" >&5
17906       ac_ext=C
17907 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17908 ac_cpp='$CXXCPP $CPPFLAGS'
17909 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17910 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17911 cross_compiling=$ac_cv_prog_cxx_cross
17912
17913       cat > conftest.$ac_ext <<EOF
17914 #line 17915 "configure"
17915 #include "confdefs.h"
17916 #include <ctype.h>
17917 int main() {
17918 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17919 ; return 0; }
17920 EOF
17921 if { (eval echo configure:17922: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17922   rm -rf conftest*
17923   \
17924       ctype_solaris26=yes
17925 else
17926   echo "configure: failed program was:" >&5
17927   cat conftest.$ac_ext >&5
17928   rm -rf conftest*
17929   ctype_solaris26=no
17930 fi
17931 rm -f conftest*
17932       ac_ext=c
17933 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17934 ac_cpp='$CPP $CPPFLAGS'
17935 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17936 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17937 cross_compiling=$ac_cv_prog_cc_cross
17938
17939       if test $ctype_solaris26 = "yes"; then
17940         ctype_include_dir="config/os/solaris/solaris2.6"
17941         echo "$ac_t""Solaris 2.6" 1>&6
17942         ctype_default=no
17943       else
17944         ctype_include_dir="config/os/solaris/solaris2.7"
17945         echo "$ac_t""Solaris 7,8" 1>&6
17946         ctype_default=no
17947       fi
17948     fi
17949     fi
17950
17951         if test $ctype_default = "yes"; then
17952     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
17953 echo "configure:17954: checking <ctype> for Solaris 2.5.1" >&5
17954     cat > conftest.$ac_ext <<EOF
17955 #line 17956 "configure"
17956 #include "confdefs.h"
17957 #include <ctype.h>
17958 int main() {
17959 int
17960     foo (int a)
17961     { return _U + _L + _N + _S + _P + _C + _X + _B \
17962         + __ctype[a];}
17963 ; return 0; }
17964 EOF
17965 if { (eval echo configure:17966: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17966   rm -rf conftest*
17967   \
17968     ctype_solaris25=yes
17969 else
17970   echo "configure: failed program was:" >&5
17971   cat conftest.$ac_ext >&5
17972   rm -rf conftest*
17973   ctype_solaris25=no
17974 fi
17975 rm -f conftest*
17976     echo "$ac_t""$ctype_solaris25" 1>&6
17977     if test $ctype_solaris25 = "yes"; then
17978       ctype_include_dir="config/os/solaris/solaris2.5"
17979       ctype_default=no
17980     fi
17981     fi
17982
17983         if test $ctype_default = "yes"; then
17984     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
17985 echo "configure:17986: checking <ctype> for AIX" >&5
17986     cat > conftest.$ac_ext <<EOF
17987 #line 17988 "configure"
17988 #include "confdefs.h"
17989 #include <ctype.h>
17990 int main() {
17991 int
17992     foo (int a)
17993     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17994         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17995         + _VALC('a') + _IS('c', 0);}
17996 ; return 0; }
17997 EOF
17998 if { (eval echo configure:17999: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17999   rm -rf conftest*
18000   \
18001     ctype_aix=yes
18002 else
18003   echo "configure: failed program was:" >&5
18004   cat conftest.$ac_ext >&5
18005   rm -rf conftest*
18006   ctype_aix=no
18007 fi
18008 rm -f conftest*
18009     echo "$ac_t""$ctype_aix" 1>&6
18010     if test $ctype_aix = "yes"; then
18011       ctype_include_dir="config/os/aix"
18012       ctype_default=no
18013     fi
18014     fi
18015
18016         if test $ctype_default = "yes"; then
18017     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18018 echo "configure:18019: checking <ctype> for IRIX" >&5
18019     cat > conftest.$ac_ext <<EOF
18020 #line 18021 "configure"
18021 #include "confdefs.h"
18022 #include <ctype.h>
18023 int main() {
18024 int
18025     foo (int a)
18026     { return _U + _L + _N + _S + _P + _C + _B + _X + \
18027              _A + _PR + _G + _BL;}
18028 ; return 0; }
18029 EOF
18030 if { (eval echo configure:18031: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18031   rm -rf conftest*
18032   \
18033     ctype_irix=yes
18034 else
18035   echo "configure: failed program was:" >&5
18036   cat conftest.$ac_ext >&5
18037   rm -rf conftest*
18038   ctype_irix=no
18039 fi
18040 rm -f conftest*
18041     echo "$ac_t""$ctype_irix" 1>&6
18042     if test $ctype_irix = "yes"; then
18043       ctype_include_dir="config/os/irix"
18044       ctype_default=no
18045     fi
18046     fi
18047
18048         if test $ctype_default = "yes"; then
18049     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
18050 echo "configure:18051: checking <ctype> for newlib" >&5
18051     cat > conftest.$ac_ext <<EOF
18052 #line 18053 "configure"
18053 #include "confdefs.h"
18054 #include <ctype.h>
18055 int main() {
18056 int
18057     foo (int a)
18058     { return _U + _L + _N + _S + _P + _C + _X + _B \
18059         + _ctype_[a];}
18060 ; return 0; }
18061 EOF
18062 if { (eval echo configure:18063: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18063   rm -rf conftest*
18064   \
18065     ctype_newlib=yes
18066 else
18067   echo "configure: failed program was:" >&5
18068   cat conftest.$ac_ext >&5
18069   rm -rf conftest*
18070   ctype_newlib=no
18071 fi
18072 rm -f conftest*
18073     echo "$ac_t""$ctype_newlib" 1>&6
18074     if test $ctype_newlib = "yes"; then
18075       ctype_include_dir="config/newlib"
18076       ctype_default=no
18077     fi
18078     fi
18079
18080     if test $ctype_default = "yes"; then
18081       ctype_include_dir="config/os/generic"
18082       echo "configure: warning: "Using default ctype headers."" 1>&2
18083     fi
18084
18085
18086
18087
18088
18089 else
18090   echo "$ac_t""no" 1>&6
18091 fi
18092
18093
18094
18095   ac_test_CXXFLAGS="${CXXFLAGS+set}"
18096   ac_save_CXXFLAGS="$CXXFLAGS"
18097   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
18098
18099   for ac_func in strtof
18100 do
18101 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18102 echo "configure:18103: checking for $ac_func" >&5
18103 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18104   echo $ac_n "(cached) $ac_c" 1>&6
18105 else
18106   cat > conftest.$ac_ext <<EOF
18107 #line 18108 "configure"
18108 #include "confdefs.h"
18109 /* System header to define __stub macros and hopefully few prototypes,
18110     which can conflict with char $ac_func(); below.  */
18111 #include <assert.h>
18112 /* Override any gcc2 internal prototype to avoid an error.  */
18113 /* We use char because int might match the return type of a gcc2
18114     builtin and then its argument prototype would still apply.  */
18115 char $ac_func();
18116
18117 int main() {
18118
18119 /* The GNU C library defines this for functions which it implements
18120     to always fail with ENOSYS.  Some functions are actually named
18121     something starting with __ and the normal name is an alias.  */
18122 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18123 choke me
18124 #else
18125 $ac_func();
18126 #endif
18127
18128 ; return 0; }
18129 EOF
18130 if { (eval echo configure:18131: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18131   rm -rf conftest*
18132   eval "ac_cv_func_$ac_func=yes"
18133 else
18134   echo "configure: failed program was:" >&5
18135   cat conftest.$ac_ext >&5
18136   rm -rf conftest*
18137   eval "ac_cv_func_$ac_func=no"
18138 fi
18139 rm -f conftest*
18140 fi
18141
18142 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18143   echo "$ac_t""yes" 1>&6
18144     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18145   cat >> confdefs.h <<EOF
18146 #define $ac_tr_func 1
18147 EOF
18148
18149 else
18150   echo "$ac_t""no" 1>&6
18151 fi
18152 done
18153
18154
18155   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
18156 echo "configure:18157: checking for strtold declaration" >&5
18157   if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
18158   echo $ac_n "(cached) $ac_c" 1>&6
18159 else
18160
18161
18162     ac_ext=C
18163 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18164 ac_cpp='$CXXCPP $CPPFLAGS'
18165 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18166 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18167 cross_compiling=$ac_cv_prog_cxx_cross
18168
18169     cat > conftest.$ac_ext <<EOF
18170 #line 18171 "configure"
18171 #include "confdefs.h"
18172 #include <stdlib.h>
18173 int main() {
18174  strtold(0, 0);
18175 ; return 0; }
18176 EOF
18177 if { (eval echo configure:18178: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18178   rm -rf conftest*
18179   glibcpp_cv_func_strtold_use=yes
18180 else
18181   echo "configure: failed program was:" >&5
18182   cat conftest.$ac_ext >&5
18183   rm -rf conftest*
18184   glibcpp_cv_func_strtold_use=no
18185 fi
18186 rm -f conftest*
18187     ac_ext=c
18188 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18189 ac_cpp='$CPP $CPPFLAGS'
18190 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18191 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18192 cross_compiling=$ac_cv_prog_cc_cross
18193
18194
18195 fi
18196
18197   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
18198   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
18199     for ac_func in strtold
18200 do
18201 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18202 echo "configure:18203: checking for $ac_func" >&5
18203 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18204   echo $ac_n "(cached) $ac_c" 1>&6
18205 else
18206   cat > conftest.$ac_ext <<EOF
18207 #line 18208 "configure"
18208 #include "confdefs.h"
18209 /* System header to define __stub macros and hopefully few prototypes,
18210     which can conflict with char $ac_func(); below.  */
18211 #include <assert.h>
18212 /* Override any gcc2 internal prototype to avoid an error.  */
18213 /* We use char because int might match the return type of a gcc2
18214     builtin and then its argument prototype would still apply.  */
18215 char $ac_func();
18216
18217 int main() {
18218
18219 /* The GNU C library defines this for functions which it implements
18220     to always fail with ENOSYS.  Some functions are actually named
18221     something starting with __ and the normal name is an alias.  */
18222 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18223 choke me
18224 #else
18225 $ac_func();
18226 #endif
18227
18228 ; return 0; }
18229 EOF
18230 if { (eval echo configure:18231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18231   rm -rf conftest*
18232   eval "ac_cv_func_$ac_func=yes"
18233 else
18234   echo "configure: failed program was:" >&5
18235   cat conftest.$ac_ext >&5
18236   rm -rf conftest*
18237   eval "ac_cv_func_$ac_func=no"
18238 fi
18239 rm -f conftest*
18240 fi
18241
18242 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18243   echo "$ac_t""yes" 1>&6
18244     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18245   cat >> confdefs.h <<EOF
18246 #define $ac_tr_func 1
18247 EOF
18248
18249 else
18250   echo "$ac_t""no" 1>&6
18251 fi
18252 done
18253
18254   fi
18255
18256
18257   CXXFLAGS="$ac_save_CXXFLAGS"
18258
18259
18260   for ac_hdr in unistd.h
18261 do
18262 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18263 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18264 echo "configure:18265: checking for $ac_hdr" >&5
18265 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18266   echo $ac_n "(cached) $ac_c" 1>&6
18267 else
18268   cat > conftest.$ac_ext <<EOF
18269 #line 18270 "configure"
18270 #include "confdefs.h"
18271 #include <$ac_hdr>
18272 EOF
18273 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18274 { (eval echo configure:18275: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18275 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18276 if test -z "$ac_err"; then
18277   rm -rf conftest*
18278   eval "ac_cv_header_$ac_safe=yes"
18279 else
18280   echo "$ac_err" >&5
18281   echo "configure: failed program was:" >&5
18282   cat conftest.$ac_ext >&5
18283   rm -rf conftest*
18284   eval "ac_cv_header_$ac_safe=no"
18285 fi
18286 rm -f conftest*
18287 fi
18288 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18289   echo "$ac_t""yes" 1>&6
18290     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18291   cat >> confdefs.h <<EOF
18292 #define $ac_tr_hdr 1
18293 EOF
18294
18295 else
18296   echo "$ac_t""no" 1>&6
18297 fi
18298 done
18299
18300 for ac_func in getpagesize
18301 do
18302 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18303 echo "configure:18304: checking for $ac_func" >&5
18304 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18305   echo $ac_n "(cached) $ac_c" 1>&6
18306 else
18307   cat > conftest.$ac_ext <<EOF
18308 #line 18309 "configure"
18309 #include "confdefs.h"
18310 /* System header to define __stub macros and hopefully few prototypes,
18311     which can conflict with char $ac_func(); below.  */
18312 #include <assert.h>
18313 /* Override any gcc2 internal prototype to avoid an error.  */
18314 /* We use char because int might match the return type of a gcc2
18315     builtin and then its argument prototype would still apply.  */
18316 char $ac_func();
18317
18318 int main() {
18319
18320 /* The GNU C library defines this for functions which it implements
18321     to always fail with ENOSYS.  Some functions are actually named
18322     something starting with __ and the normal name is an alias.  */
18323 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18324 choke me
18325 #else
18326 $ac_func();
18327 #endif
18328
18329 ; return 0; }
18330 EOF
18331 if { (eval echo configure:18332: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18332   rm -rf conftest*
18333   eval "ac_cv_func_$ac_func=yes"
18334 else
18335   echo "configure: failed program was:" >&5
18336   cat conftest.$ac_ext >&5
18337   rm -rf conftest*
18338   eval "ac_cv_func_$ac_func=no"
18339 fi
18340 rm -f conftest*
18341 fi
18342
18343 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18344   echo "$ac_t""yes" 1>&6
18345     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18346   cat >> confdefs.h <<EOF
18347 #define $ac_tr_func 1
18348 EOF
18349
18350 else
18351   echo "$ac_t""no" 1>&6
18352 fi
18353 done
18354
18355 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
18356 echo "configure:18357: checking for working mmap" >&5
18357 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
18358   echo $ac_n "(cached) $ac_c" 1>&6
18359 else
18360   if test "$cross_compiling" = yes; then
18361   ac_cv_func_mmap_fixed_mapped=no
18362 else
18363   cat > conftest.$ac_ext <<EOF
18364 #line 18365 "configure"
18365 #include "confdefs.h"
18366
18367 /* Thanks to Mike Haertel and Jim Avera for this test.
18368    Here is a matrix of mmap possibilities:
18369         mmap private not fixed
18370         mmap private fixed at somewhere currently unmapped
18371         mmap private fixed at somewhere already mapped
18372         mmap shared not fixed
18373         mmap shared fixed at somewhere currently unmapped
18374         mmap shared fixed at somewhere already mapped
18375    For private mappings, we should verify that changes cannot be read()
18376    back from the file, nor mmap's back from the file at a different
18377    address.  (There have been systems where private was not correctly
18378    implemented like the infamous i386 svr4.0, and systems where the
18379    VM page cache was not coherent with the filesystem buffer cache
18380    like early versions of FreeBSD and possibly contemporary NetBSD.)
18381    For shared mappings, we should conversely verify that changes get
18382    propogated back to all the places they're supposed to be.
18383
18384    Grep wants private fixed already mapped.
18385    The main things grep needs to know about mmap are:
18386    * does it exist and is it safe to write into the mmap'd area
18387    * how to use it (BSD variants)  */
18388 #include <sys/types.h>
18389 #include <fcntl.h>
18390 #include <sys/mman.h>
18391
18392 /* This mess was copied from the GNU getpagesize.h.  */
18393 #ifndef HAVE_GETPAGESIZE
18394 # ifdef HAVE_UNISTD_H
18395 #  include <unistd.h>
18396 # endif
18397
18398 /* Assume that all systems that can run configure have sys/param.h.  */
18399 # ifndef HAVE_SYS_PARAM_H
18400 #  define HAVE_SYS_PARAM_H 1
18401 # endif
18402
18403 # ifdef _SC_PAGESIZE
18404 #  define getpagesize() sysconf(_SC_PAGESIZE)
18405 # else /* no _SC_PAGESIZE */
18406 #  ifdef HAVE_SYS_PARAM_H
18407 #   include <sys/param.h>
18408 #   ifdef EXEC_PAGESIZE
18409 #    define getpagesize() EXEC_PAGESIZE
18410 #   else /* no EXEC_PAGESIZE */
18411 #    ifdef NBPG
18412 #     define getpagesize() NBPG * CLSIZE
18413 #     ifndef CLSIZE
18414 #      define CLSIZE 1
18415 #     endif /* no CLSIZE */
18416 #    else /* no NBPG */
18417 #     ifdef NBPC
18418 #      define getpagesize() NBPC
18419 #     else /* no NBPC */
18420 #      ifdef PAGESIZE
18421 #       define getpagesize() PAGESIZE
18422 #      endif /* PAGESIZE */
18423 #     endif /* no NBPC */
18424 #    endif /* no NBPG */
18425 #   endif /* no EXEC_PAGESIZE */
18426 #  else /* no HAVE_SYS_PARAM_H */
18427 #   define getpagesize() 8192   /* punt totally */
18428 #  endif /* no HAVE_SYS_PARAM_H */
18429 # endif /* no _SC_PAGESIZE */
18430
18431 #endif /* no HAVE_GETPAGESIZE */
18432
18433 #ifdef __cplusplus
18434 extern "C" { void *malloc(unsigned); }
18435 #else
18436 char *malloc();
18437 #endif
18438
18439 int
18440 main()
18441 {
18442         char *data, *data2, *data3;
18443         int i, pagesize;
18444         int fd;
18445
18446         pagesize = getpagesize();
18447
18448         /*
18449          * First, make a file with some known garbage in it.
18450          */
18451         data = malloc(pagesize);
18452         if (!data)
18453                 exit(1);
18454         for (i = 0; i < pagesize; ++i)
18455                 *(data + i) = rand();
18456         umask(0);
18457         fd = creat("conftestmmap", 0600);
18458         if (fd < 0)
18459                 exit(1);
18460         if (write(fd, data, pagesize) != pagesize)
18461                 exit(1);
18462         close(fd);
18463
18464         /*
18465          * Next, try to mmap the file at a fixed address which
18466          * already has something else allocated at it.  If we can,
18467          * also make sure that we see the same garbage.
18468          */
18469         fd = open("conftestmmap", O_RDWR);
18470         if (fd < 0)
18471                 exit(1);
18472         data2 = malloc(2 * pagesize);
18473         if (!data2)
18474                 exit(1);
18475         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
18476         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
18477             MAP_PRIVATE | MAP_FIXED, fd, 0L))
18478                 exit(1);
18479         for (i = 0; i < pagesize; ++i)
18480                 if (*(data + i) != *(data2 + i))
18481                         exit(1);
18482
18483         /*
18484          * Finally, make sure that changes to the mapped area
18485          * do not percolate back to the file as seen by read().
18486          * (This is a bug on some variants of i386 svr4.0.)
18487          */
18488         for (i = 0; i < pagesize; ++i)
18489                 *(data2 + i) = *(data2 + i) + 1;
18490         data3 = malloc(pagesize);
18491         if (!data3)
18492                 exit(1);
18493         if (read(fd, data3, pagesize) != pagesize)
18494                 exit(1);
18495         for (i = 0; i < pagesize; ++i)
18496                 if (*(data + i) != *(data3 + i))
18497                         exit(1);
18498         close(fd);
18499         unlink("conftestmmap");
18500         exit(0);
18501 }
18502
18503 EOF
18504 if { (eval echo configure:18505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
18505 then
18506   ac_cv_func_mmap_fixed_mapped=yes
18507 else
18508   echo "configure: failed program was:" >&5
18509   cat conftest.$ac_ext >&5
18510   rm -fr conftest*
18511   ac_cv_func_mmap_fixed_mapped=no
18512 fi
18513 rm -fr conftest*
18514 fi
18515
18516 fi
18517
18518 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
18519 if test $ac_cv_func_mmap_fixed_mapped = yes; then
18520   cat >> confdefs.h <<\EOF
18521 #define HAVE_MMAP 1
18522 EOF
18523
18524 fi
18525
18526 fi
18527
18528
18529
18530 if test "$CANADIAN" = yes; then
18531   CANADIAN_TRUE=
18532   CANADIAN_FALSE='#'
18533 else
18534   CANADIAN_TRUE='#'
18535   CANADIAN_FALSE=
18536 fi
18537
18538
18539 if test "$NULL_TARGET" = yes; then
18540   NULL_TARGET_TRUE=
18541   NULL_TARGET_FALSE='#'
18542 else
18543   NULL_TARGET_TRUE='#'
18544   NULL_TARGET_FALSE=
18545 fi
18546
18547
18548 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
18549   NATIVE_TRUE=
18550   NATIVE_FALSE='#'
18551 else
18552   NATIVE_TRUE='#'
18553   NATIVE_FALSE=
18554 fi
18555
18556
18557 if test -z "$with_cross_host"; then
18558   USE_LIBDIR_TRUE=
18559   USE_LIBDIR_FALSE='#'
18560 else
18561   USE_LIBDIR_TRUE='#'
18562   USE_LIBDIR_FALSE=
18563 fi
18564
18565 cat > confcache <<\EOF
18566 # This file is a shell script that caches the results of configure
18567 # tests run on this system so they can be shared between configure
18568 # scripts and configure runs.  It is not useful on other systems.
18569 # If it contains results you don't want to keep, you may remove or edit it.
18570 #
18571 # By default, configure uses ./config.cache as the cache file,
18572 # creating it if it does not exist already.  You can give configure
18573 # the --cache-file=FILE option to use a different cache file; that is
18574 # what configure does when it calls configure scripts in
18575 # subdirectories, so they share the cache.
18576 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18577 # config.status only pays attention to the cache file if you give it the
18578 # --recheck option to rerun configure.
18579 #
18580 EOF
18581 # The following way of writing the cache mishandles newlines in values,
18582 # but we know of no workaround that is simple, portable, and efficient.
18583 # So, don't put newlines in cache variables' values.
18584 # Ultrix sh set writes to stderr and can't be redirected directly,
18585 # and sets the high bit in the cache file unless we assign to the vars.
18586 (set) 2>&1 |
18587   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18588   *ac_space=\ *)
18589     # `set' does not quote correctly, so add quotes (double-quote substitution
18590     # turns \\\\ into \\, and sed turns \\ into \).
18591     sed -n \
18592       -e "s/'/'\\\\''/g" \
18593       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18594     ;;
18595   *)
18596     # `set' quotes correctly as required by POSIX, so do not add quotes.
18597     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18598     ;;
18599   esac >> confcache
18600 if cmp -s $cache_file confcache; then
18601   :
18602 else
18603   if test -w $cache_file; then
18604     echo "updating cache $cache_file"
18605     cat confcache > $cache_file
18606   else
18607     echo "not updating unwritable cache $cache_file"
18608   fi
18609 fi
18610 rm -f confcache
18611
18612 if test $ac_cv_header_locale_h = yes; then
18613     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
18614 echo "configure:18615: checking for LC_MESSAGES" >&5
18615 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
18616   echo $ac_n "(cached) $ac_c" 1>&6
18617 else
18618   cat > conftest.$ac_ext <<EOF
18619 #line 18620 "configure"
18620 #include "confdefs.h"
18621 #include <locale.h>
18622 int main() {
18623 return LC_MESSAGES
18624 ; return 0; }
18625 EOF
18626 if { (eval echo configure:18627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18627   rm -rf conftest*
18628   ac_cv_val_LC_MESSAGES=yes
18629 else
18630   echo "configure: failed program was:" >&5
18631   cat conftest.$ac_ext >&5
18632   rm -rf conftest*
18633   ac_cv_val_LC_MESSAGES=no
18634 fi
18635 rm -f conftest*
18636 fi
18637
18638 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
18639     if test $ac_cv_val_LC_MESSAGES = yes; then
18640       cat >> confdefs.h <<\EOF
18641 #define HAVE_LC_MESSAGES 1
18642 EOF
18643
18644     fi
18645   fi
18646
18647 if test "${multilib}" = "yes"; then
18648   multilib_arg="--enable-multilib"
18649 else
18650   multilib_arg=
18651 fi
18652
18653
18654 # Generate the various Makefiles, include files, and scripts.
18655
18656 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
18657 # Needed so that g++ can find the correct include subdir automatically.
18658 INTERFACE=v3
18659
18660 # Check for the interface version number for specifying where header
18661 # files are installed, if a version number is provided.
18662 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
18663 echo "configure:18664: checking for interface version number" >&5
18664 libstdcxx_interface=$INTERFACE
18665 echo "$ac_t""$libstdcxx_interface" 1>&6
18666
18667
18668 # Process the option --with-gxx-include-dir=<path to include-files directory>
18669 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
18670 echo "configure:18671: checking for --with-gxx-include-dir" >&5
18671 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
18672 if test "${with_gxx_include_dir+set}" = set; then
18673   withval="$with_gxx_include_dir"
18674   case "${withval}" in
18675   yes)
18676     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
18677     gxx_include_dir=no
18678     ;;
18679   no)
18680     gxx_include_dir=no
18681     ;;
18682   *)
18683     gxx_include_dir=${withval}
18684     ;;
18685 esac
18686 else
18687   gxx_include_dir=no
18688 fi
18689
18690 echo "$ac_t""$gxx_include_dir" 1>&6
18691
18692
18693
18694 if test x${gxx_include_dir} != xno; then
18695   GXX_INCLUDE_DIR_TRUE=
18696   GXX_INCLUDE_DIR_FALSE='#'
18697 else
18698   GXX_INCLUDE_DIR_TRUE='#'
18699   GXX_INCLUDE_DIR_FALSE=
18700 fi
18701
18702 # Process the option "--enable-version-specific-runtime-libs"
18703 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
18704 echo "configure:18705: checking for --enable-version-specific-runtime-libs" >&5
18705 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
18706 if test "${enable_version_specific_runtime_libs+set}" = set; then
18707   enableval="$enable_version_specific_runtime_libs"
18708     version_specific_libs=yes
18709 # Need the gcc compiler version to know where to install libraries
18710 # and header files if --enable-version-specific-runtime-libs option
18711 # is selected.
18712 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
18713 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
18714 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
18715 #gcc_version=$gcc_num-$gcc_date
18716 gcc_version=$gcc_num
18717
18718
18719 else
18720   version_specific_libs=no
18721 fi
18722
18723 echo "$ac_t""$version_specific_libs" 1>&6
18724 if test x${version_specific_libs} = xyes; then
18725
18726
18727 if test x${version_specific_libs} = xyes; then
18728   VERSION_SPECIFIC_LIBS_TRUE=
18729   VERSION_SPECIFIC_LIBS_FALSE='#'
18730 else
18731   VERSION_SPECIFIC_LIBS_TRUE='#'
18732   VERSION_SPECIFIC_LIBS_FALSE=
18733 fi
18734   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
18735 fi
18736
18737
18738
18739 # Export all the include and flag information to makefiles.
18740
18741   # Root level of the include sources.
18742   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
18743
18744   # Can either use include/c or include/c_std to grab "C" headers. This
18745   # variable is set to the include directory currently in use.
18746   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
18747
18748   # Passed down for canadian crosses.
18749   if  test x"$CANADIAN" = xyes; then
18750     TOPLEVEL_INCLUDES='-I$(includedir)'
18751   fi
18752
18753   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
18754
18755   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
18756
18757   #if GLIBCPP_NEED_LIBIO
18758   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
18759   #else
18760   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
18761   #endif
18762
18763   #if GLIBCPP_USE_CSHADOW
18764   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
18765   #                   -I$(top_blddir)/cshadow'
18766   #else
18767   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
18768   #endif
18769
18770   # Now, export this to all the little Makefiles....
18771
18772
18773
18774
18775
18776
18777
18778
18779   # Optimization flags that are probably a good idea for thrill-seekers. Just
18780   # uncomment the lines below and make, everything else is ready to go...
18781   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
18782   OPTIMIZE_CXXFLAGS=
18783
18784
18785   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
18786
18787
18788
18789 # This should be done by mkincludedir, but hack around it now.
18790 blddir=`pwd`
18791 echo "checking for $blddir/include"
18792
18793 if test ! -d "$blddir/include"; then
18794   mkdir "$blddir/include"
18795 fi
18796
18797 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
18798 # so that multilib installs will end up installed in the correct
18799 # place. To work around this not being passed down from config-ml.in
18800 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
18801 # append it here.
18802 trap '' 1 2 15
18803 cat > confcache <<\EOF
18804 # This file is a shell script that caches the results of configure
18805 # tests run on this system so they can be shared between configure
18806 # scripts and configure runs.  It is not useful on other systems.
18807 # If it contains results you don't want to keep, you may remove or edit it.
18808 #
18809 # By default, configure uses ./config.cache as the cache file,
18810 # creating it if it does not exist already.  You can give configure
18811 # the --cache-file=FILE option to use a different cache file; that is
18812 # what configure does when it calls configure scripts in
18813 # subdirectories, so they share the cache.
18814 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18815 # config.status only pays attention to the cache file if you give it the
18816 # --recheck option to rerun configure.
18817 #
18818 EOF
18819 # The following way of writing the cache mishandles newlines in values,
18820 # but we know of no workaround that is simple, portable, and efficient.
18821 # So, don't put newlines in cache variables' values.
18822 # Ultrix sh set writes to stderr and can't be redirected directly,
18823 # and sets the high bit in the cache file unless we assign to the vars.
18824 (set) 2>&1 |
18825   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18826   *ac_space=\ *)
18827     # `set' does not quote correctly, so add quotes (double-quote substitution
18828     # turns \\\\ into \\, and sed turns \\ into \).
18829     sed -n \
18830       -e "s/'/'\\\\''/g" \
18831       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18832     ;;
18833   *)
18834     # `set' quotes correctly as required by POSIX, so do not add quotes.
18835     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18836     ;;
18837   esac >> confcache
18838 if cmp -s $cache_file confcache; then
18839   :
18840 else
18841   if test -w $cache_file; then
18842     echo "updating cache $cache_file"
18843     cat confcache > $cache_file
18844   else
18845     echo "not updating unwritable cache $cache_file"
18846   fi
18847 fi
18848 rm -f confcache
18849
18850 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
18851
18852 test "x$prefix" = xNONE && prefix=$ac_default_prefix
18853 # Let make expand exec_prefix.
18854 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
18855
18856 # Any assignment to VPATH causes Sun make to only execute
18857 # the first set of double-colon rules, so remove it if not needed.
18858 # If there is a colon in the path, we need to keep it.
18859 if test "x$srcdir" = x.; then
18860   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
18861 fi
18862
18863 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
18864
18865 DEFS=-DHAVE_CONFIG_H
18866
18867 # Without the "./", some shells look in PATH for config.status.
18868 : ${CONFIG_STATUS=./config.status}
18869
18870 echo creating $CONFIG_STATUS
18871 rm -f $CONFIG_STATUS
18872 cat > $CONFIG_STATUS <<EOF
18873 #! /bin/sh
18874 # Generated automatically by configure.
18875 # Run this file to recreate the current configuration.
18876 # This directory was configured as follows,
18877 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
18878 #
18879 # $0 $ac_configure_args
18880 #
18881 # Compiler output produced by configure, useful for debugging
18882 # configure, is in ./config.log if it exists.
18883
18884 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
18885 for ac_option
18886 do
18887   case "\$ac_option" in
18888   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
18889     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
18890     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
18891   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
18892     echo "$CONFIG_STATUS generated by autoconf version 2.13"
18893     exit 0 ;;
18894   -help | --help | --hel | --he | --h)
18895     echo "\$ac_cs_usage"; exit 0 ;;
18896   *) echo "\$ac_cs_usage"; exit 1 ;;
18897   esac
18898 done
18899
18900 ac_given_srcdir=$srcdir
18901 ac_given_INSTALL="$INSTALL"
18902
18903 trap 'rm -fr `echo "mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
18904 EOF
18905 cat >> $CONFIG_STATUS <<EOF
18906
18907 # Protect against being on the right side of a sed subst in config.status.
18908 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
18909  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
18910 $ac_vpsub
18911 $extrasub
18912 s%@SHELL@%$SHELL%g
18913 s%@CFLAGS@%$CFLAGS%g
18914 s%@CPPFLAGS@%$CPPFLAGS%g
18915 s%@CXXFLAGS@%$CXXFLAGS%g
18916 s%@FFLAGS@%$FFLAGS%g
18917 s%@DEFS@%$DEFS%g
18918 s%@LDFLAGS@%$LDFLAGS%g
18919 s%@LIBS@%$LIBS%g
18920 s%@exec_prefix@%$exec_prefix%g
18921 s%@prefix@%$prefix%g
18922 s%@program_transform_name@%$program_transform_name%g
18923 s%@bindir@%$bindir%g
18924 s%@sbindir@%$sbindir%g
18925 s%@libexecdir@%$libexecdir%g
18926 s%@datadir@%$datadir%g
18927 s%@sysconfdir@%$sysconfdir%g
18928 s%@sharedstatedir@%$sharedstatedir%g
18929 s%@localstatedir@%$localstatedir%g
18930 s%@libdir@%$libdir%g
18931 s%@includedir@%$includedir%g
18932 s%@oldincludedir@%$oldincludedir%g
18933 s%@infodir@%$infodir%g
18934 s%@mandir@%$mandir%g
18935 s%@host@%$host%g
18936 s%@host_alias@%$host_alias%g
18937 s%@host_cpu@%$host_cpu%g
18938 s%@host_vendor@%$host_vendor%g
18939 s%@host_os@%$host_os%g
18940 s%@target@%$target%g
18941 s%@target_alias@%$target_alias%g
18942 s%@target_cpu@%$target_cpu%g
18943 s%@target_vendor@%$target_vendor%g
18944 s%@target_os@%$target_os%g
18945 s%@build@%$build%g
18946 s%@build_alias@%$build_alias%g
18947 s%@build_cpu@%$build_cpu%g
18948 s%@build_vendor@%$build_vendor%g
18949 s%@build_os@%$build_os%g
18950 s%@glibcpp_basedir@%$glibcpp_basedir%g
18951 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
18952 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
18953 s%@INSTALL_DATA@%$INSTALL_DATA%g
18954 s%@PACKAGE@%$PACKAGE%g
18955 s%@VERSION@%$VERSION%g
18956 s%@ACLOCAL@%$ACLOCAL%g
18957 s%@AUTOCONF@%$AUTOCONF%g
18958 s%@AUTOMAKE@%$AUTOMAKE%g
18959 s%@AUTOHEADER@%$AUTOHEADER%g
18960 s%@MAKEINFO@%$MAKEINFO%g
18961 s%@SET_MAKE@%$SET_MAKE%g
18962 s%@CC@%$CC%g
18963 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
18964 s%@CXX@%$CXX%g
18965 s%@AS@%$AS%g
18966 s%@AR@%$AR%g
18967 s%@RANLIB@%$RANLIB%g
18968 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
18969 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
18970 s%@MAINT@%$MAINT%g
18971 s%@EXEEXT@%$EXEEXT%g
18972 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
18973 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
18974 s%@LN_S@%$LN_S%g
18975 s%@OBJEXT@%$OBJEXT%g
18976 s%@STRIP@%$STRIP%g
18977 s%@LIBTOOL@%$LIBTOOL%g
18978 s%@CXXCPP@%$CXXCPP%g
18979 s%@enable_shared@%$enable_shared%g
18980 s%@enable_static@%$enable_static%g
18981 s%@ifGNUmake@%$ifGNUmake%g
18982 s%@CPP@%$CPP%g
18983 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
18984 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
18985 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
18986 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
18987 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
18988 s%@libio_la@%$libio_la%g
18989 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
18990 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
18991 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
18992 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
18993 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
18994 s%@WERROR@%$WERROR%g
18995 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
18996 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
18997 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
18998 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
18999 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
19000 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
19001 s%@libinst_wstring_la@%$libinst_wstring_la%g
19002 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
19003 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
19004 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
19005 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
19006 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
19007 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
19008 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
19009 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
19010 s%@libstdcxx_interface@%$libstdcxx_interface%g
19011 s%@gxx_include_dir@%$gxx_include_dir%g
19012 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
19013 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
19014 s%@gcc_version@%$gcc_version%g
19015 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
19016 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
19017 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
19018 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
19019 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
19020 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
19021 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
19022 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
19023 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
19024 s%@WARN_FLAGS@%$WARN_FLAGS%g
19025
19026 CEOF
19027 EOF
19028
19029 cat >> $CONFIG_STATUS <<\EOF
19030
19031 # Split the substitutions into bite-sized pieces for seds with
19032 # small command number limits, like on Digital OSF/1 and HP-UX.
19033 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
19034 ac_file=1 # Number of current file.
19035 ac_beg=1 # First line for current file.
19036 ac_end=$ac_max_sed_cmds # Line after last line for current file.
19037 ac_more_lines=:
19038 ac_sed_cmds=""
19039 while $ac_more_lines; do
19040   if test $ac_beg -gt 1; then
19041     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
19042   else
19043     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
19044   fi
19045   if test ! -s conftest.s$ac_file; then
19046     ac_more_lines=false
19047     rm -f conftest.s$ac_file
19048   else
19049     if test -z "$ac_sed_cmds"; then
19050       ac_sed_cmds="sed -f conftest.s$ac_file"
19051     else
19052       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
19053     fi
19054     ac_file=`expr $ac_file + 1`
19055     ac_beg=$ac_end
19056     ac_end=`expr $ac_end + $ac_max_sed_cmds`
19057   fi
19058 done
19059 if test -z "$ac_sed_cmds"; then
19060   ac_sed_cmds=cat
19061 fi
19062 EOF
19063
19064 cat >> $CONFIG_STATUS <<EOF
19065
19066 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
19067 EOF
19068 cat >> $CONFIG_STATUS <<\EOF
19069 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
19070   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19071   case "$ac_file" in
19072   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19073        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19074   *) ac_file_in="${ac_file}.in" ;;
19075   esac
19076
19077   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
19078
19079   # Remove last slash and all that follows it.  Not all systems have dirname.
19080   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19081   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19082     # The file is in a subdirectory.
19083     test ! -d "$ac_dir" && mkdir "$ac_dir"
19084     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
19085     # A "../" for each directory in $ac_dir_suffix.
19086     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
19087   else
19088     ac_dir_suffix= ac_dots=
19089   fi
19090
19091   case "$ac_given_srcdir" in
19092   .)  srcdir=.
19093       if test -z "$ac_dots"; then top_srcdir=.
19094       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
19095   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
19096   *) # Relative path.
19097     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
19098     top_srcdir="$ac_dots$ac_given_srcdir" ;;
19099   esac
19100
19101   case "$ac_given_INSTALL" in
19102   [/$]*) INSTALL="$ac_given_INSTALL" ;;
19103   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
19104   esac
19105
19106   echo creating "$ac_file"
19107   rm -f "$ac_file"
19108   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
19109   case "$ac_file" in
19110   *Makefile*) ac_comsub="1i\\
19111 # $configure_input" ;;
19112   *) ac_comsub= ;;
19113   esac
19114
19115   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19116   sed -e "$ac_comsub
19117 s%@configure_input@%$configure_input%g
19118 s%@srcdir@%$srcdir%g
19119 s%@top_srcdir@%$top_srcdir%g
19120 s%@INSTALL@%$INSTALL%g
19121 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
19122 fi; done
19123 rm -f conftest.s*
19124
19125 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
19126 # NAME is the cpp macro being defined and VALUE is the value it is being given.
19127 #
19128 # ac_d sets the value in "#define NAME VALUE" lines.
19129 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
19130 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
19131 ac_dC='\3'
19132 ac_dD='%g'
19133 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
19134 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19135 ac_uB='\([      ]\)%\1#\2define\3'
19136 ac_uC=' '
19137 ac_uD='\4%g'
19138 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
19139 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19140 ac_eB='$%\1#\2define\3'
19141 ac_eC=' '
19142 ac_eD='%g'
19143
19144 if test "${CONFIG_HEADERS+set}" != set; then
19145 EOF
19146 cat >> $CONFIG_STATUS <<EOF
19147   CONFIG_HEADERS="config.h"
19148 EOF
19149 cat >> $CONFIG_STATUS <<\EOF
19150 fi
19151 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
19152   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19153   case "$ac_file" in
19154   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19155        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19156   *) ac_file_in="${ac_file}.in" ;;
19157   esac
19158
19159   echo creating $ac_file
19160
19161   rm -f conftest.frag conftest.in conftest.out
19162   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19163   cat $ac_file_inputs > conftest.in
19164
19165 EOF
19166
19167 # Transform confdefs.h into a sed script conftest.vals that substitutes
19168 # the proper values into config.h.in to produce config.h.  And first:
19169 # Protect against being on the right side of a sed subst in config.status.
19170 # Protect against being in an unquoted here document in config.status.
19171 rm -f conftest.vals
19172 cat > conftest.hdr <<\EOF
19173 s/[\\&%]/\\&/g
19174 s%[\\$`]%\\&%g
19175 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
19176 s%ac_d%ac_u%gp
19177 s%ac_u%ac_e%gp
19178 EOF
19179 sed -n -f conftest.hdr confdefs.h > conftest.vals
19180 rm -f conftest.hdr
19181
19182 # This sed command replaces #undef with comments.  This is necessary, for
19183 # example, in the case of _POSIX_SOURCE, which is predefined and required
19184 # on some systems where configure will not decide to define it.
19185 cat >> conftest.vals <<\EOF
19186 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
19187 EOF
19188
19189 # Break up conftest.vals because some shells have a limit on
19190 # the size of here documents, and old seds have small limits too.
19191
19192 rm -f conftest.tail
19193 while :
19194 do
19195   ac_lines=`grep -c . conftest.vals`
19196   # grep -c gives empty output for an empty file on some AIX systems.
19197   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
19198   # Write a limited-size here document to conftest.frag.
19199   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
19200   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
19201   echo 'CEOF
19202   sed -f conftest.frag conftest.in > conftest.out
19203   rm -f conftest.in
19204   mv conftest.out conftest.in
19205 ' >> $CONFIG_STATUS
19206   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
19207   rm -f conftest.vals
19208   mv conftest.tail conftest.vals
19209 done
19210 rm -f conftest.vals
19211
19212 cat >> $CONFIG_STATUS <<\EOF
19213   rm -f conftest.frag conftest.h
19214   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
19215   cat conftest.in >> conftest.h
19216   rm -f conftest.in
19217   if cmp -s $ac_file conftest.h 2>/dev/null; then
19218     echo "$ac_file is unchanged"
19219     rm -f conftest.h
19220   else
19221     # Remove last slash and all that follows it.  Not all systems have dirname.
19222       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19223       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19224       # The file is in a subdirectory.
19225       test ! -d "$ac_dir" && mkdir "$ac_dir"
19226     fi
19227     rm -f $ac_file
19228     mv conftest.h $ac_file
19229   fi
19230 fi; done
19231
19232 EOF
19233
19234 cat >> $CONFIG_STATUS <<EOF
19235 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"
19236 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 \
19237         include/bits/ctype_inline.h \
19238         include/bits/ctype_noninline.h include/bits/ctype_base.h \
19239         include/bits/ctype_inline.h \
19240         include/bits/ctype_noninline.h include/bits/ctype_base.h include/bits/ctype_inline.h \
19241     include/bits/ctype_noninline.h"
19242 EOF
19243
19244 cat >> $CONFIG_STATUS <<\EOF
19245 srcdir=$ac_given_srcdir
19246 while test -n "$ac_sources"; do
19247   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
19248   set $ac_sources; ac_source=$1; shift; ac_sources=$*
19249
19250   echo "linking $srcdir/$ac_source to $ac_dest"
19251
19252   if test ! -r $srcdir/$ac_source; then
19253     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
19254   fi
19255   rm -f $ac_dest
19256
19257   # Make relative symlinks.
19258   # Remove last slash and all that follows it.  Not all systems have dirname.
19259   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
19260   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
19261     # The dest file is in a subdirectory.
19262     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
19263     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
19264     # A "../" for each directory in $ac_dest_dir_suffix.
19265     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
19266   else
19267     ac_dest_dir_suffix= ac_dots=
19268   fi
19269
19270   case "$srcdir" in
19271   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
19272   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
19273   esac
19274
19275   # Make a symlink if possible; otherwise try a hard link.
19276   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
19277     ln $srcdir/$ac_source $ac_dest; then :
19278   else
19279     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
19280   fi
19281 done
19282 EOF
19283 cat >> $CONFIG_STATUS <<EOF
19284
19285 srcdir=${srcdir}
19286 host=${host}
19287 target=${target}
19288 with_multisubdir=${with_multisubdir}
19289 ac_configure_args="${multilib_arg} ${ac_configure_args}"
19290 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
19291 glibcpp_basedir=${glibcpp_basedir}
19292 CC="${CC}"
19293 CXX="${CXX}"
19294
19295 EOF
19296 cat >> $CONFIG_STATUS <<\EOF
19297 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
19298 if test -n "$CONFIG_FILES"; then
19299   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
19300   grep '^MULTISUBDIR =' Makefile >> src/Makefile
19301 fi
19302 chmod +x mkcheck
19303
19304 exit 0
19305 EOF
19306 chmod +x $CONFIG_STATUS
19307 rm -fr confdefs* $ac_clean_files
19308 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
19309
19310
19311
19312 # Generate bits/c++config.h
19313 # NB: This must be the first generated file as others include it. . .
19314
19315
19316 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
19317 if test ! -f stamp-limits; then
19318
19319   touch stamp-limits
19320 fi
19321
19322
19323 # Sanity checking & User-visible messages.
19324 # Checks down here, otherwise they get scrolled off before
19325 # the user will notice.
19326
19327 # Trying to get more people to read documentation.  Possibly remove
19328 # check and warn all the time. There is no "informational" AC_MSG_
19329 # macro, so these are going to be printed even when --quiet/--silent
19330 # is given.
19331 if test ! -f stamp-sanity-warned; then
19332   touch stamp-sanity-warned
19333   echo ""
19334   echo "Please make certain that you read the installation information here:"
19335   echo "  faster => ${srcdir}/docs/install.html"
19336   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
19337   echo ""
19338   echo "and the configuration information here:"
19339   echo "  faster => ${srcdir}/docs/configopts.html"
19340   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
19341   echo ""
19342   echo "before proceeding with ${_cv_gnu_make_command}."
19343   echo ""
19344 fi
19345
19346
19347 $srcdir/mkc++config $blddir $srcdir
19348 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
19349
19350