libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --with-pic              try to use only PIC/non-PIC objects [default=use both]"
  36 ac_help="$ac_help
  37   --enable-debug          extra debugging, turn off optimization [default=no]"
  38 ac_help="$ac_help
  39   --enable-cstdio        enable stdio for target io package. (default)
  40      --enable-cstdio=LIB    use LIB target-speific io package."
  41 ac_help="$ac_help
  42   --enable-c-mbchar       enable multibyte (wide) characters [default=yes]"
  43 ac_help="$ac_help
  44   --enable-long-long      turns on 'long long' [default=yes]"
  45 ac_help="$ac_help
  46   --enable-cshadow-headers construct "shadowed" C header files for
  47                            g++ [default=no]"
  48 ac_help="$ac_help
  49   --enable-threads        enable thread usage for target GCC.
  50      --enable-threads=LIB    use LIB thread package for target GCC."
  51 ac_help="$ac_help
  52   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  53                                 [default=none]"
  54 ac_help="$ac_help
  55  --with-gxx-include-dir  the installation directory for include files"
  56 ac_help="$ac_help
  57   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory "
  58
  59 # Initialize some variables set by options.
  60 # The variables have the same names as the options, with
  61 # dashes changed to underlines.
  62 build=NONE
  63 cache_file=./config.cache
  64 exec_prefix=NONE
  65 host=NONE
  66 no_create=
  67 nonopt=NONE
  68 no_recursion=
  69 prefix=NONE
  70 program_prefix=NONE
  71 program_suffix=NONE
  72 program_transform_name=s,x,x,
  73 silent=
  74 site=
  75 srcdir=
  76 target=NONE
  77 verbose=
  78 x_includes=NONE
  79 x_libraries=NONE
  80 bindir='${exec_prefix}/bin'
  81 sbindir='${exec_prefix}/sbin'
  82 libexecdir='${exec_prefix}/libexec'
  83 datadir='${prefix}/share'
  84 sysconfdir='${prefix}/etc'
  85 sharedstatedir='${prefix}/com'
  86 localstatedir='${prefix}/var'
  87 libdir='${exec_prefix}/lib'
  88 includedir='${prefix}/include'
  89 oldincludedir='/usr/include'
  90 infodir='${prefix}/info'
  91 mandir='${prefix}/man'
  92
  93 # Initialize some other variables.
  94 subdirs=
  95 MFLAGS= MAKEFLAGS=
  96 SHELL=${CONFIG_SHELL-/bin/sh}
  97 # Maximum number of lines to put in a shell here document.
  98 ac_max_here_lines=12
  99
 100 ac_prev=
 101 for ac_option
 102 do
 103
 104   # If the previous option needs an argument, assign it.
 105   if test -n "$ac_prev"; then
 106     eval "$ac_prev=\$ac_option"
 107     ac_prev=
 108     continue
 109   fi
 110
 111   case "$ac_option" in
 112   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 113   *) ac_optarg= ;;
 114   esac
 115
 116   # Accept the important Cygnus configure options, so we can diagnose typos.
 117
 118   case "$ac_option" in
 119
 120   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 121     ac_prev=bindir ;;
 122   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 123     bindir="$ac_optarg" ;;
 124
 125   -build | --build | --buil | --bui | --bu)
 126     ac_prev=build ;;
 127   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 128     build="$ac_optarg" ;;
 129
 130   -cache-file | --cache-file | --cache-fil | --cache-fi \
 131   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 132     ac_prev=cache_file ;;
 133   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 134   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 135     cache_file="$ac_optarg" ;;
 136
 137   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 138     ac_prev=datadir ;;
 139   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 140   | --da=*)
 141     datadir="$ac_optarg" ;;
 142
 143   -disable-* | --disable-*)
 144     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 145     # Reject names that are not valid shell variable names.
 146     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 147       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 148     fi
 149     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 150     eval "enable_${ac_feature}=no" ;;
 151
 152   -enable-* | --enable-*)
 153     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 154     # Reject names that are not valid shell variable names.
 155     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 156       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 157     fi
 158     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 159     case "$ac_option" in
 160       *=*) ;;
 161       *) ac_optarg=yes ;;
 162     esac
 163     eval "enable_${ac_feature}='$ac_optarg'" ;;
 164
 165   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 166   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 167   | --exec | --exe | --ex)
 168     ac_prev=exec_prefix ;;
 169   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 170   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 171   | --exec=* | --exe=* | --ex=*)
 172     exec_prefix="$ac_optarg" ;;
 173
 174   -gas | --gas | --ga | --g)
 175     # Obsolete; use --with-gas.
 176     with_gas=yes ;;
 177
 178   -help | --help | --hel | --he)
 179     # Omit some internal or obsolete options to make the list less imposing.
 180     # This message is too long to be a string in the A/UX 3.1 sh.
 181     cat << EOF
 182 Usage: configure [options] [host]
 183 Options: [defaults in brackets after descriptions]
 184 Configuration:
 185   --cache-file=FILE       cache test results in FILE
 186   --help                  print this message
 187   --no-create             do not create output files
 188   --quiet, --silent       do not print \`checking...' messages
 189   --version               print the version of autoconf that created configure
 190 Directory and file names:
 191   --prefix=PREFIX         install architecture-independent files in PREFIX
 192                           [$ac_default_prefix]
 193   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 194                           [same as prefix]
 195   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 196   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 197   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 198   --datadir=DIR           read-only architecture-independent data in DIR
 199                           [PREFIX/share]
 200   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 201   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 202                           [PREFIX/com]
 203   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 204   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 205   --includedir=DIR        C header files in DIR [PREFIX/include]
 206   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 207   --infodir=DIR           info documentation in DIR [PREFIX/info]
 208   --mandir=DIR            man documentation in DIR [PREFIX/man]
 209   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 210   --program-prefix=PREFIX prepend PREFIX to installed program names
 211   --program-suffix=SUFFIX append SUFFIX to installed program names
 212   --program-transform-name=PROGRAM
 213                           run sed PROGRAM on installed program names
 214 EOF
 215     cat << EOF
 216 Host type:
 217   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 218   --host=HOST             configure for HOST [guessed]
 219   --target=TARGET         configure for TARGET [TARGET=HOST]
 220 Features and packages:
 221   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 222   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 223   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 224   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 225   --x-includes=DIR        X include files are in DIR
 226   --x-libraries=DIR       X library files are in DIR
 227 EOF
 228     if test -n "$ac_help"; then
 229       echo "--enable and --with options recognized:$ac_help"
 230     fi
 231     exit 0 ;;
 232
 233   -host | --host | --hos | --ho)
 234     ac_prev=host ;;
 235   -host=* | --host=* | --hos=* | --ho=*)
 236     host="$ac_optarg" ;;
 237
 238   -includedir | --includedir | --includedi | --included | --include \
 239   | --includ | --inclu | --incl | --inc)
 240     ac_prev=includedir ;;
 241   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 242   | --includ=* | --inclu=* | --incl=* | --inc=*)
 243     includedir="$ac_optarg" ;;
 244
 245   -infodir | --infodir | --infodi | --infod | --info | --inf)
 246     ac_prev=infodir ;;
 247   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 248     infodir="$ac_optarg" ;;
 249
 250   -libdir | --libdir | --libdi | --libd)
 251     ac_prev=libdir ;;
 252   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 253     libdir="$ac_optarg" ;;
 254
 255   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 256   | --libexe | --libex | --libe)
 257     ac_prev=libexecdir ;;
 258   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 259   | --libexe=* | --libex=* | --libe=*)
 260     libexecdir="$ac_optarg" ;;
 261
 262   -localstatedir | --localstatedir | --localstatedi | --localstated \
 263   | --localstate | --localstat | --localsta | --localst \
 264   | --locals | --local | --loca | --loc | --lo)
 265     ac_prev=localstatedir ;;
 266   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 267   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 268   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 269     localstatedir="$ac_optarg" ;;
 270
 271   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 272     ac_prev=mandir ;;
 273   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 274     mandir="$ac_optarg" ;;
 275
 276   -nfp | --nfp | --nf)
 277     # Obsolete; use --without-fp.
 278     with_fp=no ;;
 279
 280   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 281   | --no-cr | --no-c)
 282     no_create=yes ;;
 283
 284   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 285   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 286     no_recursion=yes ;;
 287
 288   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 289   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 290   | --oldin | --oldi | --old | --ol | --o)
 291     ac_prev=oldincludedir ;;
 292   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 293   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 294   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 295     oldincludedir="$ac_optarg" ;;
 296
 297   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 298     ac_prev=prefix ;;
 299   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 300     prefix="$ac_optarg" ;;
 301
 302   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 303   | --program-pre | --program-pr | --program-p)
 304     ac_prev=program_prefix ;;
 305   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 306   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 307     program_prefix="$ac_optarg" ;;
 308
 309   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 310   | --program-suf | --program-su | --program-s)
 311     ac_prev=program_suffix ;;
 312   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 313   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 314     program_suffix="$ac_optarg" ;;
 315
 316   -program-transform-name | --program-transform-name \
 317   | --program-transform-nam | --program-transform-na \
 318   | --program-transform-n | --program-transform- \
 319   | --program-transform | --program-transfor \
 320   | --program-transfo | --program-transf \
 321   | --program-trans | --program-tran \
 322   | --progr-tra | --program-tr | --program-t)
 323     ac_prev=program_transform_name ;;
 324   -program-transform-name=* | --program-transform-name=* \
 325   | --program-transform-nam=* | --program-transform-na=* \
 326   | --program-transform-n=* | --program-transform-=* \
 327   | --program-transform=* | --program-transfor=* \
 328   | --program-transfo=* | --program-transf=* \
 329   | --program-trans=* | --program-tran=* \
 330   | --progr-tra=* | --program-tr=* | --program-t=*)
 331     program_transform_name="$ac_optarg" ;;
 332
 333   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 334   | -silent | --silent | --silen | --sile | --sil)
 335     silent=yes ;;
 336
 337   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 338     ac_prev=sbindir ;;
 339   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 340   | --sbi=* | --sb=*)
 341     sbindir="$ac_optarg" ;;
 342
 343   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 344   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 345   | --sharedst | --shareds | --shared | --share | --shar \
 346   | --sha | --sh)
 347     ac_prev=sharedstatedir ;;
 348   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 349   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 350   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 351   | --sha=* | --sh=*)
 352     sharedstatedir="$ac_optarg" ;;
 353
 354   -site | --site | --sit)
 355     ac_prev=site ;;
 356   -site=* | --site=* | --sit=*)
 357     site="$ac_optarg" ;;
 358
 359   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 360     ac_prev=srcdir ;;
 361   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 362     srcdir="$ac_optarg" ;;
 363
 364   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 365   | --syscon | --sysco | --sysc | --sys | --sy)
 366     ac_prev=sysconfdir ;;
 367   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 368   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 369     sysconfdir="$ac_optarg" ;;
 370
 371   -target | --target | --targe | --targ | --tar | --ta | --t)
 372     ac_prev=target ;;
 373   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 374     target="$ac_optarg" ;;
 375
 376   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 377     verbose=yes ;;
 378
 379   -version | --version | --versio | --versi | --vers)
 380     echo "configure generated by autoconf version 2.13"
 381     exit 0 ;;
 382
 383   -with-* | --with-*)
 384     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 385     # Reject names that are not valid shell variable names.
 386     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 387       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 388     fi
 389     ac_package=`echo $ac_package| sed 's/-/_/g'`
 390     case "$ac_option" in
 391       *=*) ;;
 392       *) ac_optarg=yes ;;
 393     esac
 394     eval "with_${ac_package}='$ac_optarg'" ;;
 395
 396   -without-* | --without-*)
 397     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 398     # Reject names that are not valid shell variable names.
 399     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 400       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 401     fi
 402     ac_package=`echo $ac_package| sed 's/-/_/g'`
 403     eval "with_${ac_package}=no" ;;
 404
 405   --x)
 406     # Obsolete; use --with-x.
 407     with_x=yes ;;
 408
 409   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 410   | --x-incl | --x-inc | --x-in | --x-i)
 411     ac_prev=x_includes ;;
 412   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 413   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 414     x_includes="$ac_optarg" ;;
 415
 416   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 417   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 418     ac_prev=x_libraries ;;
 419   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 420   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 421     x_libraries="$ac_optarg" ;;
 422
 423   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 424     ;;
 425
 426   *)
 427     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 428       echo "configure: warning: $ac_option: invalid host type" 1>&2
 429     fi
 430     if test "x$nonopt" != xNONE; then
 431       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 432     fi
 433     nonopt="$ac_option"
 434     ;;
 435
 436   esac
 437 done
 438
 439 if test -n "$ac_prev"; then
 440   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 441 fi
 442
 443 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 444
 445 # File descriptor usage:
 446 # 0 standard input
 447 # 1 file creation
 448 # 2 errors and warnings
 449 # 3 some systems may open it to /dev/tty
 450 # 4 used on the Kubota Titan
 451 # 6 checking for... messages and results
 452 # 5 compiler messages saved in config.log
 453 if test "$silent" = yes; then
 454   exec 6>/dev/null
 455 else
 456   exec 6>&1
 457 fi
 458 exec 5>./config.log
 459
 460 echo "\
 461 This file contains any messages produced by compilers while
 462 running configure, to aid debugging if configure makes a mistake.
 463 " 1>&5
 464
 465 # Strip out --no-create and --no-recursion so they do not pile up.
 466 # Also quote any args containing shell metacharacters.
 467 ac_configure_args=
 468 for ac_arg
 469 do
 470   case "$ac_arg" in
 471   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 472   | --no-cr | --no-c) ;;
 473   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 474   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 475   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 476   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 477   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 478   esac
 479 done
 480
 481 # NLS nuisances.
 482 # Only set these to C if already set.  These must not be set unconditionally
 483 # because not all systems understand e.g. LANG=C (notably SCO).
 484 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 485 # Non-C LC_CTYPE values break the ctype check.
 486 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 487 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 488 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 489 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 490
 491 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 492 rm -rf conftest* confdefs.h
 493 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 494 echo > confdefs.h
 495
 496 # A filename unique to this package, relative to the directory that
 497 # configure is in, which we can look for to find out if srcdir is correct.
 498 ac_unique_file=src/complex.cc
 499
 500 # Find the source files, if location was not specified.
 501 if test -z "$srcdir"; then
 502   ac_srcdir_defaulted=yes
 503   # Try the directory containing this script, then its parent.
 504   ac_prog=$0
 505   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 506   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 507   srcdir=$ac_confdir
 508   if test ! -r $srcdir/$ac_unique_file; then
 509     srcdir=..
 510   fi
 511 else
 512   ac_srcdir_defaulted=no
 513 fi
 514 if test ! -r $srcdir/$ac_unique_file; then
 515   if test "$ac_srcdir_defaulted" = yes; then
 516     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 517   else
 518     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 519   fi
 520 fi
 521 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 522
 523 # Prefer explicitly selected file to automatically selected ones.
 524 if test -z "$CONFIG_SITE"; then
 525   if test "x$prefix" != xNONE; then
 526     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527   else
 528     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529   fi
 530 fi
 531 for ac_site_file in $CONFIG_SITE; do
 532   if test -r "$ac_site_file"; then
 533     echo "loading site script $ac_site_file"
 534     . "$ac_site_file"
 535   fi
 536 done
 537
 538 if test -r "$cache_file"; then
 539   echo "loading cache $cache_file"
 540   . $cache_file
 541 else
 542   echo "creating cache $cache_file"
 543   > $cache_file
 544 fi
 545
 546 ac_ext=c
 547 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 548 ac_cpp='$CPP $CPPFLAGS'
 549 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 550 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 551 cross_compiling=$ac_cv_prog_cc_cross
 552
 553 ac_exeext=
 554 ac_objext=o
 555 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 556   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 557   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 558     ac_n= ac_c='
 559 ' ac_t='        '
 560   else
 561     ac_n=-n ac_c= ac_t=
 562   fi
 563 else
 564   ac_n= ac_c='\c' ac_t=
 565 fi
 566
 567
 568 ac_aux_dir=
 569 for ac_dir in .. $srcdir/..; do
 570   if test -f $ac_dir/install-sh; then
 571     ac_aux_dir=$ac_dir
 572     ac_install_sh="$ac_aux_dir/install-sh -c"
 573     break
 574   elif test -f $ac_dir/install.sh; then
 575     ac_aux_dir=$ac_dir
 576     ac_install_sh="$ac_aux_dir/install.sh -c"
 577     break
 578   fi
 579 done
 580 if test -z "$ac_aux_dir"; then
 581   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 582 fi
 583 ac_config_guess=$ac_aux_dir/config.guess
 584 ac_config_sub=$ac_aux_dir/config.sub
 585 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 586
 587
 588 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 589
 590 # Do some error checking and defaulting for the host and target type.
 591 # The inputs are:
 592 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 593 #
 594 # The rules are:
 595 # 1. You are not allowed to specify --host, --target, and nonopt at the
 596 #    same time.
 597 # 2. Host defaults to nonopt.
 598 # 3. If nonopt is not specified, then host defaults to the current host,
 599 #    as determined by config.guess.
 600 # 4. Target and build default to nonopt.
 601 # 5. If nonopt is not specified, then target and build default to host.
 602
 603 # The aliases save the names the user supplied, while $host etc.
 604 # will get canonicalized.
 605 case $host---$target---$nonopt in
 606 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 607 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 608 esac
 609
 610
 611 # Make sure we can run config.sub.
 612 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 613 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 614 fi
 615
 616 echo $ac_n "checking host system type""... $ac_c" 1>&6
 617 echo "configure:618: checking host system type" >&5
 618
 619 host_alias=$host
 620 case "$host_alias" in
 621 NONE)
 622   case $nonopt in
 623   NONE)
 624     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 625     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 626     fi ;;
 627   *) host_alias=$nonopt ;;
 628   esac ;;
 629 esac
 630
 631 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 632 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 633 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 634 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 635 echo "$ac_t""$host" 1>&6
 636
 637 echo $ac_n "checking target system type""... $ac_c" 1>&6
 638 echo "configure:639: checking target system type" >&5
 639
 640 target_alias=$target
 641 case "$target_alias" in
 642 NONE)
 643   case $nonopt in
 644   NONE) target_alias=$host_alias ;;
 645   *) target_alias=$nonopt ;;
 646   esac ;;
 647 esac
 648
 649 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 650 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 651 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 652 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 653 echo "$ac_t""$target" 1>&6
 654
 655 echo $ac_n "checking build system type""... $ac_c" 1>&6
 656 echo "configure:657: checking build system type" >&5
 657
 658 build_alias=$build
 659 case "$build_alias" in
 660 NONE)
 661   case $nonopt in
 662   NONE) build_alias=$host_alias ;;
 663   *) build_alias=$nonopt ;;
 664   esac ;;
 665 esac
 666
 667 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 668 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 669 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 670 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 671 echo "$ac_t""$build" 1>&6
 672
 673 test "$host_alias" != "$target_alias" &&
 674   test "$program_prefix$program_suffix$program_transform_name" = \
 675     NONENONEs,x,x, &&
 676   program_prefix=${target_alias}-
 677
 678
 679 # We use these options to decide which functions to include.
 680 # Check whether --with-target-subdir or --without-target-subdir was given.
 681 if test "${with_target_subdir+set}" = set; then
 682   withval="$with_target_subdir"
 683   :
 684 fi
 685
 686 # Check whether --with-cross-host or --without-cross-host was given.
 687 if test "${with_cross_host+set}" = set; then
 688   withval="$with_cross_host"
 689   :
 690 fi
 691
 692
 693 # Runs configure.host and configure.target. Have to run this before
 694 # the GLIBCPP_ENABLE_* macros below.
 695 # Find a good install program.  We prefer a C program (faster),
 696 # so one script is as good as another.  But avoid the broken or
 697 # incompatible versions:
 698 # SysV /etc/install, /usr/sbin/install
 699 # SunOS /usr/etc/install
 700 # IRIX /sbin/install
 701 # AIX /bin/install
 702 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 703 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 704 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 705 # ./install, which can be erroneously created by make from ./install.sh.
 706 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 707 echo "configure:708: checking for a BSD compatible install" >&5
 708 if test -z "$INSTALL"; then
 709 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 710   echo $ac_n "(cached) $ac_c" 1>&6
 711 else
 712     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 713   for ac_dir in $PATH; do
 714     # Account for people who put trailing slashes in PATH elements.
 715     case "$ac_dir/" in
 716     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 717     *)
 718       # OSF1 and SCO ODT 3.0 have their own names for install.
 719       # Don't use installbsd from OSF since it installs stuff as root
 720       # by default.
 721       for ac_prog in ginstall scoinst install; do
 722         if test -f $ac_dir/$ac_prog; then
 723           if test $ac_prog = install &&
 724             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 725             # AIX install.  It has an incompatible calling convention.
 726             :
 727           else
 728             ac_cv_path_install="$ac_dir/$ac_prog -c"
 729             break 2
 730           fi
 731         fi
 732       done
 733       ;;
 734     esac
 735   done
 736   IFS="$ac_save_IFS"
 737
 738 fi
 739   if test "${ac_cv_path_install+set}" = set; then
 740     INSTALL="$ac_cv_path_install"
 741   else
 742     # As a last resort, use the slow shell script.  We don't cache a
 743     # path for INSTALL within a source directory, because that will
 744     # break other packages using the cache if that directory is
 745     # removed, or if the path is relative.
 746     INSTALL="$ac_install_sh"
 747   fi
 748 fi
 749 echo "$ac_t""$INSTALL" 1>&6
 750
 751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 752 # It thinks the first close brace ends the variable substitution.
 753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 754
 755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 756
 757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 758
 759 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 760 echo "configure:761: checking whether build environment is sane" >&5
 761 # Just in case
 762 sleep 1
 763 echo timestamp > conftestfile
 764 # Do `set' in a subshell so we don't clobber the current shell's
 765 # arguments.  Must try -L first in case configure is actually a
 766 # symlink; some systems play weird games with the mod time of symlinks
 767 # (eg FreeBSD returns the mod time of the symlink's containing
 768 # directory).
 769 if (
 770    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 771    if test "$*" = "X"; then
 772       # -L didn't work.
 773       set X `ls -t $srcdir/configure conftestfile`
 774    fi
 775    if test "$*" != "X $srcdir/configure conftestfile" \
 776       && test "$*" != "X conftestfile $srcdir/configure"; then
 777
 778       # If neither matched, then we have a broken ls.  This can happen
 779       # if, for instance, CONFIG_SHELL is bash and it inherits a
 780       # broken ls alias from the environment.  This has actually
 781       # happened.  Such a system could not be considered "sane".
 782       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 783 alias in your environment" 1>&2; exit 1; }
 784    fi
 785
 786    test "$2" = conftestfile
 787    )
 788 then
 789    # Ok.
 790    :
 791 else
 792    { echo "configure: error: newly created file is older than distributed files!
 793 Check your system clock" 1>&2; exit 1; }
 794 fi
 795 rm -f conftest*
 796 echo "$ac_t""yes" 1>&6
 797 if test "$program_transform_name" = s,x,x,; then
 798   program_transform_name=
 799 else
 800   # Double any \ or $.  echo might interpret backslashes.
 801   cat <<\EOF_SED > conftestsed
 802 s,\\,\\\\,g; s,\$,$$,g
 803 EOF_SED
 804   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 805   rm -f conftestsed
 806 fi
 807 test "$program_prefix" != NONE &&
 808   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 809 # Use a double $ so make ignores it.
 810 test "$program_suffix" != NONE &&
 811   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 812
 813 # sed with no file args requires a program.
 814 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 815
 816 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 817 echo "configure:818: checking whether ${MAKE-make} sets \${MAKE}" >&5
 818 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 819 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 820   echo $ac_n "(cached) $ac_c" 1>&6
 821 else
 822   cat > conftestmake <<\EOF
 823 all:
 824         @echo 'ac_maketemp="${MAKE}"'
 825 EOF
 826 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 827 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 828 if test -n "$ac_maketemp"; then
 829   eval ac_cv_prog_make_${ac_make}_set=yes
 830 else
 831   eval ac_cv_prog_make_${ac_make}_set=no
 832 fi
 833 rm -f conftestmake
 834 fi
 835 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 836   echo "$ac_t""yes" 1>&6
 837   SET_MAKE=
 838 else
 839   echo "$ac_t""no" 1>&6
 840   SET_MAKE="MAKE=${MAKE-make}"
 841 fi
 842
 843 if test $host != $build; then
 844   ac_tool_prefix=${host_alias}-
 845 else
 846   ac_tool_prefix=
 847 fi
 848
 849 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 850 echo "configure:851: checking for Cygwin environment" >&5
 851 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 852   echo $ac_n "(cached) $ac_c" 1>&6
 853 else
 854   cat > conftest.$ac_ext <<EOF
 855 #line 856 "configure"
 856 #include "confdefs.h"
 857
 858 int main() {
 859
 860 #ifndef __CYGWIN__
 861 #define __CYGWIN__ __CYGWIN32__
 862 #endif
 863 return __CYGWIN__;
 864 ; return 0; }
 865 EOF
 866 if { (eval echo configure:867: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 867   rm -rf conftest*
 868   ac_cv_cygwin=yes
 869 else
 870   echo "configure: failed program was:" >&5
 871   cat conftest.$ac_ext >&5
 872   rm -rf conftest*
 873   ac_cv_cygwin=no
 874 fi
 875 rm -f conftest*
 876 rm -f conftest*
 877 fi
 878
 879 echo "$ac_t""$ac_cv_cygwin" 1>&6
 880 CYGWIN=
 881 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 882 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 883 echo "configure:884: checking for mingw32 environment" >&5
 884 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 885   echo $ac_n "(cached) $ac_c" 1>&6
 886 else
 887   cat > conftest.$ac_ext <<EOF
 888 #line 889 "configure"
 889 #include "confdefs.h"
 890
 891 int main() {
 892 return __MINGW32__;
 893 ; return 0; }
 894 EOF
 895 if { (eval echo configure:896: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 896   rm -rf conftest*
 897   ac_cv_mingw32=yes
 898 else
 899   echo "configure: failed program was:" >&5
 900   cat conftest.$ac_ext >&5
 901   rm -rf conftest*
 902   ac_cv_mingw32=no
 903 fi
 904 rm -f conftest*
 905 rm -f conftest*
 906 fi
 907
 908 echo "$ac_t""$ac_cv_mingw32" 1>&6
 909 MINGW32=
 910 test "$ac_cv_mingw32" = yes && MINGW32=yes
 911
 912     # Check whether --enable-multilib or --disable-multilib was given.
 913 if test "${enable_multilib+set}" = set; then
 914   enableval="$enable_multilib"
 915   case "${enableval}" in
 916     yes) multilib=yes ;;
 917     no)  multilib=no ;;
 918     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 919    esac
 920 else
 921   multilib=yes
 922 fi
 923
 924       if test "${srcdir}" = "."; then
 925     if test "${with_target_subdir}" != "."; then
 926       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 927     else
 928       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 929     fi
 930   else
 931     glibcpp_basedir="${srcdir}/."
 932   fi
 933
 934
 935
 936 PACKAGE=libstdc++
 937
 938 VERSION=2.90.8
 939
 940 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 941   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 942 fi
 943 cat >> confdefs.h <<EOF
 944 #define PACKAGE "$PACKAGE"
 945 EOF
 946
 947 cat >> confdefs.h <<EOF
 948 #define VERSION "$VERSION"
 949 EOF
 950
 951
 952
 953 missing_dir=`cd $ac_aux_dir && pwd`
 954 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 955 echo "configure:956: checking for working aclocal" >&5
 956 # Run test in a subshell; some versions of sh will print an error if
 957 # an executable is not found, even if stderr is redirected.
 958 # Redirect stdin to placate older versions of autoconf.  Sigh.
 959 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 960    ACLOCAL=aclocal
 961    echo "$ac_t""found" 1>&6
 962 else
 963    ACLOCAL="$missing_dir/missing aclocal"
 964    echo "$ac_t""missing" 1>&6
 965 fi
 966
 967 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 968 echo "configure:969: checking for working autoconf" >&5
 969 # Run test in a subshell; some versions of sh will print an error if
 970 # an executable is not found, even if stderr is redirected.
 971 # Redirect stdin to placate older versions of autoconf.  Sigh.
 972 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 973    AUTOCONF=autoconf
 974    echo "$ac_t""found" 1>&6
 975 else
 976    AUTOCONF="$missing_dir/missing autoconf"
 977    echo "$ac_t""missing" 1>&6
 978 fi
 979
 980 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 981 echo "configure:982: checking for working automake" >&5
 982 # Run test in a subshell; some versions of sh will print an error if
 983 # an executable is not found, even if stderr is redirected.
 984 # Redirect stdin to placate older versions of autoconf.  Sigh.
 985 if (automake --version) < /dev/null > /dev/null 2>&1; then
 986    AUTOMAKE=automake
 987    echo "$ac_t""found" 1>&6
 988 else
 989    AUTOMAKE="$missing_dir/missing automake"
 990    echo "$ac_t""missing" 1>&6
 991 fi
 992
 993 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
 994 echo "configure:995: checking for working autoheader" >&5
 995 # Run test in a subshell; some versions of sh will print an error if
 996 # an executable is not found, even if stderr is redirected.
 997 # Redirect stdin to placate older versions of autoconf.  Sigh.
 998 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
 999    AUTOHEADER=autoheader
1000    echo "$ac_t""found" 1>&6
1001 else
1002    AUTOHEADER="$missing_dir/missing autoheader"
1003    echo "$ac_t""missing" 1>&6
1004 fi
1005
1006 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1007 echo "configure:1008: checking for working makeinfo" >&5
1008 # Run test in a subshell; some versions of sh will print an error if
1009 # an executable is not found, even if stderr is redirected.
1010 # Redirect stdin to placate older versions of autoconf.  Sigh.
1011 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1012    MAKEINFO=makeinfo
1013    echo "$ac_t""found" 1>&6
1014 else
1015    MAKEINFO="$missing_dir/missing makeinfo"
1016    echo "$ac_t""missing" 1>&6
1017 fi
1018
1019
1020
1021   # Never versions of autoconf add an underscore to these functions.
1022   # Prevent future problems ...
1023
1024
1025
1026
1027
1028 #  AC_PROG_CC
1029
1030 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1031 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1032 # are probably using a cross compiler, which will not be able to fully
1033 # link an executable.  This should really be fixed in autoconf
1034 # itself.
1035
1036
1037
1038
1039 # Extract the first word of "gcc", so it can be a program name with args.
1040 set dummy gcc; ac_word=$2
1041 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1042 echo "configure:1043: checking for $ac_word" >&5
1043 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1044   echo $ac_n "(cached) $ac_c" 1>&6
1045 else
1046   if test -n "$CC"; then
1047   ac_cv_prog_CC="$CC" # Let the user override the test.
1048 else
1049   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1050   ac_dummy="$PATH"
1051   for ac_dir in $ac_dummy; do
1052     test -z "$ac_dir" && ac_dir=.
1053     if test -f $ac_dir/$ac_word; then
1054       ac_cv_prog_CC="gcc"
1055       break
1056     fi
1057   done
1058   IFS="$ac_save_ifs"
1059 fi
1060 fi
1061 CC="$ac_cv_prog_CC"
1062 if test -n "$CC"; then
1063   echo "$ac_t""$CC" 1>&6
1064 else
1065   echo "$ac_t""no" 1>&6
1066 fi
1067
1068 if test -z "$CC"; then
1069   # Extract the first word of "cc", so it can be a program name with args.
1070 set dummy cc; ac_word=$2
1071 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1072 echo "configure:1073: checking for $ac_word" >&5
1073 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1074   echo $ac_n "(cached) $ac_c" 1>&6
1075 else
1076   if test -n "$CC"; then
1077   ac_cv_prog_CC="$CC" # Let the user override the test.
1078 else
1079   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1080   ac_prog_rejected=no
1081   ac_dummy="$PATH"
1082   for ac_dir in $ac_dummy; do
1083     test -z "$ac_dir" && ac_dir=.
1084     if test -f $ac_dir/$ac_word; then
1085       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1086         ac_prog_rejected=yes
1087         continue
1088       fi
1089       ac_cv_prog_CC="cc"
1090       break
1091     fi
1092   done
1093   IFS="$ac_save_ifs"
1094 if test $ac_prog_rejected = yes; then
1095   # We found a bogon in the path, so make sure we never use it.
1096   set dummy $ac_cv_prog_CC
1097   shift
1098   if test $# -gt 0; then
1099     # We chose a different compiler from the bogus one.
1100     # However, it has the same basename, so the bogon will be chosen
1101     # first if we set CC to just the basename; use the full file name.
1102     shift
1103     set dummy "$ac_dir/$ac_word" "$@"
1104     shift
1105     ac_cv_prog_CC="$@"
1106   fi
1107 fi
1108 fi
1109 fi
1110 CC="$ac_cv_prog_CC"
1111 if test -n "$CC"; then
1112   echo "$ac_t""$CC" 1>&6
1113 else
1114   echo "$ac_t""no" 1>&6
1115 fi
1116
1117   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1118 fi
1119
1120 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1121 echo "configure:1122: checking whether we are using GNU C" >&5
1122 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1123   echo $ac_n "(cached) $ac_c" 1>&6
1124 else
1125   cat > conftest.c <<EOF
1126 #ifdef __GNUC__
1127   yes;
1128 #endif
1129 EOF
1130 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1131: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1131   ac_cv_prog_gcc=yes
1132 else
1133   ac_cv_prog_gcc=no
1134 fi
1135 fi
1136
1137 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1138
1139 if test $ac_cv_prog_gcc = yes; then
1140   GCC=yes
1141   ac_test_CFLAGS="${CFLAGS+set}"
1142   ac_save_CFLAGS="$CFLAGS"
1143   CFLAGS=
1144   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1145 echo "configure:1146: checking whether ${CC-cc} accepts -g" >&5
1146 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1147   echo $ac_n "(cached) $ac_c" 1>&6
1148 else
1149   echo 'void f(){}' > conftest.c
1150 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1151   ac_cv_prog_cc_g=yes
1152 else
1153   ac_cv_prog_cc_g=no
1154 fi
1155 rm -f conftest*
1156
1157 fi
1158
1159 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1160   if test "$ac_test_CFLAGS" = set; then
1161     CFLAGS="$ac_save_CFLAGS"
1162   elif test $ac_cv_prog_cc_g = yes; then
1163     CFLAGS="-g -O2"
1164   else
1165     CFLAGS="-O2"
1166   fi
1167 else
1168   GCC=
1169   test "${CFLAGS+set}" = set || CFLAGS="-g"
1170 fi
1171
1172
1173 # Can't just call these here as g++ requires libstc++ to be built....
1174 #  AC_PROG_CXX
1175
1176 # Likewise for AC_PROG_CXX.
1177
1178
1179
1180 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1181 # flags that come in CXX while configuring libstdc++.  They're different
1182 # from those used for all other target libraries.  If CXX is set in
1183 # the environment, respect that here.
1184 CXX_libstdcxx=$CXX
1185 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1186 do
1187 # Extract the first word of "$ac_prog", so it can be a program name with args.
1188 set dummy $ac_prog; ac_word=$2
1189 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1190 echo "configure:1191: checking for $ac_word" >&5
1191 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1192   echo $ac_n "(cached) $ac_c" 1>&6
1193 else
1194   if test -n "$CXX_libstdcxx"; then
1195   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1196 else
1197   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1198   ac_dummy="$PATH"
1199   for ac_dir in $ac_dummy; do
1200     test -z "$ac_dir" && ac_dir=.
1201     if test -f $ac_dir/$ac_word; then
1202       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1203       break
1204     fi
1205   done
1206   IFS="$ac_save_ifs"
1207 fi
1208 fi
1209 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1210 if test -n "$CXX_libstdcxx"; then
1211   echo "$ac_t""$CXX_libstdcxx" 1>&6
1212 else
1213   echo "$ac_t""no" 1>&6
1214 fi
1215
1216 test -n "$CXX_libstdcxx" && break
1217 done
1218 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1219
1220 CXX=$CXX_libstdcxx
1221
1222 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1223
1224 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1225 echo "configure:1226: checking whether we are using GNU C++" >&5
1226 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1227   echo $ac_n "(cached) $ac_c" 1>&6
1228 else
1229   cat > conftest.C <<EOF
1230 #ifdef __GNUC__
1231   yes;
1232 #endif
1233 EOF
1234 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1235: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1235   ac_cv_prog_gxx=yes
1236 else
1237   ac_cv_prog_gxx=no
1238 fi
1239 fi
1240
1241 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1242
1243 if test $ac_cv_prog_gxx = yes; then
1244   GXX=yes
1245   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1246   ac_save_CXXFLAGS="$CXXFLAGS"
1247   CXXFLAGS=
1248   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1249 echo "configure:1250: checking whether ${CXX-g++} accepts -g" >&5
1250 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1251   echo $ac_n "(cached) $ac_c" 1>&6
1252 else
1253   echo 'void f(){}' > conftest.cc
1254 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1255   ac_cv_prog_cxx_g=yes
1256 else
1257   ac_cv_prog_cxx_g=no
1258 fi
1259 rm -f conftest*
1260
1261 fi
1262
1263 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1264   if test "$ac_test_CXXFLAGS" = set; then
1265     CXXFLAGS="$ac_save_CXXFLAGS"
1266   elif test $ac_cv_prog_cxx_g = yes; then
1267     CXXFLAGS="-g -O2"
1268   else
1269     CXXFLAGS="-O2"
1270   fi
1271 else
1272   GXX=
1273   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1274 fi
1275
1276
1277   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1278 set dummy ${ac_tool_prefix}as; ac_word=$2
1279 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1280 echo "configure:1281: checking for $ac_word" >&5
1281 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1282   echo $ac_n "(cached) $ac_c" 1>&6
1283 else
1284   if test -n "$AS"; then
1285   ac_cv_prog_AS="$AS" # Let the user override the test.
1286 else
1287   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1288   ac_dummy="$PATH"
1289   for ac_dir in $ac_dummy; do
1290     test -z "$ac_dir" && ac_dir=.
1291     if test -f $ac_dir/$ac_word; then
1292       ac_cv_prog_AS="${ac_tool_prefix}as"
1293       break
1294     fi
1295   done
1296   IFS="$ac_save_ifs"
1297   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1298 fi
1299 fi
1300 AS="$ac_cv_prog_AS"
1301 if test -n "$AS"; then
1302   echo "$ac_t""$AS" 1>&6
1303 else
1304   echo "$ac_t""no" 1>&6
1305 fi
1306
1307
1308
1309   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1310 set dummy ${ac_tool_prefix}ar; ac_word=$2
1311 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1312 echo "configure:1313: checking for $ac_word" >&5
1313 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1314   echo $ac_n "(cached) $ac_c" 1>&6
1315 else
1316   if test -n "$AR"; then
1317   ac_cv_prog_AR="$AR" # Let the user override the test.
1318 else
1319   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1320   ac_dummy="$PATH"
1321   for ac_dir in $ac_dummy; do
1322     test -z "$ac_dir" && ac_dir=.
1323     if test -f $ac_dir/$ac_word; then
1324       ac_cv_prog_AR="${ac_tool_prefix}ar"
1325       break
1326     fi
1327   done
1328   IFS="$ac_save_ifs"
1329   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1330 fi
1331 fi
1332 AR="$ac_cv_prog_AR"
1333 if test -n "$AR"; then
1334   echo "$ac_t""$AR" 1>&6
1335 else
1336   echo "$ac_t""no" 1>&6
1337 fi
1338
1339
1340
1341   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1342 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1343 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1344 echo "configure:1345: checking for $ac_word" >&5
1345 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1346   echo $ac_n "(cached) $ac_c" 1>&6
1347 else
1348   if test -n "$RANLIB"; then
1349   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1350 else
1351   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1352   ac_dummy="$PATH"
1353   for ac_dir in $ac_dummy; do
1354     test -z "$ac_dir" && ac_dir=.
1355     if test -f $ac_dir/$ac_word; then
1356       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1357       break
1358     fi
1359   done
1360   IFS="$ac_save_ifs"
1361 fi
1362 fi
1363 RANLIB="$ac_cv_prog_RANLIB"
1364 if test -n "$RANLIB"; then
1365   echo "$ac_t""$RANLIB" 1>&6
1366 else
1367   echo "$ac_t""no" 1>&6
1368 fi
1369
1370
1371 if test -z "$ac_cv_prog_RANLIB"; then
1372 if test -n "$ac_tool_prefix"; then
1373   # Extract the first word of "ranlib", so it can be a program name with args.
1374 set dummy ranlib; ac_word=$2
1375 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1376 echo "configure:1377: checking for $ac_word" >&5
1377 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1378   echo $ac_n "(cached) $ac_c" 1>&6
1379 else
1380   if test -n "$RANLIB"; then
1381   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1382 else
1383   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1384   ac_dummy="$PATH"
1385   for ac_dir in $ac_dummy; do
1386     test -z "$ac_dir" && ac_dir=.
1387     if test -f $ac_dir/$ac_word; then
1388       ac_cv_prog_RANLIB="ranlib"
1389       break
1390     fi
1391   done
1392   IFS="$ac_save_ifs"
1393   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403 else
1404   RANLIB=":"
1405 fi
1406 fi
1407
1408
1409   # Find a good install program.  We prefer a C program (faster),
1410 # so one script is as good as another.  But avoid the broken or
1411 # incompatible versions:
1412 # SysV /etc/install, /usr/sbin/install
1413 # SunOS /usr/etc/install
1414 # IRIX /sbin/install
1415 # AIX /bin/install
1416 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1417 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1418 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1419 # ./install, which can be erroneously created by make from ./install.sh.
1420 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1421 echo "configure:1422: checking for a BSD compatible install" >&5
1422 if test -z "$INSTALL"; then
1423 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1424   echo $ac_n "(cached) $ac_c" 1>&6
1425 else
1426     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1427   for ac_dir in $PATH; do
1428     # Account for people who put trailing slashes in PATH elements.
1429     case "$ac_dir/" in
1430     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1431     *)
1432       # OSF1 and SCO ODT 3.0 have their own names for install.
1433       # Don't use installbsd from OSF since it installs stuff as root
1434       # by default.
1435       for ac_prog in ginstall scoinst install; do
1436         if test -f $ac_dir/$ac_prog; then
1437           if test $ac_prog = install &&
1438             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1439             # AIX install.  It has an incompatible calling convention.
1440             :
1441           else
1442             ac_cv_path_install="$ac_dir/$ac_prog -c"
1443             break 2
1444           fi
1445         fi
1446       done
1447       ;;
1448     esac
1449   done
1450   IFS="$ac_save_IFS"
1451
1452 fi
1453   if test "${ac_cv_path_install+set}" = set; then
1454     INSTALL="$ac_cv_path_install"
1455   else
1456     # As a last resort, use the slow shell script.  We don't cache a
1457     # path for INSTALL within a source directory, because that will
1458     # break other packages using the cache if that directory is
1459     # removed, or if the path is relative.
1460     INSTALL="$ac_install_sh"
1461   fi
1462 fi
1463 echo "$ac_t""$INSTALL" 1>&6
1464
1465 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1466 # It thinks the first close brace ends the variable substitution.
1467 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1468
1469 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1470
1471 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1472
1473
1474   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1475 echo "configure:1476: checking whether to enable maintainer-specific portions of Makefiles" >&5
1476     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1477 if test "${enable_maintainer_mode+set}" = set; then
1478   enableval="$enable_maintainer_mode"
1479   USE_MAINTAINER_MODE=$enableval
1480 else
1481   USE_MAINTAINER_MODE=no
1482 fi
1483
1484   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1485
1486
1487 if test $USE_MAINTAINER_MODE = yes; then
1488   MAINTAINER_MODE_TRUE=
1489   MAINTAINER_MODE_FALSE='#'
1490 else
1491   MAINTAINER_MODE_TRUE='#'
1492   MAINTAINER_MODE_FALSE=
1493 fi
1494   MAINT=$MAINTAINER_MODE_TRUE
1495
1496
1497
1498   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1499   # at least currently, we never actually build a program, so we never
1500   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1501   # fails, because we are probably configuring with a cross compiler
1502   # which cant create executables.  So we include AC_EXEEXT to keep
1503   # automake happy, but we dont execute it, since we dont care about
1504   # the result.
1505   if false; then
1506
1507
1508 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1509 echo "configure:1510: checking for executable suffix" >&5
1510 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1511   echo $ac_n "(cached) $ac_c" 1>&6
1512 else
1513   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1514   ac_cv_exeext=.exe
1515 else
1516   rm -f conftest*
1517   echo 'int main () { return 0; }' > conftest.$ac_ext
1518   ac_cv_exeext=
1519   if { (eval echo configure:1520: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1520     for file in conftest.*; do
1521       case $file in
1522       *.c | *.o | *.obj) ;;
1523       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1524       esac
1525     done
1526   else
1527     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1528   fi
1529   rm -f conftest*
1530   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1531 fi
1532 fi
1533
1534 EXEEXT=""
1535 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1536 echo "$ac_t""${ac_cv_exeext}" 1>&6
1537 ac_exeext=$EXEEXT
1538
1539   fi
1540
1541   # configure.host sets the following important variables
1542   #        glibcpp_cflags    - host specific C compiler flags
1543   #        glibcpp_cxxflags  - host specific C++ compiler flags
1544   glibcpp_cflags=
1545   glibcpp_cxxflags=
1546
1547   . ${glibcpp_basedir}/configure.host
1548
1549   case ${glibcpp_basedir} in
1550     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1551     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1552   esac
1553
1554   # This does for the target what configure.host does for the host.  In
1555   # addition to modifying the same flags, it also sets up symlinks.
1556
1557     . ${glibcpp_basedir}/configure.target
1558     echo "$ac_t""CPU config directory is $cpu_include_dir" 1>&6
1559     echo "$ac_t""OS config directory is $os_include_dir" 1>&6
1560
1561
1562
1563   GLIBCPP_CFLAGS="${glibcpp_cflags}"
1564   GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1565
1566
1567
1568
1569
1570 # Check whether --enable-shared or --disable-shared was given.
1571 if test "${enable_shared+set}" = set; then
1572   enableval="$enable_shared"
1573   p=${PACKAGE-default}
1574 case "$enableval" in
1575 yes) enable_shared=yes ;;
1576 no) enable_shared=no ;;
1577 *)
1578   enable_shared=no
1579   # Look at the argument we got.  We use all the common list separators.
1580   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1581   for pkg in $enableval; do
1582     if test "X$pkg" = "X$p"; then
1583       enable_shared=yes
1584     fi
1585   done
1586   IFS="$ac_save_ifs"
1587   ;;
1588 esac
1589 else
1590   enable_shared=yes
1591 fi
1592
1593 # Check whether --enable-static or --disable-static was given.
1594 if test "${enable_static+set}" = set; then
1595   enableval="$enable_static"
1596   p=${PACKAGE-default}
1597 case "$enableval" in
1598 yes) enable_static=yes ;;
1599 no) enable_static=no ;;
1600 *)
1601   enable_static=no
1602   # Look at the argument we got.  We use all the common list separators.
1603   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1604   for pkg in $enableval; do
1605     if test "X$pkg" = "X$p"; then
1606       enable_static=yes
1607     fi
1608   done
1609   IFS="$ac_save_ifs"
1610   ;;
1611 esac
1612 else
1613   enable_static=yes
1614 fi
1615
1616 # Check whether --enable-fast-install or --disable-fast-install was given.
1617 if test "${enable_fast_install+set}" = set; then
1618   enableval="$enable_fast_install"
1619   p=${PACKAGE-default}
1620 case "$enableval" in
1621 yes) enable_fast_install=yes ;;
1622 no) enable_fast_install=no ;;
1623 *)
1624   enable_fast_install=no
1625   # Look at the argument we got.  We use all the common list separators.
1626   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1627   for pkg in $enableval; do
1628     if test "X$pkg" = "X$p"; then
1629       enable_fast_install=yes
1630     fi
1631   done
1632   IFS="$ac_save_ifs"
1633   ;;
1634 esac
1635 else
1636   enable_fast_install=yes
1637 fi
1638
1639 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1640 if test "${with_gnu_ld+set}" = set; then
1641   withval="$with_gnu_ld"
1642   test "$withval" = no || with_gnu_ld=yes
1643 else
1644   with_gnu_ld=no
1645 fi
1646
1647 ac_prog=ld
1648 if test "$ac_cv_prog_gcc" = yes; then
1649   # Check if gcc -print-prog-name=ld gives a path.
1650   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1651 echo "configure:1652: checking for ld used by GCC" >&5
1652   case $host in
1653   *-*-mingw*)
1654     # gcc leaves a trailing carriage return which upsets mingw
1655     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
1656   *)
1657     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
1658   esac
1659   case "$ac_prog" in
1660     # Accept absolute paths.
1661     [\\/]* | [A-Za-z]:[\\/]*)
1662       re_direlt='/[^/][^/]*/\.\./'
1663       # Canonicalize the path of ld
1664       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1665       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1666         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1667       done
1668       test -z "$LD" && LD="$ac_prog"
1669       ;;
1670   "")
1671     # If it fails, then pretend we aren't using GCC.
1672     ac_prog=ld
1673     ;;
1674   *)
1675     # If it is relative, then search for the first ld in PATH.
1676     with_gnu_ld=unknown
1677     ;;
1678   esac
1679 elif test "$with_gnu_ld" = yes; then
1680   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1681 echo "configure:1682: checking for GNU ld" >&5
1682 else
1683   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1684 echo "configure:1685: checking for non-GNU ld" >&5
1685 fi
1686 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1687   echo $ac_n "(cached) $ac_c" 1>&6
1688 else
1689   if test -z "$LD"; then
1690   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1691   for ac_dir in $PATH; do
1692     test -z "$ac_dir" && ac_dir=.
1693     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1694       ac_cv_path_LD="$ac_dir/$ac_prog"
1695       # Check to see if the program is GNU ld.  I'd rather use --version,
1696       # but apparently some GNU ld's only accept -v.
1697       # Break only if it was the GNU/non-GNU ld that we prefer.
1698       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1699         test "$with_gnu_ld" != no && break
1700       else
1701         test "$with_gnu_ld" != yes && break
1702       fi
1703     fi
1704   done
1705   IFS="$ac_save_ifs"
1706 else
1707   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1708 fi
1709 fi
1710
1711 LD="$ac_cv_path_LD"
1712 if test -n "$LD"; then
1713   echo "$ac_t""$LD" 1>&6
1714 else
1715   echo "$ac_t""no" 1>&6
1716 fi
1717 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1718 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1719 echo "configure:1720: checking if the linker ($LD) is GNU ld" >&5
1720 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1721   echo $ac_n "(cached) $ac_c" 1>&6
1722 else
1723   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1724 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1725   ac_cv_prog_gnu_ld=yes
1726 else
1727   ac_cv_prog_gnu_ld=no
1728 fi
1729 fi
1730
1731 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1732 with_gnu_ld=$ac_cv_prog_gnu_ld
1733
1734
1735 echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6
1736 echo "configure:1737: checking for $LD option to reload object files" >&5
1737 if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then
1738   echo $ac_n "(cached) $ac_c" 1>&6
1739 else
1740   lt_cv_ld_reload_flag='-r'
1741 fi
1742
1743 echo "$ac_t""$lt_cv_ld_reload_flag" 1>&6
1744 reload_flag=$lt_cv_ld_reload_flag
1745 test -n "$reload_flag" && reload_flag=" $reload_flag"
1746
1747 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1748 echo "configure:1749: checking for BSD-compatible nm" >&5
1749 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1750   echo $ac_n "(cached) $ac_c" 1>&6
1751 else
1752   if test -n "$NM"; then
1753   # Let the user override the test.
1754   ac_cv_path_NM="$NM"
1755 else
1756   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1757   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1758     test -z "$ac_dir" && ac_dir=.
1759     tmp_nm=$ac_dir/${ac_tool_prefix}nm
1760     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
1761       # Check to see if the nm accepts a BSD-compat flag.
1762       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1763       #   nm: unknown option "B" ignored
1764       # Tru64's nm complains that /dev/null is an invalid object file
1765       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
1766         ac_cv_path_NM="$tmp_nm -B"
1767         break
1768       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1769         ac_cv_path_NM="$tmp_nm -p"
1770         break
1771       else
1772         ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
1773         continue # so that we can try to find one that supports BSD flags
1774       fi
1775     fi
1776   done
1777   IFS="$ac_save_ifs"
1778   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1779 fi
1780 fi
1781
1782 NM="$ac_cv_path_NM"
1783 echo "$ac_t""$NM" 1>&6
1784
1785 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1786 echo "configure:1787: checking whether ln -s works" >&5
1787 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1788   echo $ac_n "(cached) $ac_c" 1>&6
1789 else
1790   rm -f conftestdata
1791 if ln -s X conftestdata 2>/dev/null
1792 then
1793   rm -f conftestdata
1794   ac_cv_prog_LN_S="ln -s"
1795 else
1796   ac_cv_prog_LN_S=ln
1797 fi
1798 fi
1799 LN_S="$ac_cv_prog_LN_S"
1800 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1801   echo "$ac_t""yes" 1>&6
1802 else
1803   echo "$ac_t""no" 1>&6
1804 fi
1805
1806 echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6
1807 echo "configure:1808: checking how to recognise dependant libraries" >&5
1808 if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then
1809   echo $ac_n "(cached) $ac_c" 1>&6
1810 else
1811   lt_cv_file_magic_cmd='$MAGIC_CMD'
1812 lt_cv_file_magic_test_file=
1813 lt_cv_deplibs_check_method='unknown'
1814 # Need to set the preceding variable on all platforms that support
1815 # interlibrary dependencies.
1816 # 'none' -- dependencies not supported.
1817 # `unknown' -- same as none, but documents that we really don't know.
1818 # 'pass_all' -- all dependencies passed with no checks.
1819 # 'test_compile' -- check by making test program.
1820 # 'file_magic [regex]' -- check by looking for files in library path
1821 # which responds to the $file_magic_cmd with a given egrep regex.
1822 # If you have `file' or equivalent on your system and you're not sure
1823 # whether `pass_all' will *always* work, you probably want this one.
1824
1825 case "$host_os" in
1826 aix4*)
1827   lt_cv_deplibs_check_method=pass_all
1828   ;;
1829
1830 beos*)
1831   lt_cv_deplibs_check_method=pass_all
1832   ;;
1833
1834 bsdi4*)
1835     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
1836     lt_cv_file_magic_cmd='/usr/bin/file -L'
1837   lt_cv_file_magic_test_file=/shlib/libc.so
1838   ;;
1839
1840 cygwin* | mingw* |pw32*)
1841   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
1842   lt_cv_file_magic_cmd='$OBJDUMP -f'
1843   ;;
1844
1845 freebsd* )
1846   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
1847     case "$host_cpu" in
1848     i*86 )
1849       # Not sure whether the presence of OpenBSD here was a mistake.
1850       # Let's accept both of them until this is cleared up.
1851             lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
1852             lt_cv_file_magic_cmd=/usr/bin/file
1853       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
1854       ;;
1855     esac
1856   else
1857     lt_cv_deplibs_check_method=pass_all
1858   fi
1859   ;;
1860
1861 gnu*)
1862   lt_cv_deplibs_check_method=pass_all
1863   ;;
1864
1865 hpux10.20*)
1866   # TODO:  Does this work for hpux-11 too?
1867   lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9.0-9) shared library'
1868   lt_cv_file_magic_cmd=/usr/bin/file
1869   lt_cv_file_magic_test_file=/usr/lib/libc.sl
1870   ;;
1871
1872 irix5* | irix6*)
1873   case "$host_os" in
1874   irix5*)
1875     # this will be overridden with pass_all, but let us keep it just in case
1876     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
1877     ;;
1878   *)
1879     case "$LD" in
1880     *-32|*"-32 ") libmagic=32-bit;;
1881     *-n32|*"-n32 ") libmagic=N32;;
1882     *-64|*"-64 ") libmagic=64-bit;;
1883     *) libmagic=never-match;;
1884     esac
1885     # this will be overridden with pass_all, but let us keep it just in case
1886         lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
1887         ;;
1888   esac
1889   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
1890   lt_cv_deplibs_check_method=pass_all
1891   ;;
1892
1893 # This must be Linux ELF.
1894 linux-gnu*)
1895   case "$host_cpu" in
1896   alpha* | i*86 | powerpc* | sparc* | ia64* )
1897     lt_cv_deplibs_check_method=pass_all ;;
1898   *)
1899     # glibc up to 2.1.1 does not perform some relocations on ARM
1900         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
1901       esac
1902   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
1903   ;;
1904
1905 netbsd*)
1906   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
1907   else
1908         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
1909         lt_cv_file_magic_cmd='/usr/bin/file -L'
1910     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1911   fi
1912   ;;
1913
1914 osf3* | osf4* | osf5*)
1915   # this will be overridden with pass_all, but let us keep it just in case
1916   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
1917   lt_cv_file_magic_test_file=/shlib/libc.so
1918   lt_cv_deplibs_check_method=pass_all
1919   ;;
1920
1921 sco3.2v5*)
1922   lt_cv_deplibs_check_method=pass_all
1923   ;;
1924
1925 solaris*)
1926   lt_cv_deplibs_check_method=pass_all
1927   lt_cv_file_magic_test_file=/lib/libc.so
1928   ;;
1929
1930 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
1931   case "$host_vendor" in
1932   ncr)
1933     lt_cv_deplibs_check_method=pass_all
1934     ;;
1935   motorola)
1936         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]'
1937         lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1938     ;;
1939   esac
1940   ;;
1941 esac
1942
1943 fi
1944
1945 echo "$ac_t""$lt_cv_deplibs_check_method" 1>&6
1946 file_magic_cmd=$lt_cv_file_magic_cmd
1947 deplibs_check_method=$lt_cv_deplibs_check_method
1948
1949 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
1950 echo "configure:1951: checking for object suffix" >&5
1951 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
1952   echo $ac_n "(cached) $ac_c" 1>&6
1953 else
1954   rm -f conftest*
1955 echo 'int i = 1;' > conftest.$ac_ext
1956 if { (eval echo configure:1957: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1957   for ac_file in conftest.*; do
1958     case $ac_file in
1959     *.c) ;;
1960     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
1961     esac
1962   done
1963 else
1964   { echo "configure: error: installation or configuration problem; compiler does not work" 1>&2; exit 1; }
1965 fi
1966 rm -f conftest*
1967 fi
1968
1969 echo "$ac_t""$ac_cv_objext" 1>&6
1970 OBJEXT=$ac_cv_objext
1971 ac_objext=$ac_cv_objext
1972
1973 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
1974
1975 # Only perform the check for file, if the check method requires it
1976 case "$deplibs_check_method" in
1977 file_magic*)
1978   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
1979     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
1980 echo "configure:1981: checking for ${ac_tool_prefix}file" >&5
1981 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
1982   echo $ac_n "(cached) $ac_c" 1>&6
1983 else
1984   case "$MAGIC_CMD" in
1985   /*)
1986   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
1987   ;;
1988   ?:/*)
1989   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
1990   ;;
1991   *)
1992   ac_save_MAGIC_CMD="$MAGIC_CMD"
1993   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1994   ac_dummy="/usr/bin:$PATH"
1995   for ac_dir in $ac_dummy; do
1996     test -z "$ac_dir" && ac_dir=.
1997     if test -f $ac_dir/${ac_tool_prefix}file; then
1998       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
1999       if test -n "$file_magic_test_file"; then
2000         case "$deplibs_check_method" in
2001         "file_magic "*)
2002           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2003           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2004           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2005             egrep "$file_magic_regex" > /dev/null; then
2006             :
2007           else
2008             cat <<EOF 1>&2
2009
2010 *** Warning: the command libtool uses to detect shared libraries,
2011 *** $file_magic_cmd, produces output that libtool cannot recognize.
2012 *** The result is that libtool may fail to recognize shared libraries
2013 *** as such.  This will affect the creation of libtool libraries that
2014 *** depend on shared libraries, but programs linked with such libtool
2015 *** libraries will work regardless of this problem.  Nevertheless, you
2016 *** may want to report the problem to your system manager and/or to
2017 *** bug-libtool@gnu.org
2018
2019 EOF
2020           fi ;;
2021         esac
2022       fi
2023       break
2024     fi
2025   done
2026   IFS="$ac_save_ifs"
2027   MAGIC_CMD="$ac_save_MAGIC_CMD"
2028   ;;
2029 esac
2030 fi
2031
2032 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2033 if test -n "$MAGIC_CMD"; then
2034   echo "$ac_t""$MAGIC_CMD" 1>&6
2035 else
2036   echo "$ac_t""no" 1>&6
2037 fi
2038
2039 if test -z "$lt_cv_path_MAGIC_CMD"; then
2040   if test -n "$ac_tool_prefix"; then
2041     echo $ac_n "checking for file""... $ac_c" 1>&6
2042 echo "configure:2043: checking for file" >&5
2043 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
2044   echo $ac_n "(cached) $ac_c" 1>&6
2045 else
2046   case "$MAGIC_CMD" in
2047   /*)
2048   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2049   ;;
2050   ?:/*)
2051   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
2052   ;;
2053   *)
2054   ac_save_MAGIC_CMD="$MAGIC_CMD"
2055   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2056   ac_dummy="/usr/bin:$PATH"
2057   for ac_dir in $ac_dummy; do
2058     test -z "$ac_dir" && ac_dir=.
2059     if test -f $ac_dir/file; then
2060       lt_cv_path_MAGIC_CMD="$ac_dir/file"
2061       if test -n "$file_magic_test_file"; then
2062         case "$deplibs_check_method" in
2063         "file_magic "*)
2064           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2065           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2066           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2067             egrep "$file_magic_regex" > /dev/null; then
2068             :
2069           else
2070             cat <<EOF 1>&2
2071
2072 *** Warning: the command libtool uses to detect shared libraries,
2073 *** $file_magic_cmd, produces output that libtool cannot recognize.
2074 *** The result is that libtool may fail to recognize shared libraries
2075 *** as such.  This will affect the creation of libtool libraries that
2076 *** depend on shared libraries, but programs linked with such libtool
2077 *** libraries will work regardless of this problem.  Nevertheless, you
2078 *** may want to report the problem to your system manager and/or to
2079 *** bug-libtool@gnu.org
2080
2081 EOF
2082           fi ;;
2083         esac
2084       fi
2085       break
2086     fi
2087   done
2088   IFS="$ac_save_ifs"
2089   MAGIC_CMD="$ac_save_MAGIC_CMD"
2090   ;;
2091 esac
2092 fi
2093
2094 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2095 if test -n "$MAGIC_CMD"; then
2096   echo "$ac_t""$MAGIC_CMD" 1>&6
2097 else
2098   echo "$ac_t""no" 1>&6
2099 fi
2100
2101   else
2102     MAGIC_CMD=:
2103   fi
2104 fi
2105
2106   fi
2107   ;;
2108 esac
2109
2110 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
2111 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
2112 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2113 echo "configure:2114: checking for $ac_word" >&5
2114 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2115   echo $ac_n "(cached) $ac_c" 1>&6
2116 else
2117   if test -n "$RANLIB"; then
2118   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2119 else
2120   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2121   ac_dummy="$PATH"
2122   for ac_dir in $ac_dummy; do
2123     test -z "$ac_dir" && ac_dir=.
2124     if test -f $ac_dir/$ac_word; then
2125       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
2126       break
2127     fi
2128   done
2129   IFS="$ac_save_ifs"
2130 fi
2131 fi
2132 RANLIB="$ac_cv_prog_RANLIB"
2133 if test -n "$RANLIB"; then
2134   echo "$ac_t""$RANLIB" 1>&6
2135 else
2136   echo "$ac_t""no" 1>&6
2137 fi
2138
2139
2140 if test -z "$ac_cv_prog_RANLIB"; then
2141 if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "ranlib", so it can be a program name with args.
2143 set dummy ranlib; ac_word=$2
2144 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2145 echo "configure:2146: checking for $ac_word" >&5
2146 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2147   echo $ac_n "(cached) $ac_c" 1>&6
2148 else
2149   if test -n "$RANLIB"; then
2150   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2151 else
2152   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2153   ac_dummy="$PATH"
2154   for ac_dir in $ac_dummy; do
2155     test -z "$ac_dir" && ac_dir=.
2156     if test -f $ac_dir/$ac_word; then
2157       ac_cv_prog_RANLIB="ranlib"
2158       break
2159     fi
2160   done
2161   IFS="$ac_save_ifs"
2162   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
2163 fi
2164 fi
2165 RANLIB="$ac_cv_prog_RANLIB"
2166 if test -n "$RANLIB"; then
2167   echo "$ac_t""$RANLIB" 1>&6
2168 else
2169   echo "$ac_t""no" 1>&6
2170 fi
2171
2172 else
2173   RANLIB=":"
2174 fi
2175 fi
2176
2177 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
2178 set dummy ${ac_tool_prefix}strip; ac_word=$2
2179 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2180 echo "configure:2181: checking for $ac_word" >&5
2181 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2182   echo $ac_n "(cached) $ac_c" 1>&6
2183 else
2184   if test -n "$STRIP"; then
2185   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2186 else
2187   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2188   ac_dummy="$PATH"
2189   for ac_dir in $ac_dummy; do
2190     test -z "$ac_dir" && ac_dir=.
2191     if test -f $ac_dir/$ac_word; then
2192       ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2193       break
2194     fi
2195   done
2196   IFS="$ac_save_ifs"
2197 fi
2198 fi
2199 STRIP="$ac_cv_prog_STRIP"
2200 if test -n "$STRIP"; then
2201   echo "$ac_t""$STRIP" 1>&6
2202 else
2203   echo "$ac_t""no" 1>&6
2204 fi
2205
2206
2207 if test -z "$ac_cv_prog_STRIP"; then
2208 if test -n "$ac_tool_prefix"; then
2209   # Extract the first word of "strip", so it can be a program name with args.
2210 set dummy strip; ac_word=$2
2211 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2212 echo "configure:2213: checking for $ac_word" >&5
2213 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2214   echo $ac_n "(cached) $ac_c" 1>&6
2215 else
2216   if test -n "$STRIP"; then
2217   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2218 else
2219   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2220   ac_dummy="$PATH"
2221   for ac_dir in $ac_dummy; do
2222     test -z "$ac_dir" && ac_dir=.
2223     if test -f $ac_dir/$ac_word; then
2224       ac_cv_prog_STRIP="strip"
2225       break
2226     fi
2227   done
2228   IFS="$ac_save_ifs"
2229   test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP=":"
2230 fi
2231 fi
2232 STRIP="$ac_cv_prog_STRIP"
2233 if test -n "$STRIP"; then
2234   echo "$ac_t""$STRIP" 1>&6
2235 else
2236   echo "$ac_t""no" 1>&6
2237 fi
2238
2239 else
2240   STRIP=":"
2241 fi
2242 fi
2243
2244
2245 # Check for any special flags to pass to ltconfig.
2246 libtool_flags="--cache-file=$cache_file"
2247 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
2248 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
2249 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
2250 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
2251 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
2252 libtool_flags="$libtool_flags --enable-dlopen"
2253
2254 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
2255 if test "${enable_libtool_lock+set}" = set; then
2256   enableval="$enable_libtool_lock"
2257   :
2258 fi
2259
2260 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
2261 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
2262
2263 # Check whether --with-pic or --without-pic was given.
2264 if test "${with_pic+set}" = set; then
2265   withval="$with_pic"
2266   pic_mode="$withval"
2267 else
2268   pic_mode=default
2269 fi
2270
2271 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
2272 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
2273
2274 # Some flags need to be propagated to the compiler or linker for good
2275 # libtool support.
2276 case "$host" in
2277 *-*-irix6*)
2278   # Find out which ABI we are using.
2279   echo '#line 2280 "configure"' > conftest.$ac_ext
2280   if { (eval echo configure:2281: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2281     case "`/usr/bin/file conftest.o`" in
2282     *32-bit*)
2283       LD="${LD-ld} -32"
2284       ;;
2285     *N32*)
2286       LD="${LD-ld} -n32"
2287       ;;
2288     *64-bit*)
2289       LD="${LD-ld} -64"
2290       ;;
2291     esac
2292   fi
2293   rm -rf conftest*
2294   ;;
2295
2296 *-*-sco3.2v5*)
2297   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
2298   SAVE_CFLAGS="$CFLAGS"
2299   CFLAGS="$CFLAGS -belf"
2300   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
2301 echo "configure:2302: checking whether the C compiler needs -belf" >&5
2302 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
2303   echo $ac_n "(cached) $ac_c" 1>&6
2304 else
2305
2306      ac_ext=c
2307 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2308 ac_cpp='$CPP $CPPFLAGS'
2309 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2310 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2311 cross_compiling=$ac_cv_prog_cc_cross
2312
2313      cat > conftest.$ac_ext <<EOF
2314 #line 2315 "configure"
2315 #include "confdefs.h"
2316
2317 int main() {
2318
2319 ; return 0; }
2320 EOF
2321 if { (eval echo configure:2322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2322   rm -rf conftest*
2323   lt_cv_cc_needs_belf=yes
2324 else
2325   echo "configure: failed program was:" >&5
2326   cat conftest.$ac_ext >&5
2327   rm -rf conftest*
2328   lt_cv_cc_needs_belf=no
2329 fi
2330 rm -f conftest*
2331      ac_ext=c
2332 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2333 ac_cpp='$CPP $CPPFLAGS'
2334 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2335 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2336 cross_compiling=$ac_cv_prog_cc_cross
2337
2338 fi
2339
2340 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
2341   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
2342     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
2343     CFLAGS="$SAVE_CFLAGS"
2344   fi
2345   ;;
2346
2347
2348 esac
2349
2350 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
2351 echo "configure:2352: checking how to run the C++ preprocessor" >&5
2352 if test -z "$CXXCPP"; then
2353 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
2354   echo $ac_n "(cached) $ac_c" 1>&6
2355 else
2356   ac_ext=C
2357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2358 ac_cpp='$CXXCPP $CPPFLAGS'
2359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2361 cross_compiling=$ac_cv_prog_cxx_cross
2362   CXXCPP="${CXX-g++} -E"
2363   cat > conftest.$ac_ext <<EOF
2364 #line 2365 "configure"
2365 #include "confdefs.h"
2366 #include <stdlib.h>
2367 EOF
2368 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2369 { (eval echo configure:2370: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2370 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2371 if test -z "$ac_err"; then
2372   :
2373 else
2374   echo "$ac_err" >&5
2375   echo "configure: failed program was:" >&5
2376   cat conftest.$ac_ext >&5
2377   rm -rf conftest*
2378   CXXCPP=/lib/cpp
2379 fi
2380 rm -f conftest*
2381   ac_cv_prog_CXXCPP="$CXXCPP"
2382 ac_ext=c
2383 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2384 ac_cpp='$CPP $CPPFLAGS'
2385 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2386 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2387 cross_compiling=$ac_cv_prog_cc_cross
2388 fi
2389 fi
2390 CXXCPP="$ac_cv_prog_CXXCPP"
2391 echo "$ac_t""$CXXCPP" 1>&6
2392
2393
2394 # Save cache, so that ltconfig can load it
2395 cat > confcache <<\EOF
2396 # This file is a shell script that caches the results of configure
2397 # tests run on this system so they can be shared between configure
2398 # scripts and configure runs.  It is not useful on other systems.
2399 # If it contains results you don't want to keep, you may remove or edit it.
2400 #
2401 # By default, configure uses ./config.cache as the cache file,
2402 # creating it if it does not exist already.  You can give configure
2403 # the --cache-file=FILE option to use a different cache file; that is
2404 # what configure does when it calls configure scripts in
2405 # subdirectories, so they share the cache.
2406 # Giving --cache-file=/dev/null disables caching, for debugging configure.
2407 # config.status only pays attention to the cache file if you give it the
2408 # --recheck option to rerun configure.
2409 #
2410 EOF
2411 # The following way of writing the cache mishandles newlines in values,
2412 # but we know of no workaround that is simple, portable, and efficient.
2413 # So, don't put newlines in cache variables' values.
2414 # Ultrix sh set writes to stderr and can't be redirected directly,
2415 # and sets the high bit in the cache file unless we assign to the vars.
2416 (set) 2>&1 |
2417   case `(ac_space=' '; set | grep ac_space) 2>&1` in
2418   *ac_space=\ *)
2419     # `set' does not quote correctly, so add quotes (double-quote substitution
2420     # turns \\\\ into \\, and sed turns \\ into \).
2421     sed -n \
2422       -e "s/'/'\\\\''/g" \
2423       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
2424     ;;
2425   *)
2426     # `set' quotes correctly as required by POSIX, so do not add quotes.
2427     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
2428     ;;
2429   esac >> confcache
2430 if cmp -s $cache_file confcache; then
2431   :
2432 else
2433   if test -w $cache_file; then
2434     echo "updating cache $cache_file"
2435     cat confcache > $cache_file
2436   else
2437     echo "not updating unwritable cache $cache_file"
2438   fi
2439 fi
2440 rm -f confcache
2441
2442
2443 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
2444 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
2445 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2446 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2447 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2448 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2449 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
2450 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2451 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
2452 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2453
2454 # Reload cache, that may have been modified by ltconfig
2455 if test -r "$cache_file"; then
2456   echo "loading cache $cache_file"
2457   . $cache_file
2458 else
2459   echo "creating cache $cache_file"
2460   > $cache_file
2461 fi
2462
2463
2464 # This can be used to rebuild libtool when needed
2465 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
2466
2467 # Always use our own libtool.
2468 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2469
2470 # Redirect the config.log output again, so that the ltconfig log is not
2471 # clobbered by the next message.
2472 exec 5>>./config.log
2473
2474
2475
2476
2477 LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh"
2478 lt_save_CC="$CC"
2479 lt_save_CFLAGS="$CFLAGS"
2480 AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \
2481 MAGIC_CMD="$MAGIC_CMD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2482 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2483 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2484 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2485 deplibs_check_method="$deplibs_check_method" \
2486 file_magic_cmd="$file_magic_cmd" \
2487 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \
2488 --build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \
2489 || { echo "configure: error: libtool tag configuration failed" 1>&2; exit 1; }
2490 CC="$lt_save_CC"
2491 CFLAGS="$lt_save_CFLAGS"
2492
2493 # Redirect the config.log output again, so that the ltconfig log is not
2494 # clobbered by the next message.
2495 exec 5>>./config.log
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
2506 echo "configure:2507: checking for GNU make" >&5
2507 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
2508   echo $ac_n "(cached) $ac_c" 1>&6
2509 else
2510   _cv_gnu_make_command='' ;
2511           for a in "${MAKE:-make}" make gmake gnumake ; do
2512                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2513                   then
2514                           _cv_gnu_make_command=$a ;
2515                           break;
2516                   fi
2517           done ;
2518
2519 fi
2520
2521 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
2522   if test  "x$_cv_gnu_make_command" != "x"  ; then
2523           ifGNUmake='' ;
2524   else
2525           ifGNUmake='#' ;
2526   fi
2527
2528
2529   if test "x$_cv_gnu_make_command" = "x"; then
2530     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
2531   fi
2532
2533
2534
2535
2536 # Check for c++ or library specific bits that don't require linking.
2537
2538 if test ! -f stamp-sanity-compiler; then
2539   echo $ac_n "checking for g++ that will successfully compile libstdc++-v3""... $ac_c" 1>&6
2540 echo "configure:2541: checking for g++ that will successfully compile libstdc++-v3" >&5
2541
2542   ac_ext=C
2543 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2544 ac_cpp='$CXXCPP $CPPFLAGS'
2545 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2546 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2547 cross_compiling=$ac_cv_prog_cxx_cross
2548
2549   cat > conftest.$ac_ext <<EOF
2550 #line 2551 "configure"
2551 #include "confdefs.h"
2552
2553   #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2554     ok
2555   #endif
2556
2557 EOF
2558 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2559   egrep "ok" >/dev/null 2>&1; then
2560   rm -rf conftest*
2561   gpp_satisfactory=yes
2562 else
2563   rm -rf conftest*
2564   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2565 fi
2566 rm -f conftest*
2567
2568   ac_ext=c
2569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2570 ac_cpp='$CPP $CPPFLAGS'
2571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2573 cross_compiling=$ac_cv_prog_cc_cross
2574
2575   echo "$ac_t""$gpp_satisfactory" 1>&6
2576   touch stamp-sanity-compiler
2577 fi
2578
2579
2580 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2581 # Check whether --enable-debug or --disable-debug was given.
2582 if test "${enable_debug+set}" = set; then
2583   enableval="$enable_debug"
2584   case "${enableval}" in
2585  yes) enable_debug=yes ;;
2586  no)  enable_debug=no ;;
2587  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2588  esac
2589 else
2590   enable_debug=no
2591 fi
2592
2593 case "${enable_debug}" in
2594     yes)
2595         DEBUG_FLAGS='-O0 -ggdb3'
2596         ;;
2597     no)
2598         DEBUG_FLAGS='-g'
2599         ;;
2600 esac
2601
2602
2603 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2604 echo "configure:2605: checking how to run the C preprocessor" >&5
2605 # On Suns, sometimes $CPP names a directory.
2606 if test -n "$CPP" && test -d "$CPP"; then
2607   CPP=
2608 fi
2609 if test -z "$CPP"; then
2610 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2611   echo $ac_n "(cached) $ac_c" 1>&6
2612 else
2613     # This must be in double quotes, not single quotes, because CPP may get
2614   # substituted into the Makefile and "${CC-cc}" will confuse make.
2615   CPP="${CC-cc} -E"
2616   # On the NeXT, cc -E runs the code through the compiler's parser,
2617   # not just through cpp.
2618   cat > conftest.$ac_ext <<EOF
2619 #line 2620 "configure"
2620 #include "confdefs.h"
2621 #include <assert.h>
2622 Syntax Error
2623 EOF
2624 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2625 { (eval echo configure:2626: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2626 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2627 if test -z "$ac_err"; then
2628   :
2629 else
2630   echo "$ac_err" >&5
2631   echo "configure: failed program was:" >&5
2632   cat conftest.$ac_ext >&5
2633   rm -rf conftest*
2634   CPP="${CC-cc} -E -traditional-cpp"
2635   cat > conftest.$ac_ext <<EOF
2636 #line 2637 "configure"
2637 #include "confdefs.h"
2638 #include <assert.h>
2639 Syntax Error
2640 EOF
2641 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2642 { (eval echo configure:2643: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2643 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2644 if test -z "$ac_err"; then
2645   :
2646 else
2647   echo "$ac_err" >&5
2648   echo "configure: failed program was:" >&5
2649   cat conftest.$ac_ext >&5
2650   rm -rf conftest*
2651   CPP="${CC-cc} -nologo -E"
2652   cat > conftest.$ac_ext <<EOF
2653 #line 2654 "configure"
2654 #include "confdefs.h"
2655 #include <assert.h>
2656 Syntax Error
2657 EOF
2658 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2659 { (eval echo configure:2660: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2660 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2661 if test -z "$ac_err"; then
2662   :
2663 else
2664   echo "$ac_err" >&5
2665   echo "configure: failed program was:" >&5
2666   cat conftest.$ac_ext >&5
2667   rm -rf conftest*
2668   CPP=/lib/cpp
2669 fi
2670 rm -f conftest*
2671 fi
2672 rm -f conftest*
2673 fi
2674 rm -f conftest*
2675   ac_cv_prog_CPP="$CPP"
2676 fi
2677   CPP="$ac_cv_prog_CPP"
2678 else
2679   ac_cv_prog_CPP="$CPP"
2680 fi
2681 echo "$ac_t""$CPP" 1>&6
2682
2683
2684   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2685 echo "configure:2686: checking for cstdio to use" >&5
2686   # Check whether --enable-cstdio or --disable-cstdio was given.
2687 if test "${enable_cstdio+set}" = set; then
2688   enableval="$enable_cstdio"
2689   if test x$enable_cstdio = xno; then
2690      enable_cstdio=stdio
2691   fi
2692 else
2693   enable_cstdio=stdio
2694 fi
2695
2696
2697   enable_cstdio_flag=$enable_cstdio
2698
2699     case x${enable_cstdio_flag} in
2700     xlibio)
2701       CSTDIO_H=config/c_io_libio.h
2702       CSTDIO_CC=config/c_io_libio.cc
2703       echo "$ac_t""libio" 1>&6
2704
2705       # see if we are on a system with libio native (ie, linux)
2706       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2707 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2708 echo "configure:2709: checking for libio.h" >&5
2709 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2710   echo $ac_n "(cached) $ac_c" 1>&6
2711 else
2712   cat > conftest.$ac_ext <<EOF
2713 #line 2714 "configure"
2714 #include "confdefs.h"
2715 #include <libio.h>
2716 EOF
2717 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2718 { (eval echo configure:2719: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2719 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2720 if test -z "$ac_err"; then
2721   rm -rf conftest*
2722   eval "ac_cv_header_$ac_safe=yes"
2723 else
2724   echo "$ac_err" >&5
2725   echo "configure: failed program was:" >&5
2726   cat conftest.$ac_ext >&5
2727   rm -rf conftest*
2728   eval "ac_cv_header_$ac_safe=no"
2729 fi
2730 rm -f conftest*
2731 fi
2732 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2733   echo "$ac_t""yes" 1>&6
2734   has_libio=yes
2735 else
2736   echo "$ac_t""no" 1>&6
2737 has_libio=no
2738 fi
2739
2740
2741       # Need to check and see what version of glibc is being used. If
2742       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2743       # compile most of libio for linux systems.
2744       if test x$has_libio = x"yes"; then
2745         case "$target" in
2746           *-*-linux*)
2747               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2748 echo "configure:2749: checking for glibc version >= 2.2" >&5
2749               cat > conftest.$ac_ext <<EOF
2750 #line 2751 "configure"
2751 #include "confdefs.h"
2752
2753             #include <features.h>
2754               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2755                     ok
2756               #endif
2757
2758 EOF
2759 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2760   egrep "ok" >/dev/null 2>&1; then
2761   rm -rf conftest*
2762   glibc_satisfactory=yes
2763 else
2764   rm -rf conftest*
2765   glibc_satisfactory=no
2766 fi
2767 rm -f conftest*
2768
2769               echo "$ac_t""$glibc_satisfactory" 1>&6
2770             ;;
2771         esac
2772
2773         # XXX at the moment, admit defeat and force the recompilation
2774         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2775         glibc_satisfactory=no
2776
2777         if test x$glibc_satisfactory = x"yes"; then
2778            need_libio=no
2779            need_wlibio=no
2780         else
2781            need_libio=yes
2782            # bkoz XXX need to add checks to enable this
2783            # pme XXX here's a first pass at such a check
2784            if test x$enable_c_mbchar != xno; then
2785               need_wlibio=yes
2786            else
2787               need_wlibio=no
2788            fi
2789         fi
2790
2791       else
2792          # Using libio, but <libio.h> doesn't exist on the target system. . .
2793          need_libio=yes
2794          # bkoz XXX need to add checks to enable this
2795          # pme XXX here's a first pass at such a check
2796          if test x$enable_c_mbchar != xno; then
2797              need_wlibio=yes
2798          else
2799              need_wlibio=no
2800          fi
2801       fi
2802       ;;
2803     xstdio | x | xno | xnone | xyes)
2804       # default
2805       CSTDIO_H=config/c_io_stdio.h
2806       CSTDIO_CC=config/c_io_stdio.cc
2807       echo "$ac_t""stdio" 1>&6
2808
2809       # We're not using stdio.
2810       need_libio=no
2811       need_wlibio=no
2812       # Wide characters are not supported with this package.
2813       enable_c_mbchar=no
2814       ;;
2815     *)
2816       echo "$enable_cstdio is an unknown io package" 1>&2
2817       exit 1
2818       ;;
2819   esac
2820
2821
2822
2823   # 2000-08-04 bkoz hack
2824   CCODECVT_C=config/c_io_libio_codecvt.c
2825
2826   # 2000-08-04 bkoz hack
2827
2828
2829
2830 if test "$need_libio" = yes; then
2831   GLIBCPP_NEED_LIBIO_TRUE=
2832   GLIBCPP_NEED_LIBIO_FALSE='#'
2833 else
2834   GLIBCPP_NEED_LIBIO_TRUE='#'
2835   GLIBCPP_NEED_LIBIO_FALSE=
2836 fi
2837
2838
2839 if test "$need_wlibio" = yes; then
2840   GLIBCPP_NEED_WLIBIO_TRUE=
2841   GLIBCPP_NEED_WLIBIO_FALSE='#'
2842 else
2843   GLIBCPP_NEED_WLIBIO_TRUE='#'
2844   GLIBCPP_NEED_WLIBIO_FALSE=
2845 fi
2846   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2847         libio_la=../libio/libio.la
2848   else
2849         libio_la=
2850   fi
2851
2852
2853 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2854 if test "${enable_c_mbchar+set}" = set; then
2855   enableval="$enable_c_mbchar"
2856   case "$enableval" in
2857  yes) enable_c_mbchar=yes ;;
2858  no)  enable_c_mbchar=no ;;
2859  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2860  esac
2861 else
2862   enable_c_mbchar=yes
2863 fi
2864
2865
2866   # Check whether --enable-long-long or --disable-long-long was given.
2867 if test "${enable_long_long+set}" = set; then
2868   enableval="$enable_long_long"
2869     case "$enableval" in
2870    yes) enable_long_long=yes ;;
2871    no)  enable_long_long=no ;;
2872    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2873    esac
2874 else
2875   enable_long_long=yes
2876 fi
2877
2878   # Allow use of os-dependent settings, so that macros that turn on
2879   # C99 capabilities can be defined and used in a consistent way.
2880   OS_INC_PATH=${srcdir}/$os_include_dir
2881   ac_test_CFLAGS="${CFLAGS+set}"
2882   ac_save_CFLAGS="$CFLAGS"
2883   CFLAGS="-I$OS_INC_PATH"
2884
2885   # Check for the existence of functions used if long long is enabled.
2886   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2887 echo "configure:2888: checking for strtoll" >&5
2888 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2889   echo $ac_n "(cached) $ac_c" 1>&6
2890 else
2891   cat > conftest.$ac_ext <<EOF
2892 #line 2893 "configure"
2893 #include "confdefs.h"
2894 /* System header to define __stub macros and hopefully few prototypes,
2895     which can conflict with char strtoll(); below.  */
2896 #include <assert.h>
2897 /* Override any gcc2 internal prototype to avoid an error.  */
2898 /* We use char because int might match the return type of a gcc2
2899     builtin and then its argument prototype would still apply.  */
2900 char strtoll();
2901
2902 int main() {
2903
2904 /* The GNU C library defines this for functions which it implements
2905     to always fail with ENOSYS.  Some functions are actually named
2906     something starting with __ and the normal name is an alias.  */
2907 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2908 choke me
2909 #else
2910 strtoll();
2911 #endif
2912
2913 ; return 0; }
2914 EOF
2915 if { (eval echo configure:2916: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2916   rm -rf conftest*
2917   eval "ac_cv_func_strtoll=yes"
2918 else
2919   echo "configure: failed program was:" >&5
2920   cat conftest.$ac_ext >&5
2921   rm -rf conftest*
2922   eval "ac_cv_func_strtoll=no"
2923 fi
2924 rm -f conftest*
2925 fi
2926
2927 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2928   echo "$ac_t""yes" 1>&6
2929   :
2930 else
2931   echo "$ac_t""no" 1>&6
2932 ac_strtoll=no
2933 fi
2934
2935   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2936 echo "configure:2937: checking for strtoull" >&5
2937 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2938   echo $ac_n "(cached) $ac_c" 1>&6
2939 else
2940   cat > conftest.$ac_ext <<EOF
2941 #line 2942 "configure"
2942 #include "confdefs.h"
2943 /* System header to define __stub macros and hopefully few prototypes,
2944     which can conflict with char strtoull(); below.  */
2945 #include <assert.h>
2946 /* Override any gcc2 internal prototype to avoid an error.  */
2947 /* We use char because int might match the return type of a gcc2
2948     builtin and then its argument prototype would still apply.  */
2949 char strtoull();
2950
2951 int main() {
2952
2953 /* The GNU C library defines this for functions which it implements
2954     to always fail with ENOSYS.  Some functions are actually named
2955     something starting with __ and the normal name is an alias.  */
2956 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2957 choke me
2958 #else
2959 strtoull();
2960 #endif
2961
2962 ; return 0; }
2963 EOF
2964 if { (eval echo configure:2965: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2965   rm -rf conftest*
2966   eval "ac_cv_func_strtoull=yes"
2967 else
2968   echo "configure: failed program was:" >&5
2969   cat conftest.$ac_ext >&5
2970   rm -rf conftest*
2971   eval "ac_cv_func_strtoull=no"
2972 fi
2973 rm -f conftest*
2974 fi
2975
2976 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2977   echo "$ac_t""yes" 1>&6
2978   :
2979 else
2980   echo "$ac_t""no" 1>&6
2981 ac_strtoull=no
2982 fi
2983
2984
2985   # Check for lldiv_t, et. al.
2986   echo $ac_n "checking for lldiv_t declaration""... $ac_c" 1>&6
2987 echo "configure:2988: checking for lldiv_t declaration" >&5
2988   if eval "test \"`echo '$''{'glibcpp_lldiv_t_use'+set}'`\" = set"; then
2989   echo $ac_n "(cached) $ac_c" 1>&6
2990 else
2991
2992   cat > conftest.$ac_ext <<EOF
2993 #line 2994 "configure"
2994 #include "confdefs.h"
2995 #include <bits/os_defines.h>
2996                   #include <stdlib.h>
2997 int main() {
2998  lldiv_t mydivt;
2999 ; return 0; }
3000 EOF
3001 if { (eval echo configure:3002: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3002   rm -rf conftest*
3003   glibcpp_lldiv_t_use=yes
3004 else
3005   echo "configure: failed program was:" >&5
3006   cat conftest.$ac_ext >&5
3007   rm -rf conftest*
3008   glibcpp_lldiv_t_use=no
3009 fi
3010 rm -f conftest*
3011
3012 fi
3013
3014   echo "$ac_t""$glibcpp_lldiv_t_use" 1>&6
3015   if test x$glibcpp_lldiv_t_use = x"yes"; then
3016     cat >> confdefs.h <<\EOF
3017 #define _GLIBCPP_HAVE_LLDIV_T 1
3018 EOF
3019
3020   fi
3021
3022   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
3023 echo "configure:3024: checking for enabled long long" >&5
3024   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
3025     enable_long_long=no;
3026   fi;
3027   echo "$ac_t""$enable_long_long" 1>&6
3028
3029   # Option parsed, now set things appropriately
3030   if test x"$enable_long_long" = xyes; then
3031     cat >> confdefs.h <<\EOF
3032 #define _GLIBCPP_USE_LONG_LONG 1
3033 EOF
3034
3035   fi
3036
3037   # Reset CFLAGS
3038   CFLAGS="$ac_save_CFLAGS"
3039
3040 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
3041 echo "configure:3042: checking for enabled cshadow headers" >&5
3042 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
3043 if test "${enable_cshadow_headers+set}" = set; then
3044   enableval="$enable_cshadow_headers"
3045
3046   case "$enableval" in
3047    yes) enable_cshadow_headers=yes
3048         ;;
3049    no)  enable_cshadow_headers=no
3050         ;;
3051    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3052         ;;
3053   esac
3054 else
3055   enable_cshadow_headers=no
3056 fi
3057
3058   echo "$ac_t""$enable_cshadow_headers" 1>&6
3059
3060       case "$enable_cshadow_headers" in
3061     yes)
3062         CSHADOW_FLAGS="-fno-builtin"
3063         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3064         cat >> confdefs.h <<\EOF
3065 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3066 EOF
3067
3068         ;;
3069     no)
3070         CSHADOW_FLAGS=""
3071         C_INCLUDE_DIR='${top_srcdir}/include/c'
3072         ;;
3073   esac
3074
3075
3076
3077
3078
3079 if test "$enable_cshadow_headers" = yes; then
3080   GLIBCPP_USE_CSHADOW_TRUE=
3081   GLIBCPP_USE_CSHADOW_FALSE='#'
3082 else
3083   GLIBCPP_USE_CSHADOW_TRUE='#'
3084   GLIBCPP_USE_CSHADOW_FALSE=
3085 fi
3086
3087
3088       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3089 echo "configure:3090: checking for threads package to use" >&5
3090   # Check whether --enable-threads or --disable-threads was given.
3091 if test "${enable_threads+set}" = set; then
3092   enableval="$enable_threads"
3093   if test x$enable_threads = xno; then
3094     enable_threads=''
3095   fi
3096 else
3097   enable_threads=''
3098 fi
3099
3100
3101   enable_threads_flag=$enable_threads
3102
3103     case x${enable_threads_flag} in
3104         x | xno | xnone)
3105                 # No threads
3106                 target_thread_file='single'
3107                 ;;
3108         xyes)
3109                 # default
3110                 target_thread_file='posix'
3111                 ;;
3112         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3113         xsolaris | xwin32 | xdce | xvxworks)
3114                 target_thread_file=$enable_threads_flag
3115                 ;;
3116         *)
3117                 echo "$enable_threads is an unknown thread package" 1>&2
3118                 exit 1
3119                 ;;
3120   esac
3121
3122     THREADH=
3123   case "$target_thread_file" in
3124     no | none | single)
3125       THREADH=threads-no.h
3126       ;;
3127     posix | pthreads)
3128       THREADH=threads-posix.h
3129       ;;
3130     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3131       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3132       ;;
3133     *)
3134       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3135       ;;
3136   esac
3137   echo "$ac_t""$THREADH" 1>&6
3138
3139
3140   if test $THREADH != threads-no.h; then
3141     cat >> confdefs.h <<\EOF
3142 #define _GLIBCPP_USE_THREADS 1
3143 EOF
3144
3145   fi
3146
3147
3148     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3149 echo "configure:3150: checking for atomicity.h" >&5
3150     # We have ATOMICITY already from GLIBCPP_CONFIGURE
3151     if test "$ATOMICITYH" = "config/cpu/generic"; then
3152       echo "configure: warning: No ATOMICITY settings found, using generic atomic ops." 1>&2
3153     fi
3154     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3155
3156
3157 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3158 if test "${enable_cxx_flags+set}" = set; then
3159   enableval="$enable_cxx_flags"
3160   case "x$enableval" in
3161  xyes)
3162         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3163  xno|x)
3164         enable_cxx_flags='' ;;
3165  *)
3166         enable_cxx_flags="$enableval" ;;
3167  esac
3168 else
3169   enable_cxx_flags='none'
3170 fi
3171
3172
3173 if test "$enable_cxx_flags" = "none"; then
3174   enable_cxx_flags='';
3175 fi
3176
3177 if test -n "$enable_cxx_flags"; then
3178     for f in $enable_cxx_flags; do
3179         case "$f" in
3180             -fhonor-std)  ;;
3181             -*)  ;;
3182             *)   # and we're trying to pass /what/ exactly?
3183                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3184         esac
3185     done
3186 fi
3187 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3188
3189
3190
3191
3192 if test -n "$with_cross_host"; then
3193
3194   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3195   # may not work correctly, because the compiler may not be able to
3196   # link executables.
3197
3198   xcompiling=1
3199   NATIVE=no
3200   # If Canadian cross, then don't pick up tools from the build
3201   # directory.
3202   if test "$build" != "$with_cross_host"; then
3203     CANADIAN=yes
3204     NULL_TARGET=yes
3205   else
3206     CANADIAN=no
3207     NULL_TARGET=no
3208   fi
3209
3210   case "$target_alias" in
3211     *-wince-*)
3212         # Configure for Microsoft Windows CE, or whatever they are
3213         # currently calling it.
3214         cat >> confdefs.h <<\EOF
3215 #define HAVE_FLOAT_H 1
3216 EOF
3217
3218
3219         cat >> confdefs.h <<\EOF
3220 #define HAVE__FINITE 1
3221 EOF
3222
3223         cat >> confdefs.h <<\EOF
3224 #define HAVE__ISNAN 1
3225 EOF
3226
3227         cat >> confdefs.h <<\EOF
3228 #define HAVE__COPYSIGN 1
3229 EOF
3230
3231         cat >> confdefs.h <<\EOF
3232 #define HAVE__FPCLASS 1
3233 EOF
3234
3235         cat >> confdefs.h <<\EOF
3236 #define HAVE_MODF 1
3237 EOF
3238
3239
3240         ctype_include_dir="config/os/wince"
3241
3242
3243
3244
3245
3246         cat >> confdefs.h <<\EOF
3247 #define _GLIBCPP_NEED_MBSTATE_T 1
3248 EOF
3249
3250
3251         cat >> confdefs.h <<\EOF
3252 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3253 EOF
3254
3255         cat >> confdefs.h <<\EOF
3256 #define _GLIBCPP_BUGGY_COMPLEX 1
3257 EOF
3258
3259         ;;
3260     *)
3261         # We assume newlib.  This lets us hard-code the functions we know
3262         # we'll have.
3263         cat >> confdefs.h <<\EOF
3264 #define HAVE_FINITE 1
3265 EOF
3266
3267         cat >> confdefs.h <<\EOF
3268 #define HAVE_ISNAN 1
3269 EOF
3270
3271         cat >> confdefs.h <<\EOF
3272 #define HAVE_ISNANF 1
3273 EOF
3274
3275         cat >> confdefs.h <<\EOF
3276 #define HAVE_ISINF 1
3277 EOF
3278
3279         cat >> confdefs.h <<\EOF
3280 #define HAVE_ISINFF 1
3281 EOF
3282
3283
3284         ctype_include_dir="config/os/newlib"
3285
3286
3287
3288
3289         cat >> confdefs.h <<\EOF
3290 #define _GLIBCPP_NEED_MBSTATE_T 1
3291 EOF
3292
3293
3294         cat >> confdefs.h <<\EOF
3295 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3296 EOF
3297
3298         cat >> confdefs.h <<\EOF
3299 #define _GLIBCPP_BUGGY_COMPLEX 1
3300 EOF
3301
3302         # need to check for faster f versions of math functions, ie sinf?
3303         ;;
3304   esac
3305 else
3306
3307   # We are being configured natively. We can do more elaborate tests
3308   # that include AC_TRY_COMPILE now, as the linker is assumed to be
3309   # working.
3310
3311   xcompiling=0
3312   NATIVE=yes
3313   CANADIAN=no
3314   NULL_TARGET=no
3315
3316   # Check for available headers.
3317   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
3318   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
3319 do
3320 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3321 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3322 echo "configure:3323: checking for $ac_hdr" >&5
3323 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3324   echo $ac_n "(cached) $ac_c" 1>&6
3325 else
3326   cat > conftest.$ac_ext <<EOF
3327 #line 3328 "configure"
3328 #include "confdefs.h"
3329 #include <$ac_hdr>
3330 EOF
3331 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3332 { (eval echo configure:3333: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3333 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3334 if test -z "$ac_err"; then
3335   rm -rf conftest*
3336   eval "ac_cv_header_$ac_safe=yes"
3337 else
3338   echo "$ac_err" >&5
3339   echo "configure: failed program was:" >&5
3340   cat conftest.$ac_ext >&5
3341   rm -rf conftest*
3342   eval "ac_cv_header_$ac_safe=no"
3343 fi
3344 rm -f conftest*
3345 fi
3346 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3347   echo "$ac_t""yes" 1>&6
3348     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3349   cat >> confdefs.h <<EOF
3350 #define $ac_tr_hdr 1
3351 EOF
3352
3353 else
3354   echo "$ac_t""no" 1>&6
3355 fi
3356 done
3357
3358
3359
3360   # All these tests are for C++; save the language and the compiler flags.
3361   # The CXXFLAGS thing is suspicious, but based on similar bits
3362   # found in GLIBCPP_CONFIGURE.
3363
3364   ac_ext=C
3365 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3366 ac_cpp='$CXXCPP $CPPFLAGS'
3367 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3368 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3369 cross_compiling=$ac_cv_prog_cxx_cross
3370
3371   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3372   ac_save_CXXFLAGS="$CXXFLAGS"
3373
3374   # Check for maintainer-mode bits.
3375   if test x"$USE_MAINTAINER_MODE" = xno; then
3376     WERROR=''
3377   else
3378     WERROR='-Werror'
3379   fi
3380
3381   # Check for more sophisticated diagnostic control.
3382   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
3383 echo "configure:3384: checking for g++ that supports -fdiagnostics-show-location=once" >&5
3384   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
3385   cat > conftest.$ac_ext <<EOF
3386 #line 3387 "configure"
3387 #include "confdefs.h"
3388
3389 int main() {
3390 int foo;
3391
3392 ; return 0; }
3393 EOF
3394 if { (eval echo configure:3395: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3395   rm -rf conftest*
3396   ac_gabydiags=yes
3397 else
3398   echo "configure: failed program was:" >&5
3399   cat conftest.$ac_ext >&5
3400   rm -rf conftest*
3401   ac_gabydiags=no
3402 fi
3403 rm -f conftest*
3404   if test "$ac_test_CXXFLAGS" = set; then
3405     CXXFLAGS="$ac_save_CXXFLAGS"
3406   else
3407     # this is the suspicious part
3408     CXXFLAGS=''
3409   fi
3410   if test "$ac_gabydiags" = "yes"; then
3411     WFMT_FLAGS='-fdiagnostics-show-location=once'
3412   fi
3413   echo "$ac_t""$ac_gabydiags" 1>&6
3414
3415   # Check for -ffunction-sections -fdata-sections
3416   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
3417 echo "configure:3418: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
3418   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
3419   cat > conftest.$ac_ext <<EOF
3420 #line 3421 "configure"
3421 #include "confdefs.h"
3422
3423 int main() {
3424 int foo;
3425
3426 ; return 0; }
3427 EOF
3428 if { (eval echo configure:3429: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3429   rm -rf conftest*
3430   ac_fdsections=yes
3431 else
3432   echo "configure: failed program was:" >&5
3433   cat conftest.$ac_ext >&5
3434   rm -rf conftest*
3435   ac_fdsections=no
3436 fi
3437 rm -f conftest*
3438   if test "$ac_test_CXXFLAGS" = set; then
3439     CXXFLAGS="$ac_save_CXXFLAGS"
3440   else
3441     # this is the suspicious part
3442     CXXFLAGS=''
3443   fi
3444   if test "$ac_fdsections" = "yes"; then
3445     SECTION_FLAGS='-ffunction-sections -fdata-sections'
3446   fi
3447   echo "$ac_t""$ac_fdsections" 1>&6
3448
3449   ac_ext=c
3450 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3451 ac_cpp='$CPP $CPPFLAGS'
3452 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3453 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3454 cross_compiling=$ac_cv_prog_cc_cross
3455
3456
3457
3458
3459
3460
3461   # If we're not using GNU ld, then there's no point in even trying these
3462   # tests.  Check for that first.  We should have already tested for gld
3463   # by now (in libtool), but require it now just to be safe...
3464   SECTION_LDFLAGS=''
3465   OPT_LDFLAGS=''
3466
3467
3468   # Set --gc-sections.
3469   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
3470     # GNU ld it is!  Joy and bunny rabbits!
3471
3472     # All these tests are for C++; save the language and the compiler flags.
3473     # Need to do this so that g++ won't try to link in libstdc++
3474     ac_test_CFLAGS="${CFLAGS+set}"
3475     ac_save_CFLAGS="$CFLAGS"
3476     CFLAGS='-x c++  -Wl,--gc-sections'
3477
3478     # Check for -Wl,--gc-sections
3479     # XXX This test is broken at the moment, as symbols required for
3480     # linking are now in libsupc++ (not built yet.....). In addition,
3481     # this test has cored on solaris in the past. In addition,
3482     # --gc-sections doesn't really work at the moment (keeps on discarding
3483     # used sections, first .eh_frame and now some of the glibc sections for
3484     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3485     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3486 echo "configure:3487: checking for ld that supports -Wl,--gc-sections" >&5
3487     if test "$cross_compiling" = yes; then
3488   ac_sectionLDflags=yes
3489 else
3490   cat > conftest.$ac_ext <<EOF
3491 #line 3492 "configure"
3492 #include "confdefs.h"
3493
3494      int main(void)
3495      {
3496        try { throw 1; }
3497        catch (...) { };
3498        return 0;
3499      }
3500
3501 EOF
3502 if { (eval echo configure:3503: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3503 then
3504   ac_sectionLDflags=yes
3505 else
3506   echo "configure: failed program was:" >&5
3507   cat conftest.$ac_ext >&5
3508   rm -fr conftest*
3509   ac_sectionLFflags=no
3510 fi
3511 rm -fr conftest*
3512 fi
3513
3514     if test "$ac_test_CFLAGS" = set; then
3515       CFLAGS="$ac_save_CFLAGS"
3516     else
3517       # this is the suspicious part
3518       CFLAGS=''
3519     fi
3520     if test "$ac_sectionLDflags" = "yes"; then
3521       SECTION_LDFLAGS='-Wl,--gc-sections'
3522     fi
3523     echo "$ac_t""$ac_sectionLDflags" 1>&6
3524   fi
3525
3526   # Set linker optimization flags.
3527   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3528     OPT_LDFLAGS='-Wl,-O1'
3529   fi
3530
3531
3532
3533
3534
3535
3536   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3537 echo "configure:3538: checking for __builtin_abs declaration" >&5
3538   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
3539   echo $ac_n "(cached) $ac_c" 1>&6
3540 else
3541
3542
3543     ac_ext=C
3544 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3545 ac_cpp='$CXXCPP $CPPFLAGS'
3546 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3547 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3548 cross_compiling=$ac_cv_prog_cxx_cross
3549
3550     cat > conftest.$ac_ext <<EOF
3551 #line 3552 "configure"
3552 #include "confdefs.h"
3553 #include <math.h>
3554 int main() {
3555  __builtin_abs(0);
3556 ; return 0; }
3557 EOF
3558 if { (eval echo configure:3559: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3559   rm -rf conftest*
3560   glibcpp_cv_func___builtin_abs_use=yes
3561 else
3562   echo "configure: failed program was:" >&5
3563   cat conftest.$ac_ext >&5
3564   rm -rf conftest*
3565   glibcpp_cv_func___builtin_abs_use=no
3566 fi
3567 rm -f conftest*
3568     ac_ext=c
3569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3570 ac_cpp='$CPP $CPPFLAGS'
3571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3573 cross_compiling=$ac_cv_prog_cc_cross
3574
3575
3576 fi
3577
3578   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
3579   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
3580     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3581 echo "configure:3582: checking for __builtin_abs linkage" >&5
3582     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
3583   echo $ac_n "(cached) $ac_c" 1>&6
3584 else
3585
3586       cat > conftest.$ac_ext <<EOF
3587 #line 3588 "configure"
3588 #include "confdefs.h"
3589 #include <math.h>
3590 int main() {
3591  __builtin_abs(0);
3592 ; return 0; }
3593 EOF
3594 if { (eval echo configure:3595: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3595   rm -rf conftest*
3596   glibcpp_cv_func___builtin_abs_link=yes
3597 else
3598   echo "configure: failed program was:" >&5
3599   cat conftest.$ac_ext >&5
3600   rm -rf conftest*
3601   glibcpp_cv_func___builtin_abs_link=no
3602 fi
3603 rm -f conftest*
3604
3605 fi
3606
3607     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
3608     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
3609       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3610       cat >> confdefs.h <<EOF
3611 #define ${ac_tr_func} 1
3612 EOF
3613
3614     fi
3615   fi
3616
3617
3618   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3619 echo "configure:3620: checking for __builtin_fabsf declaration" >&5
3620   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
3621   echo $ac_n "(cached) $ac_c" 1>&6
3622 else
3623
3624
3625     ac_ext=C
3626 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3627 ac_cpp='$CXXCPP $CPPFLAGS'
3628 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3629 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3630 cross_compiling=$ac_cv_prog_cxx_cross
3631
3632     cat > conftest.$ac_ext <<EOF
3633 #line 3634 "configure"
3634 #include "confdefs.h"
3635 #include <math.h>
3636 int main() {
3637  __builtin_fabsf(0);
3638 ; return 0; }
3639 EOF
3640 if { (eval echo configure:3641: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3641   rm -rf conftest*
3642   glibcpp_cv_func___builtin_fabsf_use=yes
3643 else
3644   echo "configure: failed program was:" >&5
3645   cat conftest.$ac_ext >&5
3646   rm -rf conftest*
3647   glibcpp_cv_func___builtin_fabsf_use=no
3648 fi
3649 rm -f conftest*
3650     ac_ext=c
3651 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3652 ac_cpp='$CPP $CPPFLAGS'
3653 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3654 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3655 cross_compiling=$ac_cv_prog_cc_cross
3656
3657
3658 fi
3659
3660   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
3661   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
3662     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3663 echo "configure:3664: checking for __builtin_fabsf linkage" >&5
3664     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
3665   echo $ac_n "(cached) $ac_c" 1>&6
3666 else
3667
3668       cat > conftest.$ac_ext <<EOF
3669 #line 3670 "configure"
3670 #include "confdefs.h"
3671 #include <math.h>
3672 int main() {
3673  __builtin_fabsf(0);
3674 ; return 0; }
3675 EOF
3676 if { (eval echo configure:3677: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3677   rm -rf conftest*
3678   glibcpp_cv_func___builtin_fabsf_link=yes
3679 else
3680   echo "configure: failed program was:" >&5
3681   cat conftest.$ac_ext >&5
3682   rm -rf conftest*
3683   glibcpp_cv_func___builtin_fabsf_link=no
3684 fi
3685 rm -f conftest*
3686
3687 fi
3688
3689     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
3690     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
3691       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3692       cat >> confdefs.h <<EOF
3693 #define ${ac_tr_func} 1
3694 EOF
3695
3696     fi
3697   fi
3698
3699
3700   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3701 echo "configure:3702: checking for __builtin_fabs declaration" >&5
3702   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
3703   echo $ac_n "(cached) $ac_c" 1>&6
3704 else
3705
3706
3707     ac_ext=C
3708 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3709 ac_cpp='$CXXCPP $CPPFLAGS'
3710 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3711 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3712 cross_compiling=$ac_cv_prog_cxx_cross
3713
3714     cat > conftest.$ac_ext <<EOF
3715 #line 3716 "configure"
3716 #include "confdefs.h"
3717 #include <math.h>
3718 int main() {
3719  __builtin_fabs(0);
3720 ; return 0; }
3721 EOF
3722 if { (eval echo configure:3723: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3723   rm -rf conftest*
3724   glibcpp_cv_func___builtin_fabs_use=yes
3725 else
3726   echo "configure: failed program was:" >&5
3727   cat conftest.$ac_ext >&5
3728   rm -rf conftest*
3729   glibcpp_cv_func___builtin_fabs_use=no
3730 fi
3731 rm -f conftest*
3732     ac_ext=c
3733 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3734 ac_cpp='$CPP $CPPFLAGS'
3735 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3736 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3737 cross_compiling=$ac_cv_prog_cc_cross
3738
3739
3740 fi
3741
3742   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
3743   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
3744     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3745 echo "configure:3746: checking for __builtin_fabs linkage" >&5
3746     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
3747   echo $ac_n "(cached) $ac_c" 1>&6
3748 else
3749
3750       cat > conftest.$ac_ext <<EOF
3751 #line 3752 "configure"
3752 #include "confdefs.h"
3753 #include <math.h>
3754 int main() {
3755  __builtin_fabs(0);
3756 ; return 0; }
3757 EOF
3758 if { (eval echo configure:3759: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3759   rm -rf conftest*
3760   glibcpp_cv_func___builtin_fabs_link=yes
3761 else
3762   echo "configure: failed program was:" >&5
3763   cat conftest.$ac_ext >&5
3764   rm -rf conftest*
3765   glibcpp_cv_func___builtin_fabs_link=no
3766 fi
3767 rm -f conftest*
3768
3769 fi
3770
3771     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
3772     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
3773       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3774       cat >> confdefs.h <<EOF
3775 #define ${ac_tr_func} 1
3776 EOF
3777
3778     fi
3779   fi
3780
3781
3782   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3783 echo "configure:3784: checking for __builtin_fabsl declaration" >&5
3784   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
3785   echo $ac_n "(cached) $ac_c" 1>&6
3786 else
3787
3788
3789     ac_ext=C
3790 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3791 ac_cpp='$CXXCPP $CPPFLAGS'
3792 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3793 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3794 cross_compiling=$ac_cv_prog_cxx_cross
3795
3796     cat > conftest.$ac_ext <<EOF
3797 #line 3798 "configure"
3798 #include "confdefs.h"
3799 #include <math.h>
3800 int main() {
3801  __builtin_fabsl(0);
3802 ; return 0; }
3803 EOF
3804 if { (eval echo configure:3805: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3805   rm -rf conftest*
3806   glibcpp_cv_func___builtin_fabsl_use=yes
3807 else
3808   echo "configure: failed program was:" >&5
3809   cat conftest.$ac_ext >&5
3810   rm -rf conftest*
3811   glibcpp_cv_func___builtin_fabsl_use=no
3812 fi
3813 rm -f conftest*
3814     ac_ext=c
3815 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3816 ac_cpp='$CPP $CPPFLAGS'
3817 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3818 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3819 cross_compiling=$ac_cv_prog_cc_cross
3820
3821
3822 fi
3823
3824   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
3825   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
3826     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3827 echo "configure:3828: checking for __builtin_fabsl linkage" >&5
3828     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
3829   echo $ac_n "(cached) $ac_c" 1>&6
3830 else
3831
3832       cat > conftest.$ac_ext <<EOF
3833 #line 3834 "configure"
3834 #include "confdefs.h"
3835 #include <math.h>
3836 int main() {
3837  __builtin_fabsl(0);
3838 ; return 0; }
3839 EOF
3840 if { (eval echo configure:3841: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3841   rm -rf conftest*
3842   glibcpp_cv_func___builtin_fabsl_link=yes
3843 else
3844   echo "configure: failed program was:" >&5
3845   cat conftest.$ac_ext >&5
3846   rm -rf conftest*
3847   glibcpp_cv_func___builtin_fabsl_link=no
3848 fi
3849 rm -f conftest*
3850
3851 fi
3852
3853     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
3854     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
3855       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3856       cat >> confdefs.h <<EOF
3857 #define ${ac_tr_func} 1
3858 EOF
3859
3860     fi
3861   fi
3862
3863
3864   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3865 echo "configure:3866: checking for __builtin_labs declaration" >&5
3866   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
3867   echo $ac_n "(cached) $ac_c" 1>&6
3868 else
3869
3870
3871     ac_ext=C
3872 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3873 ac_cpp='$CXXCPP $CPPFLAGS'
3874 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3875 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3876 cross_compiling=$ac_cv_prog_cxx_cross
3877
3878     cat > conftest.$ac_ext <<EOF
3879 #line 3880 "configure"
3880 #include "confdefs.h"
3881 #include <math.h>
3882 int main() {
3883  __builtin_labs(0);
3884 ; return 0; }
3885 EOF
3886 if { (eval echo configure:3887: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3887   rm -rf conftest*
3888   glibcpp_cv_func___builtin_labs_use=yes
3889 else
3890   echo "configure: failed program was:" >&5
3891   cat conftest.$ac_ext >&5
3892   rm -rf conftest*
3893   glibcpp_cv_func___builtin_labs_use=no
3894 fi
3895 rm -f conftest*
3896     ac_ext=c
3897 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3898 ac_cpp='$CPP $CPPFLAGS'
3899 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3900 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3901 cross_compiling=$ac_cv_prog_cc_cross
3902
3903
3904 fi
3905
3906   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
3907   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
3908     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3909 echo "configure:3910: checking for __builtin_labs linkage" >&5
3910     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
3911   echo $ac_n "(cached) $ac_c" 1>&6
3912 else
3913
3914       cat > conftest.$ac_ext <<EOF
3915 #line 3916 "configure"
3916 #include "confdefs.h"
3917 #include <math.h>
3918 int main() {
3919  __builtin_labs(0);
3920 ; return 0; }
3921 EOF
3922 if { (eval echo configure:3923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3923   rm -rf conftest*
3924   glibcpp_cv_func___builtin_labs_link=yes
3925 else
3926   echo "configure: failed program was:" >&5
3927   cat conftest.$ac_ext >&5
3928   rm -rf conftest*
3929   glibcpp_cv_func___builtin_labs_link=no
3930 fi
3931 rm -f conftest*
3932
3933 fi
3934
3935     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
3936     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
3937       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3938       cat >> confdefs.h <<EOF
3939 #define ${ac_tr_func} 1
3940 EOF
3941
3942     fi
3943   fi
3944
3945
3946
3947   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3948 echo "configure:3949: checking for __builtin_sqrtf declaration" >&5
3949   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
3950   echo $ac_n "(cached) $ac_c" 1>&6
3951 else
3952
3953
3954     ac_ext=C
3955 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3956 ac_cpp='$CXXCPP $CPPFLAGS'
3957 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3958 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3959 cross_compiling=$ac_cv_prog_cxx_cross
3960
3961     cat > conftest.$ac_ext <<EOF
3962 #line 3963 "configure"
3963 #include "confdefs.h"
3964 #include <math.h>
3965 int main() {
3966  __builtin_sqrtf(0);
3967 ; return 0; }
3968 EOF
3969 if { (eval echo configure:3970: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3970   rm -rf conftest*
3971   glibcpp_cv_func___builtin_sqrtf_use=yes
3972 else
3973   echo "configure: failed program was:" >&5
3974   cat conftest.$ac_ext >&5
3975   rm -rf conftest*
3976   glibcpp_cv_func___builtin_sqrtf_use=no
3977 fi
3978 rm -f conftest*
3979     ac_ext=c
3980 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3981 ac_cpp='$CPP $CPPFLAGS'
3982 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3983 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3984 cross_compiling=$ac_cv_prog_cc_cross
3985
3986
3987 fi
3988
3989   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
3990   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
3991     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3992 echo "configure:3993: checking for __builtin_sqrtf linkage" >&5
3993     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
3994   echo $ac_n "(cached) $ac_c" 1>&6
3995 else
3996
3997       cat > conftest.$ac_ext <<EOF
3998 #line 3999 "configure"
3999 #include "confdefs.h"
4000 #include <math.h>
4001 int main() {
4002  __builtin_sqrtf(0);
4003 ; return 0; }
4004 EOF
4005 if { (eval echo configure:4006: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4006   rm -rf conftest*
4007   glibcpp_cv_func___builtin_sqrtf_link=yes
4008 else
4009   echo "configure: failed program was:" >&5
4010   cat conftest.$ac_ext >&5
4011   rm -rf conftest*
4012   glibcpp_cv_func___builtin_sqrtf_link=no
4013 fi
4014 rm -f conftest*
4015
4016 fi
4017
4018     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
4019     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
4020       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4021       cat >> confdefs.h <<EOF
4022 #define ${ac_tr_func} 1
4023 EOF
4024
4025     fi
4026   fi
4027
4028
4029   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
4030 echo "configure:4031: checking for __builtin_fsqrt declaration" >&5
4031   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
4032   echo $ac_n "(cached) $ac_c" 1>&6
4033 else
4034
4035
4036     ac_ext=C
4037 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4038 ac_cpp='$CXXCPP $CPPFLAGS'
4039 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4040 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4041 cross_compiling=$ac_cv_prog_cxx_cross
4042
4043     cat > conftest.$ac_ext <<EOF
4044 #line 4045 "configure"
4045 #include "confdefs.h"
4046 #include <math.h>
4047 int main() {
4048  __builtin_fsqrt(0);
4049 ; return 0; }
4050 EOF
4051 if { (eval echo configure:4052: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4052   rm -rf conftest*
4053   glibcpp_cv_func___builtin_fsqrt_use=yes
4054 else
4055   echo "configure: failed program was:" >&5
4056   cat conftest.$ac_ext >&5
4057   rm -rf conftest*
4058   glibcpp_cv_func___builtin_fsqrt_use=no
4059 fi
4060 rm -f conftest*
4061     ac_ext=c
4062 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4063 ac_cpp='$CPP $CPPFLAGS'
4064 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4065 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4066 cross_compiling=$ac_cv_prog_cc_cross
4067
4068
4069 fi
4070
4071   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
4072   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
4073     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
4074 echo "configure:4075: checking for __builtin_fsqrt linkage" >&5
4075     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
4076   echo $ac_n "(cached) $ac_c" 1>&6
4077 else
4078
4079       cat > conftest.$ac_ext <<EOF
4080 #line 4081 "configure"
4081 #include "confdefs.h"
4082 #include <math.h>
4083 int main() {
4084  __builtin_fsqrt(0);
4085 ; return 0; }
4086 EOF
4087 if { (eval echo configure:4088: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4088   rm -rf conftest*
4089   glibcpp_cv_func___builtin_fsqrt_link=yes
4090 else
4091   echo "configure: failed program was:" >&5
4092   cat conftest.$ac_ext >&5
4093   rm -rf conftest*
4094   glibcpp_cv_func___builtin_fsqrt_link=no
4095 fi
4096 rm -f conftest*
4097
4098 fi
4099
4100     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
4101     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
4102       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4103       cat >> confdefs.h <<EOF
4104 #define ${ac_tr_func} 1
4105 EOF
4106
4107     fi
4108   fi
4109
4110
4111   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
4112 echo "configure:4113: checking for __builtin_sqrtl declaration" >&5
4113   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
4114   echo $ac_n "(cached) $ac_c" 1>&6
4115 else
4116
4117
4118     ac_ext=C
4119 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4120 ac_cpp='$CXXCPP $CPPFLAGS'
4121 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4122 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4123 cross_compiling=$ac_cv_prog_cxx_cross
4124
4125     cat > conftest.$ac_ext <<EOF
4126 #line 4127 "configure"
4127 #include "confdefs.h"
4128 #include <math.h>
4129 int main() {
4130  __builtin_sqrtl(0);
4131 ; return 0; }
4132 EOF
4133 if { (eval echo configure:4134: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4134   rm -rf conftest*
4135   glibcpp_cv_func___builtin_sqrtl_use=yes
4136 else
4137   echo "configure: failed program was:" >&5
4138   cat conftest.$ac_ext >&5
4139   rm -rf conftest*
4140   glibcpp_cv_func___builtin_sqrtl_use=no
4141 fi
4142 rm -f conftest*
4143     ac_ext=c
4144 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4145 ac_cpp='$CPP $CPPFLAGS'
4146 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4147 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4148 cross_compiling=$ac_cv_prog_cc_cross
4149
4150
4151 fi
4152
4153   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
4154   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
4155     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
4156 echo "configure:4157: checking for __builtin_sqrtl linkage" >&5
4157     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
4158   echo $ac_n "(cached) $ac_c" 1>&6
4159 else
4160
4161       cat > conftest.$ac_ext <<EOF
4162 #line 4163 "configure"
4163 #include "confdefs.h"
4164 #include <math.h>
4165 int main() {
4166  __builtin_sqrtl(0);
4167 ; return 0; }
4168 EOF
4169 if { (eval echo configure:4170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4170   rm -rf conftest*
4171   glibcpp_cv_func___builtin_sqrtl_link=yes
4172 else
4173   echo "configure: failed program was:" >&5
4174   cat conftest.$ac_ext >&5
4175   rm -rf conftest*
4176   glibcpp_cv_func___builtin_sqrtl_link=no
4177 fi
4178 rm -f conftest*
4179
4180 fi
4181
4182     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
4183     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
4184       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4185       cat >> confdefs.h <<EOF
4186 #define ${ac_tr_func} 1
4187 EOF
4188
4189     fi
4190   fi
4191
4192
4193
4194   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
4195 echo "configure:4196: checking for __builtin_sinf declaration" >&5
4196   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
4197   echo $ac_n "(cached) $ac_c" 1>&6
4198 else
4199
4200
4201     ac_ext=C
4202 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4203 ac_cpp='$CXXCPP $CPPFLAGS'
4204 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4205 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4206 cross_compiling=$ac_cv_prog_cxx_cross
4207
4208     cat > conftest.$ac_ext <<EOF
4209 #line 4210 "configure"
4210 #include "confdefs.h"
4211 #include <math.h>
4212 int main() {
4213  __builtin_sinf(0);
4214 ; return 0; }
4215 EOF
4216 if { (eval echo configure:4217: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4217   rm -rf conftest*
4218   glibcpp_cv_func___builtin_sinf_use=yes
4219 else
4220   echo "configure: failed program was:" >&5
4221   cat conftest.$ac_ext >&5
4222   rm -rf conftest*
4223   glibcpp_cv_func___builtin_sinf_use=no
4224 fi
4225 rm -f conftest*
4226     ac_ext=c
4227 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4228 ac_cpp='$CPP $CPPFLAGS'
4229 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4230 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4231 cross_compiling=$ac_cv_prog_cc_cross
4232
4233
4234 fi
4235
4236   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
4237   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
4238     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
4239 echo "configure:4240: checking for __builtin_sinf linkage" >&5
4240     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
4241   echo $ac_n "(cached) $ac_c" 1>&6
4242 else
4243
4244       cat > conftest.$ac_ext <<EOF
4245 #line 4246 "configure"
4246 #include "confdefs.h"
4247 #include <math.h>
4248 int main() {
4249  __builtin_sinf(0);
4250 ; return 0; }
4251 EOF
4252 if { (eval echo configure:4253: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4253   rm -rf conftest*
4254   glibcpp_cv_func___builtin_sinf_link=yes
4255 else
4256   echo "configure: failed program was:" >&5
4257   cat conftest.$ac_ext >&5
4258   rm -rf conftest*
4259   glibcpp_cv_func___builtin_sinf_link=no
4260 fi
4261 rm -f conftest*
4262
4263 fi
4264
4265     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
4266     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
4267       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4268       cat >> confdefs.h <<EOF
4269 #define ${ac_tr_func} 1
4270 EOF
4271
4272     fi
4273   fi
4274
4275
4276   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
4277 echo "configure:4278: checking for __builtin_sin declaration" >&5
4278   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
4279   echo $ac_n "(cached) $ac_c" 1>&6
4280 else
4281
4282
4283     ac_ext=C
4284 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4285 ac_cpp='$CXXCPP $CPPFLAGS'
4286 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4287 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4288 cross_compiling=$ac_cv_prog_cxx_cross
4289
4290     cat > conftest.$ac_ext <<EOF
4291 #line 4292 "configure"
4292 #include "confdefs.h"
4293 #include <math.h>
4294 int main() {
4295  __builtin_sin(0);
4296 ; return 0; }
4297 EOF
4298 if { (eval echo configure:4299: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4299   rm -rf conftest*
4300   glibcpp_cv_func___builtin_sin_use=yes
4301 else
4302   echo "configure: failed program was:" >&5
4303   cat conftest.$ac_ext >&5
4304   rm -rf conftest*
4305   glibcpp_cv_func___builtin_sin_use=no
4306 fi
4307 rm -f conftest*
4308     ac_ext=c
4309 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4310 ac_cpp='$CPP $CPPFLAGS'
4311 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4312 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4313 cross_compiling=$ac_cv_prog_cc_cross
4314
4315
4316 fi
4317
4318   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
4319   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
4320     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
4321 echo "configure:4322: checking for __builtin_sin linkage" >&5
4322     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
4323   echo $ac_n "(cached) $ac_c" 1>&6
4324 else
4325
4326       cat > conftest.$ac_ext <<EOF
4327 #line 4328 "configure"
4328 #include "confdefs.h"
4329 #include <math.h>
4330 int main() {
4331  __builtin_sin(0);
4332 ; return 0; }
4333 EOF
4334 if { (eval echo configure:4335: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4335   rm -rf conftest*
4336   glibcpp_cv_func___builtin_sin_link=yes
4337 else
4338   echo "configure: failed program was:" >&5
4339   cat conftest.$ac_ext >&5
4340   rm -rf conftest*
4341   glibcpp_cv_func___builtin_sin_link=no
4342 fi
4343 rm -f conftest*
4344
4345 fi
4346
4347     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
4348     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
4349       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4350       cat >> confdefs.h <<EOF
4351 #define ${ac_tr_func} 1
4352 EOF
4353
4354     fi
4355   fi
4356
4357
4358   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
4359 echo "configure:4360: checking for __builtin_sinl declaration" >&5
4360   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
4361   echo $ac_n "(cached) $ac_c" 1>&6
4362 else
4363
4364
4365     ac_ext=C
4366 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4367 ac_cpp='$CXXCPP $CPPFLAGS'
4368 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4369 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4370 cross_compiling=$ac_cv_prog_cxx_cross
4371
4372     cat > conftest.$ac_ext <<EOF
4373 #line 4374 "configure"
4374 #include "confdefs.h"
4375 #include <math.h>
4376 int main() {
4377  __builtin_sinl(0);
4378 ; return 0; }
4379 EOF
4380 if { (eval echo configure:4381: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4381   rm -rf conftest*
4382   glibcpp_cv_func___builtin_sinl_use=yes
4383 else
4384   echo "configure: failed program was:" >&5
4385   cat conftest.$ac_ext >&5
4386   rm -rf conftest*
4387   glibcpp_cv_func___builtin_sinl_use=no
4388 fi
4389 rm -f conftest*
4390     ac_ext=c
4391 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4392 ac_cpp='$CPP $CPPFLAGS'
4393 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4394 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4395 cross_compiling=$ac_cv_prog_cc_cross
4396
4397
4398 fi
4399
4400   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
4401   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
4402     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
4403 echo "configure:4404: checking for __builtin_sinl linkage" >&5
4404     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
4405   echo $ac_n "(cached) $ac_c" 1>&6
4406 else
4407
4408       cat > conftest.$ac_ext <<EOF
4409 #line 4410 "configure"
4410 #include "confdefs.h"
4411 #include <math.h>
4412 int main() {
4413  __builtin_sinl(0);
4414 ; return 0; }
4415 EOF
4416 if { (eval echo configure:4417: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4417   rm -rf conftest*
4418   glibcpp_cv_func___builtin_sinl_link=yes
4419 else
4420   echo "configure: failed program was:" >&5
4421   cat conftest.$ac_ext >&5
4422   rm -rf conftest*
4423   glibcpp_cv_func___builtin_sinl_link=no
4424 fi
4425 rm -f conftest*
4426
4427 fi
4428
4429     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
4430     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
4431       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4432       cat >> confdefs.h <<EOF
4433 #define ${ac_tr_func} 1
4434 EOF
4435
4436     fi
4437   fi
4438
4439
4440
4441   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
4442 echo "configure:4443: checking for __builtin_cosf declaration" >&5
4443   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
4444   echo $ac_n "(cached) $ac_c" 1>&6
4445 else
4446
4447
4448     ac_ext=C
4449 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4450 ac_cpp='$CXXCPP $CPPFLAGS'
4451 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4452 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4453 cross_compiling=$ac_cv_prog_cxx_cross
4454
4455     cat > conftest.$ac_ext <<EOF
4456 #line 4457 "configure"
4457 #include "confdefs.h"
4458 #include <math.h>
4459 int main() {
4460  __builtin_cosf(0);
4461 ; return 0; }
4462 EOF
4463 if { (eval echo configure:4464: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4464   rm -rf conftest*
4465   glibcpp_cv_func___builtin_cosf_use=yes
4466 else
4467   echo "configure: failed program was:" >&5
4468   cat conftest.$ac_ext >&5
4469   rm -rf conftest*
4470   glibcpp_cv_func___builtin_cosf_use=no
4471 fi
4472 rm -f conftest*
4473     ac_ext=c
4474 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4475 ac_cpp='$CPP $CPPFLAGS'
4476 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4477 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4478 cross_compiling=$ac_cv_prog_cc_cross
4479
4480
4481 fi
4482
4483   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
4484   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
4485     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
4486 echo "configure:4487: checking for __builtin_cosf linkage" >&5
4487     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
4488   echo $ac_n "(cached) $ac_c" 1>&6
4489 else
4490
4491       cat > conftest.$ac_ext <<EOF
4492 #line 4493 "configure"
4493 #include "confdefs.h"
4494 #include <math.h>
4495 int main() {
4496  __builtin_cosf(0);
4497 ; return 0; }
4498 EOF
4499 if { (eval echo configure:4500: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4500   rm -rf conftest*
4501   glibcpp_cv_func___builtin_cosf_link=yes
4502 else
4503   echo "configure: failed program was:" >&5
4504   cat conftest.$ac_ext >&5
4505   rm -rf conftest*
4506   glibcpp_cv_func___builtin_cosf_link=no
4507 fi
4508 rm -f conftest*
4509
4510 fi
4511
4512     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
4513     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
4514       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4515       cat >> confdefs.h <<EOF
4516 #define ${ac_tr_func} 1
4517 EOF
4518
4519     fi
4520   fi
4521
4522
4523   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
4524 echo "configure:4525: checking for __builtin_cos declaration" >&5
4525   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
4526   echo $ac_n "(cached) $ac_c" 1>&6
4527 else
4528
4529
4530     ac_ext=C
4531 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4532 ac_cpp='$CXXCPP $CPPFLAGS'
4533 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4534 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4535 cross_compiling=$ac_cv_prog_cxx_cross
4536
4537     cat > conftest.$ac_ext <<EOF
4538 #line 4539 "configure"
4539 #include "confdefs.h"
4540 #include <math.h>
4541 int main() {
4542  __builtin_cos(0);
4543 ; return 0; }
4544 EOF
4545 if { (eval echo configure:4546: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4546   rm -rf conftest*
4547   glibcpp_cv_func___builtin_cos_use=yes
4548 else
4549   echo "configure: failed program was:" >&5
4550   cat conftest.$ac_ext >&5
4551   rm -rf conftest*
4552   glibcpp_cv_func___builtin_cos_use=no
4553 fi
4554 rm -f conftest*
4555     ac_ext=c
4556 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4557 ac_cpp='$CPP $CPPFLAGS'
4558 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4559 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4560 cross_compiling=$ac_cv_prog_cc_cross
4561
4562
4563 fi
4564
4565   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
4566   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
4567     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
4568 echo "configure:4569: checking for __builtin_cos linkage" >&5
4569     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
4570   echo $ac_n "(cached) $ac_c" 1>&6
4571 else
4572
4573       cat > conftest.$ac_ext <<EOF
4574 #line 4575 "configure"
4575 #include "confdefs.h"
4576 #include <math.h>
4577 int main() {
4578  __builtin_cos(0);
4579 ; return 0; }
4580 EOF
4581 if { (eval echo configure:4582: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4582   rm -rf conftest*
4583   glibcpp_cv_func___builtin_cos_link=yes
4584 else
4585   echo "configure: failed program was:" >&5
4586   cat conftest.$ac_ext >&5
4587   rm -rf conftest*
4588   glibcpp_cv_func___builtin_cos_link=no
4589 fi
4590 rm -f conftest*
4591
4592 fi
4593
4594     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
4595     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
4596       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4597       cat >> confdefs.h <<EOF
4598 #define ${ac_tr_func} 1
4599 EOF
4600
4601     fi
4602   fi
4603
4604
4605   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
4606 echo "configure:4607: checking for __builtin_cosl declaration" >&5
4607   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
4608   echo $ac_n "(cached) $ac_c" 1>&6
4609 else
4610
4611
4612     ac_ext=C
4613 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4614 ac_cpp='$CXXCPP $CPPFLAGS'
4615 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4616 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4617 cross_compiling=$ac_cv_prog_cxx_cross
4618
4619     cat > conftest.$ac_ext <<EOF
4620 #line 4621 "configure"
4621 #include "confdefs.h"
4622 #include <math.h>
4623 int main() {
4624  __builtin_cosl(0);
4625 ; return 0; }
4626 EOF
4627 if { (eval echo configure:4628: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4628   rm -rf conftest*
4629   glibcpp_cv_func___builtin_cosl_use=yes
4630 else
4631   echo "configure: failed program was:" >&5
4632   cat conftest.$ac_ext >&5
4633   rm -rf conftest*
4634   glibcpp_cv_func___builtin_cosl_use=no
4635 fi
4636 rm -f conftest*
4637     ac_ext=c
4638 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4639 ac_cpp='$CPP $CPPFLAGS'
4640 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4641 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4642 cross_compiling=$ac_cv_prog_cc_cross
4643
4644
4645 fi
4646
4647   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
4648   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
4649     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
4650 echo "configure:4651: checking for __builtin_cosl linkage" >&5
4651     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
4652   echo $ac_n "(cached) $ac_c" 1>&6
4653 else
4654
4655       cat > conftest.$ac_ext <<EOF
4656 #line 4657 "configure"
4657 #include "confdefs.h"
4658 #include <math.h>
4659 int main() {
4660  __builtin_cosl(0);
4661 ; return 0; }
4662 EOF
4663 if { (eval echo configure:4664: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4664   rm -rf conftest*
4665   glibcpp_cv_func___builtin_cosl_link=yes
4666 else
4667   echo "configure: failed program was:" >&5
4668   cat conftest.$ac_ext >&5
4669   rm -rf conftest*
4670   glibcpp_cv_func___builtin_cosl_link=no
4671 fi
4672 rm -f conftest*
4673
4674 fi
4675
4676     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
4677     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
4678       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4679       cat >> confdefs.h <<EOF
4680 #define ${ac_tr_func} 1
4681 EOF
4682
4683     fi
4684   fi
4685
4686
4687               dummyvar=no
4688   if test x$dummyvar = x"yes"; then
4689     cat >> confdefs.h <<\EOF
4690 #define HAVE___BUILTIN_ABS 1
4691 EOF
4692
4693     cat >> confdefs.h <<\EOF
4694 #define HAVE___BUILTIN_LABS 1
4695 EOF
4696
4697     cat >> confdefs.h <<\EOF
4698 #define HAVE___BUILTIN_COS 1
4699 EOF
4700
4701     cat >> confdefs.h <<\EOF
4702 #define HAVE___BUILTIN_COSF 1
4703 EOF
4704
4705     cat >> confdefs.h <<\EOF
4706 #define HAVE___BUILTIN_COSL 1
4707 EOF
4708
4709     cat >> confdefs.h <<\EOF
4710 #define HAVE___BUILTIN_FABS 1
4711 EOF
4712
4713     cat >> confdefs.h <<\EOF
4714 #define HAVE___BUILTIN_FABSF 1
4715 EOF
4716
4717     cat >> confdefs.h <<\EOF
4718 #define HAVE___BUILTIN_FABSL 1
4719 EOF
4720
4721     cat >> confdefs.h <<\EOF
4722 #define HAVE___BUILTIN_SIN 1
4723 EOF
4724
4725     cat >> confdefs.h <<\EOF
4726 #define HAVE___BUILTIN_SINF 1
4727 EOF
4728
4729     cat >> confdefs.h <<\EOF
4730 #define HAVE___BUILTIN_SINL 1
4731 EOF
4732
4733     cat >> confdefs.h <<\EOF
4734 #define HAVE___BUILTIN_FSQRT 1
4735 EOF
4736
4737     cat >> confdefs.h <<\EOF
4738 #define HAVE___BUILTIN_SQRTF 1
4739 EOF
4740
4741     cat >> confdefs.h <<\EOF
4742 #define HAVE___BUILTIN_SQRTL 1
4743 EOF
4744
4745   fi
4746
4747
4748   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4749   ac_save_CXXFLAGS="$CXXFLAGS"
4750   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4751
4752     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4753 echo "configure:4754: checking for sin in -lm" >&5
4754 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4755 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4756   echo $ac_n "(cached) $ac_c" 1>&6
4757 else
4758   ac_save_LIBS="$LIBS"
4759 LIBS="-lm  $LIBS"
4760 cat > conftest.$ac_ext <<EOF
4761 #line 4762 "configure"
4762 #include "confdefs.h"
4763 /* Override any gcc2 internal prototype to avoid an error.  */
4764 /* We use char because int might match the return type of a gcc2
4765     builtin and then its argument prototype would still apply.  */
4766 char sin();
4767
4768 int main() {
4769 sin()
4770 ; return 0; }
4771 EOF
4772 if { (eval echo configure:4773: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4773   rm -rf conftest*
4774   eval "ac_cv_lib_$ac_lib_var=yes"
4775 else
4776   echo "configure: failed program was:" >&5
4777   cat conftest.$ac_ext >&5
4778   rm -rf conftest*
4779   eval "ac_cv_lib_$ac_lib_var=no"
4780 fi
4781 rm -f conftest*
4782 LIBS="$ac_save_LIBS"
4783
4784 fi
4785 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4786   echo "$ac_t""yes" 1>&6
4787   libm="-lm"
4788 else
4789   echo "$ac_t""no" 1>&6
4790 fi
4791
4792   ac_save_LIBS="$LIBS"
4793   LIBS="$LIBS $libm"
4794
4795
4796   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4797 echo "configure:4798: checking for isinf declaration" >&5
4798   if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
4799   echo $ac_n "(cached) $ac_c" 1>&6
4800 else
4801
4802
4803     ac_ext=C
4804 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4805 ac_cpp='$CXXCPP $CPPFLAGS'
4806 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4807 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4808 cross_compiling=$ac_cv_prog_cxx_cross
4809
4810     cat > conftest.$ac_ext <<EOF
4811 #line 4812 "configure"
4812 #include "confdefs.h"
4813 #include <math.h>
4814 int main() {
4815  isinf(0);
4816 ; return 0; }
4817 EOF
4818 if { (eval echo configure:4819: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4819   rm -rf conftest*
4820   glibcpp_cv_func_isinf_use=yes
4821 else
4822   echo "configure: failed program was:" >&5
4823   cat conftest.$ac_ext >&5
4824   rm -rf conftest*
4825   glibcpp_cv_func_isinf_use=no
4826 fi
4827 rm -f conftest*
4828     ac_ext=c
4829 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4830 ac_cpp='$CPP $CPPFLAGS'
4831 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4832 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4833 cross_compiling=$ac_cv_prog_cc_cross
4834
4835
4836 fi
4837
4838   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
4839   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
4840     for ac_func in isinf
4841 do
4842 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4843 echo "configure:4844: checking for $ac_func" >&5
4844 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4845   echo $ac_n "(cached) $ac_c" 1>&6
4846 else
4847   cat > conftest.$ac_ext <<EOF
4848 #line 4849 "configure"
4849 #include "confdefs.h"
4850 /* System header to define __stub macros and hopefully few prototypes,
4851     which can conflict with char $ac_func(); below.  */
4852 #include <assert.h>
4853 /* Override any gcc2 internal prototype to avoid an error.  */
4854 /* We use char because int might match the return type of a gcc2
4855     builtin and then its argument prototype would still apply.  */
4856 char $ac_func();
4857
4858 int main() {
4859
4860 /* The GNU C library defines this for functions which it implements
4861     to always fail with ENOSYS.  Some functions are actually named
4862     something starting with __ and the normal name is an alias.  */
4863 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4864 choke me
4865 #else
4866 $ac_func();
4867 #endif
4868
4869 ; return 0; }
4870 EOF
4871 if { (eval echo configure:4872: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4872   rm -rf conftest*
4873   eval "ac_cv_func_$ac_func=yes"
4874 else
4875   echo "configure: failed program was:" >&5
4876   cat conftest.$ac_ext >&5
4877   rm -rf conftest*
4878   eval "ac_cv_func_$ac_func=no"
4879 fi
4880 rm -f conftest*
4881 fi
4882
4883 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4884   echo "$ac_t""yes" 1>&6
4885     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4886   cat >> confdefs.h <<EOF
4887 #define $ac_tr_func 1
4888 EOF
4889
4890 else
4891   echo "$ac_t""no" 1>&6
4892 fi
4893 done
4894
4895   fi
4896
4897
4898   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4899 echo "configure:4900: checking for isnan declaration" >&5
4900   if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
4901   echo $ac_n "(cached) $ac_c" 1>&6
4902 else
4903
4904
4905     ac_ext=C
4906 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4907 ac_cpp='$CXXCPP $CPPFLAGS'
4908 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4909 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4910 cross_compiling=$ac_cv_prog_cxx_cross
4911
4912     cat > conftest.$ac_ext <<EOF
4913 #line 4914 "configure"
4914 #include "confdefs.h"
4915 #include <math.h>
4916 int main() {
4917  isnan(0);
4918 ; return 0; }
4919 EOF
4920 if { (eval echo configure:4921: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4921   rm -rf conftest*
4922   glibcpp_cv_func_isnan_use=yes
4923 else
4924   echo "configure: failed program was:" >&5
4925   cat conftest.$ac_ext >&5
4926   rm -rf conftest*
4927   glibcpp_cv_func_isnan_use=no
4928 fi
4929 rm -f conftest*
4930     ac_ext=c
4931 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4932 ac_cpp='$CPP $CPPFLAGS'
4933 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4934 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4935 cross_compiling=$ac_cv_prog_cc_cross
4936
4937
4938 fi
4939
4940   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
4941   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
4942     for ac_func in isnan
4943 do
4944 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4945 echo "configure:4946: checking for $ac_func" >&5
4946 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4947   echo $ac_n "(cached) $ac_c" 1>&6
4948 else
4949   cat > conftest.$ac_ext <<EOF
4950 #line 4951 "configure"
4951 #include "confdefs.h"
4952 /* System header to define __stub macros and hopefully few prototypes,
4953     which can conflict with char $ac_func(); below.  */
4954 #include <assert.h>
4955 /* Override any gcc2 internal prototype to avoid an error.  */
4956 /* We use char because int might match the return type of a gcc2
4957     builtin and then its argument prototype would still apply.  */
4958 char $ac_func();
4959
4960 int main() {
4961
4962 /* The GNU C library defines this for functions which it implements
4963     to always fail with ENOSYS.  Some functions are actually named
4964     something starting with __ and the normal name is an alias.  */
4965 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4966 choke me
4967 #else
4968 $ac_func();
4969 #endif
4970
4971 ; return 0; }
4972 EOF
4973 if { (eval echo configure:4974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4974   rm -rf conftest*
4975   eval "ac_cv_func_$ac_func=yes"
4976 else
4977   echo "configure: failed program was:" >&5
4978   cat conftest.$ac_ext >&5
4979   rm -rf conftest*
4980   eval "ac_cv_func_$ac_func=no"
4981 fi
4982 rm -f conftest*
4983 fi
4984
4985 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4986   echo "$ac_t""yes" 1>&6
4987     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4988   cat >> confdefs.h <<EOF
4989 #define $ac_tr_func 1
4990 EOF
4991
4992 else
4993   echo "$ac_t""no" 1>&6
4994 fi
4995 done
4996
4997   fi
4998
4999
5000   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
5001 echo "configure:5002: checking for finite declaration" >&5
5002   if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
5003   echo $ac_n "(cached) $ac_c" 1>&6
5004 else
5005
5006
5007     ac_ext=C
5008 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5009 ac_cpp='$CXXCPP $CPPFLAGS'
5010 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5011 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5012 cross_compiling=$ac_cv_prog_cxx_cross
5013
5014     cat > conftest.$ac_ext <<EOF
5015 #line 5016 "configure"
5016 #include "confdefs.h"
5017 #include <math.h>
5018 int main() {
5019  finite(0);
5020 ; return 0; }
5021 EOF
5022 if { (eval echo configure:5023: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5023   rm -rf conftest*
5024   glibcpp_cv_func_finite_use=yes
5025 else
5026   echo "configure: failed program was:" >&5
5027   cat conftest.$ac_ext >&5
5028   rm -rf conftest*
5029   glibcpp_cv_func_finite_use=no
5030 fi
5031 rm -f conftest*
5032     ac_ext=c
5033 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5034 ac_cpp='$CPP $CPPFLAGS'
5035 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5036 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5037 cross_compiling=$ac_cv_prog_cc_cross
5038
5039
5040 fi
5041
5042   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
5043   if test x$glibcpp_cv_func_finite_use = x"yes"; then
5044     for ac_func in finite
5045 do
5046 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5047 echo "configure:5048: checking for $ac_func" >&5
5048 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5049   echo $ac_n "(cached) $ac_c" 1>&6
5050 else
5051   cat > conftest.$ac_ext <<EOF
5052 #line 5053 "configure"
5053 #include "confdefs.h"
5054 /* System header to define __stub macros and hopefully few prototypes,
5055     which can conflict with char $ac_func(); below.  */
5056 #include <assert.h>
5057 /* Override any gcc2 internal prototype to avoid an error.  */
5058 /* We use char because int might match the return type of a gcc2
5059     builtin and then its argument prototype would still apply.  */
5060 char $ac_func();
5061
5062 int main() {
5063
5064 /* The GNU C library defines this for functions which it implements
5065     to always fail with ENOSYS.  Some functions are actually named
5066     something starting with __ and the normal name is an alias.  */
5067 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5068 choke me
5069 #else
5070 $ac_func();
5071 #endif
5072
5073 ; return 0; }
5074 EOF
5075 if { (eval echo configure:5076: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5076   rm -rf conftest*
5077   eval "ac_cv_func_$ac_func=yes"
5078 else
5079   echo "configure: failed program was:" >&5
5080   cat conftest.$ac_ext >&5
5081   rm -rf conftest*
5082   eval "ac_cv_func_$ac_func=no"
5083 fi
5084 rm -f conftest*
5085 fi
5086
5087 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5088   echo "$ac_t""yes" 1>&6
5089     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5090   cat >> confdefs.h <<EOF
5091 #define $ac_tr_func 1
5092 EOF
5093
5094 else
5095   echo "$ac_t""no" 1>&6
5096 fi
5097 done
5098
5099   fi
5100
5101
5102   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
5103 echo "configure:5104: checking for copysign declaration" >&5
5104   if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
5105   echo $ac_n "(cached) $ac_c" 1>&6
5106 else
5107
5108
5109     ac_ext=C
5110 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5111 ac_cpp='$CXXCPP $CPPFLAGS'
5112 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5113 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5114 cross_compiling=$ac_cv_prog_cxx_cross
5115
5116     cat > conftest.$ac_ext <<EOF
5117 #line 5118 "configure"
5118 #include "confdefs.h"
5119 #include <math.h>
5120 int main() {
5121  copysign(0, 0);
5122 ; return 0; }
5123 EOF
5124 if { (eval echo configure:5125: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5125   rm -rf conftest*
5126   glibcpp_cv_func_copysign_use=yes
5127 else
5128   echo "configure: failed program was:" >&5
5129   cat conftest.$ac_ext >&5
5130   rm -rf conftest*
5131   glibcpp_cv_func_copysign_use=no
5132 fi
5133 rm -f conftest*
5134     ac_ext=c
5135 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5136 ac_cpp='$CPP $CPPFLAGS'
5137 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5138 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5139 cross_compiling=$ac_cv_prog_cc_cross
5140
5141
5142 fi
5143
5144   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
5145   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
5146     for ac_func in copysign
5147 do
5148 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5149 echo "configure:5150: checking for $ac_func" >&5
5150 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5151   echo $ac_n "(cached) $ac_c" 1>&6
5152 else
5153   cat > conftest.$ac_ext <<EOF
5154 #line 5155 "configure"
5155 #include "confdefs.h"
5156 /* System header to define __stub macros and hopefully few prototypes,
5157     which can conflict with char $ac_func(); below.  */
5158 #include <assert.h>
5159 /* Override any gcc2 internal prototype to avoid an error.  */
5160 /* We use char because int might match the return type of a gcc2
5161     builtin and then its argument prototype would still apply.  */
5162 char $ac_func();
5163
5164 int main() {
5165
5166 /* The GNU C library defines this for functions which it implements
5167     to always fail with ENOSYS.  Some functions are actually named
5168     something starting with __ and the normal name is an alias.  */
5169 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5170 choke me
5171 #else
5172 $ac_func();
5173 #endif
5174
5175 ; return 0; }
5176 EOF
5177 if { (eval echo configure:5178: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5178   rm -rf conftest*
5179   eval "ac_cv_func_$ac_func=yes"
5180 else
5181   echo "configure: failed program was:" >&5
5182   cat conftest.$ac_ext >&5
5183   rm -rf conftest*
5184   eval "ac_cv_func_$ac_func=no"
5185 fi
5186 rm -f conftest*
5187 fi
5188
5189 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5190   echo "$ac_t""yes" 1>&6
5191     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5192   cat >> confdefs.h <<EOF
5193 #define $ac_tr_func 1
5194 EOF
5195
5196 else
5197   echo "$ac_t""no" 1>&6
5198 fi
5199 done
5200
5201   fi
5202
5203
5204   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
5205 echo "configure:5206: checking for sincos declaration" >&5
5206   if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
5207   echo $ac_n "(cached) $ac_c" 1>&6
5208 else
5209
5210
5211     ac_ext=C
5212 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5213 ac_cpp='$CXXCPP $CPPFLAGS'
5214 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5215 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5216 cross_compiling=$ac_cv_prog_cxx_cross
5217
5218     cat > conftest.$ac_ext <<EOF
5219 #line 5220 "configure"
5220 #include "confdefs.h"
5221 #include <math.h>
5222 int main() {
5223  sincos(0, 0, 0);
5224 ; return 0; }
5225 EOF
5226 if { (eval echo configure:5227: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5227   rm -rf conftest*
5228   glibcpp_cv_func_sincos_use=yes
5229 else
5230   echo "configure: failed program was:" >&5
5231   cat conftest.$ac_ext >&5
5232   rm -rf conftest*
5233   glibcpp_cv_func_sincos_use=no
5234 fi
5235 rm -f conftest*
5236     ac_ext=c
5237 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5238 ac_cpp='$CPP $CPPFLAGS'
5239 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5240 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5241 cross_compiling=$ac_cv_prog_cc_cross
5242
5243
5244 fi
5245
5246   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
5247   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
5248     for ac_func in sincos
5249 do
5250 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5251 echo "configure:5252: checking for $ac_func" >&5
5252 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5253   echo $ac_n "(cached) $ac_c" 1>&6
5254 else
5255   cat > conftest.$ac_ext <<EOF
5256 #line 5257 "configure"
5257 #include "confdefs.h"
5258 /* System header to define __stub macros and hopefully few prototypes,
5259     which can conflict with char $ac_func(); below.  */
5260 #include <assert.h>
5261 /* Override any gcc2 internal prototype to avoid an error.  */
5262 /* We use char because int might match the return type of a gcc2
5263     builtin and then its argument prototype would still apply.  */
5264 char $ac_func();
5265
5266 int main() {
5267
5268 /* The GNU C library defines this for functions which it implements
5269     to always fail with ENOSYS.  Some functions are actually named
5270     something starting with __ and the normal name is an alias.  */
5271 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5272 choke me
5273 #else
5274 $ac_func();
5275 #endif
5276
5277 ; return 0; }
5278 EOF
5279 if { (eval echo configure:5280: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5280   rm -rf conftest*
5281   eval "ac_cv_func_$ac_func=yes"
5282 else
5283   echo "configure: failed program was:" >&5
5284   cat conftest.$ac_ext >&5
5285   rm -rf conftest*
5286   eval "ac_cv_func_$ac_func=no"
5287 fi
5288 rm -f conftest*
5289 fi
5290
5291 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5292   echo "$ac_t""yes" 1>&6
5293     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5294   cat >> confdefs.h <<EOF
5295 #define $ac_tr_func 1
5296 EOF
5297
5298 else
5299   echo "$ac_t""no" 1>&6
5300 fi
5301 done
5302
5303   fi
5304
5305
5306   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
5307 echo "configure:5308: checking for fpclass declaration" >&5
5308   if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
5309   echo $ac_n "(cached) $ac_c" 1>&6
5310 else
5311
5312
5313     ac_ext=C
5314 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5315 ac_cpp='$CXXCPP $CPPFLAGS'
5316 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5317 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5318 cross_compiling=$ac_cv_prog_cxx_cross
5319
5320     cat > conftest.$ac_ext <<EOF
5321 #line 5322 "configure"
5322 #include "confdefs.h"
5323 #include <math.h>
5324 int main() {
5325  fpclass(0);
5326 ; return 0; }
5327 EOF
5328 if { (eval echo configure:5329: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5329   rm -rf conftest*
5330   glibcpp_cv_func_fpclass_use=yes
5331 else
5332   echo "configure: failed program was:" >&5
5333   cat conftest.$ac_ext >&5
5334   rm -rf conftest*
5335   glibcpp_cv_func_fpclass_use=no
5336 fi
5337 rm -f conftest*
5338     ac_ext=c
5339 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5340 ac_cpp='$CPP $CPPFLAGS'
5341 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5342 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5343 cross_compiling=$ac_cv_prog_cc_cross
5344
5345
5346 fi
5347
5348   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
5349   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
5350     for ac_func in fpclass
5351 do
5352 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5353 echo "configure:5354: checking for $ac_func" >&5
5354 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5355   echo $ac_n "(cached) $ac_c" 1>&6
5356 else
5357   cat > conftest.$ac_ext <<EOF
5358 #line 5359 "configure"
5359 #include "confdefs.h"
5360 /* System header to define __stub macros and hopefully few prototypes,
5361     which can conflict with char $ac_func(); below.  */
5362 #include <assert.h>
5363 /* Override any gcc2 internal prototype to avoid an error.  */
5364 /* We use char because int might match the return type of a gcc2
5365     builtin and then its argument prototype would still apply.  */
5366 char $ac_func();
5367
5368 int main() {
5369
5370 /* The GNU C library defines this for functions which it implements
5371     to always fail with ENOSYS.  Some functions are actually named
5372     something starting with __ and the normal name is an alias.  */
5373 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5374 choke me
5375 #else
5376 $ac_func();
5377 #endif
5378
5379 ; return 0; }
5380 EOF
5381 if { (eval echo configure:5382: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5382   rm -rf conftest*
5383   eval "ac_cv_func_$ac_func=yes"
5384 else
5385   echo "configure: failed program was:" >&5
5386   cat conftest.$ac_ext >&5
5387   rm -rf conftest*
5388   eval "ac_cv_func_$ac_func=no"
5389 fi
5390 rm -f conftest*
5391 fi
5392
5393 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5394   echo "$ac_t""yes" 1>&6
5395     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5396   cat >> confdefs.h <<EOF
5397 #define $ac_tr_func 1
5398 EOF
5399
5400 else
5401   echo "$ac_t""no" 1>&6
5402 fi
5403 done
5404
5405   fi
5406
5407
5408   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
5409 echo "configure:5410: checking for qfpclass declaration" >&5
5410   if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
5411   echo $ac_n "(cached) $ac_c" 1>&6
5412 else
5413
5414
5415     ac_ext=C
5416 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5417 ac_cpp='$CXXCPP $CPPFLAGS'
5418 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5419 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5420 cross_compiling=$ac_cv_prog_cxx_cross
5421
5422     cat > conftest.$ac_ext <<EOF
5423 #line 5424 "configure"
5424 #include "confdefs.h"
5425 #include <math.h>
5426 int main() {
5427  qfpclass(0);
5428 ; return 0; }
5429 EOF
5430 if { (eval echo configure:5431: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5431   rm -rf conftest*
5432   glibcpp_cv_func_qfpclass_use=yes
5433 else
5434   echo "configure: failed program was:" >&5
5435   cat conftest.$ac_ext >&5
5436   rm -rf conftest*
5437   glibcpp_cv_func_qfpclass_use=no
5438 fi
5439 rm -f conftest*
5440     ac_ext=c
5441 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5442 ac_cpp='$CPP $CPPFLAGS'
5443 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5444 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5445 cross_compiling=$ac_cv_prog_cc_cross
5446
5447
5448 fi
5449
5450   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
5451   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
5452     for ac_func in qfpclass
5453 do
5454 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5455 echo "configure:5456: checking for $ac_func" >&5
5456 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5457   echo $ac_n "(cached) $ac_c" 1>&6
5458 else
5459   cat > conftest.$ac_ext <<EOF
5460 #line 5461 "configure"
5461 #include "confdefs.h"
5462 /* System header to define __stub macros and hopefully few prototypes,
5463     which can conflict with char $ac_func(); below.  */
5464 #include <assert.h>
5465 /* Override any gcc2 internal prototype to avoid an error.  */
5466 /* We use char because int might match the return type of a gcc2
5467     builtin and then its argument prototype would still apply.  */
5468 char $ac_func();
5469
5470 int main() {
5471
5472 /* The GNU C library defines this for functions which it implements
5473     to always fail with ENOSYS.  Some functions are actually named
5474     something starting with __ and the normal name is an alias.  */
5475 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5476 choke me
5477 #else
5478 $ac_func();
5479 #endif
5480
5481 ; return 0; }
5482 EOF
5483 if { (eval echo configure:5484: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5484   rm -rf conftest*
5485   eval "ac_cv_func_$ac_func=yes"
5486 else
5487   echo "configure: failed program was:" >&5
5488   cat conftest.$ac_ext >&5
5489   rm -rf conftest*
5490   eval "ac_cv_func_$ac_func=no"
5491 fi
5492 rm -f conftest*
5493 fi
5494
5495 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5496   echo "$ac_t""yes" 1>&6
5497     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5498   cat >> confdefs.h <<EOF
5499 #define $ac_tr_func 1
5500 EOF
5501
5502 else
5503   echo "$ac_t""no" 1>&6
5504 fi
5505 done
5506
5507   fi
5508
5509
5510
5511   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5512 echo "configure:5513: checking for isnanf declaration" >&5
5513   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
5514   echo $ac_n "(cached) $ac_c" 1>&6
5515 else
5516
5517
5518     ac_ext=C
5519 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5520 ac_cpp='$CXXCPP $CPPFLAGS'
5521 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5522 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5523 cross_compiling=$ac_cv_prog_cxx_cross
5524
5525     cat > conftest.$ac_ext <<EOF
5526 #line 5527 "configure"
5527 #include "confdefs.h"
5528 #include <math.h>
5529 int main() {
5530  isnanf(0);
5531 ; return 0; }
5532 EOF
5533 if { (eval echo configure:5534: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5534   rm -rf conftest*
5535   glibcpp_cv_func_isnanf_use=yes
5536 else
5537   echo "configure: failed program was:" >&5
5538   cat conftest.$ac_ext >&5
5539   rm -rf conftest*
5540   glibcpp_cv_func_isnanf_use=no
5541 fi
5542 rm -f conftest*
5543     ac_ext=c
5544 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5545 ac_cpp='$CPP $CPPFLAGS'
5546 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5547 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5548 cross_compiling=$ac_cv_prog_cc_cross
5549
5550
5551 fi
5552
5553   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
5554   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
5555     for ac_func in isnanf
5556 do
5557 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5558 echo "configure:5559: checking for $ac_func" >&5
5559 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5560   echo $ac_n "(cached) $ac_c" 1>&6
5561 else
5562   cat > conftest.$ac_ext <<EOF
5563 #line 5564 "configure"
5564 #include "confdefs.h"
5565 /* System header to define __stub macros and hopefully few prototypes,
5566     which can conflict with char $ac_func(); below.  */
5567 #include <assert.h>
5568 /* Override any gcc2 internal prototype to avoid an error.  */
5569 /* We use char because int might match the return type of a gcc2
5570     builtin and then its argument prototype would still apply.  */
5571 char $ac_func();
5572
5573 int main() {
5574
5575 /* The GNU C library defines this for functions which it implements
5576     to always fail with ENOSYS.  Some functions are actually named
5577     something starting with __ and the normal name is an alias.  */
5578 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5579 choke me
5580 #else
5581 $ac_func();
5582 #endif
5583
5584 ; return 0; }
5585 EOF
5586 if { (eval echo configure:5587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5587   rm -rf conftest*
5588   eval "ac_cv_func_$ac_func=yes"
5589 else
5590   echo "configure: failed program was:" >&5
5591   cat conftest.$ac_ext >&5
5592   rm -rf conftest*
5593   eval "ac_cv_func_$ac_func=no"
5594 fi
5595 rm -f conftest*
5596 fi
5597
5598 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5599   echo "$ac_t""yes" 1>&6
5600     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5601   cat >> confdefs.h <<EOF
5602 #define $ac_tr_func 1
5603 EOF
5604
5605 else
5606   echo "$ac_t""no" 1>&6
5607 fi
5608 done
5609
5610   fi
5611
5612
5613   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5614 echo "configure:5615: checking for isinff declaration" >&5
5615   if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
5616   echo $ac_n "(cached) $ac_c" 1>&6
5617 else
5618
5619
5620     ac_ext=C
5621 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5622 ac_cpp='$CXXCPP $CPPFLAGS'
5623 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5624 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5625 cross_compiling=$ac_cv_prog_cxx_cross
5626
5627     cat > conftest.$ac_ext <<EOF
5628 #line 5629 "configure"
5629 #include "confdefs.h"
5630 #include <math.h>
5631 int main() {
5632  isinff(0);
5633 ; return 0; }
5634 EOF
5635 if { (eval echo configure:5636: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5636   rm -rf conftest*
5637   glibcpp_cv_func_isinff_use=yes
5638 else
5639   echo "configure: failed program was:" >&5
5640   cat conftest.$ac_ext >&5
5641   rm -rf conftest*
5642   glibcpp_cv_func_isinff_use=no
5643 fi
5644 rm -f conftest*
5645     ac_ext=c
5646 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5647 ac_cpp='$CPP $CPPFLAGS'
5648 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5649 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5650 cross_compiling=$ac_cv_prog_cc_cross
5651
5652
5653 fi
5654
5655   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
5656   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
5657     for ac_func in isinff
5658 do
5659 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5660 echo "configure:5661: checking for $ac_func" >&5
5661 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5662   echo $ac_n "(cached) $ac_c" 1>&6
5663 else
5664   cat > conftest.$ac_ext <<EOF
5665 #line 5666 "configure"
5666 #include "confdefs.h"
5667 /* System header to define __stub macros and hopefully few prototypes,
5668     which can conflict with char $ac_func(); below.  */
5669 #include <assert.h>
5670 /* Override any gcc2 internal prototype to avoid an error.  */
5671 /* We use char because int might match the return type of a gcc2
5672     builtin and then its argument prototype would still apply.  */
5673 char $ac_func();
5674
5675 int main() {
5676
5677 /* The GNU C library defines this for functions which it implements
5678     to always fail with ENOSYS.  Some functions are actually named
5679     something starting with __ and the normal name is an alias.  */
5680 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5681 choke me
5682 #else
5683 $ac_func();
5684 #endif
5685
5686 ; return 0; }
5687 EOF
5688 if { (eval echo configure:5689: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5689   rm -rf conftest*
5690   eval "ac_cv_func_$ac_func=yes"
5691 else
5692   echo "configure: failed program was:" >&5
5693   cat conftest.$ac_ext >&5
5694   rm -rf conftest*
5695   eval "ac_cv_func_$ac_func=no"
5696 fi
5697 rm -f conftest*
5698 fi
5699
5700 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5701   echo "$ac_t""yes" 1>&6
5702     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5703   cat >> confdefs.h <<EOF
5704 #define $ac_tr_func 1
5705 EOF
5706
5707 else
5708   echo "$ac_t""no" 1>&6
5709 fi
5710 done
5711
5712   fi
5713
5714
5715   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5716 echo "configure:5717: checking for acosf declaration" >&5
5717   if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
5718   echo $ac_n "(cached) $ac_c" 1>&6
5719 else
5720
5721
5722     ac_ext=C
5723 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5724 ac_cpp='$CXXCPP $CPPFLAGS'
5725 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5726 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5727 cross_compiling=$ac_cv_prog_cxx_cross
5728
5729     cat > conftest.$ac_ext <<EOF
5730 #line 5731 "configure"
5731 #include "confdefs.h"
5732 #include <math.h>
5733 int main() {
5734  acosf(0);
5735 ; return 0; }
5736 EOF
5737 if { (eval echo configure:5738: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5738   rm -rf conftest*
5739   glibcpp_cv_func_acosf_use=yes
5740 else
5741   echo "configure: failed program was:" >&5
5742   cat conftest.$ac_ext >&5
5743   rm -rf conftest*
5744   glibcpp_cv_func_acosf_use=no
5745 fi
5746 rm -f conftest*
5747     ac_ext=c
5748 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5749 ac_cpp='$CPP $CPPFLAGS'
5750 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5751 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5752 cross_compiling=$ac_cv_prog_cc_cross
5753
5754
5755 fi
5756
5757   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
5758   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
5759     for ac_func in acosf
5760 do
5761 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5762 echo "configure:5763: checking for $ac_func" >&5
5763 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5764   echo $ac_n "(cached) $ac_c" 1>&6
5765 else
5766   cat > conftest.$ac_ext <<EOF
5767 #line 5768 "configure"
5768 #include "confdefs.h"
5769 /* System header to define __stub macros and hopefully few prototypes,
5770     which can conflict with char $ac_func(); below.  */
5771 #include <assert.h>
5772 /* Override any gcc2 internal prototype to avoid an error.  */
5773 /* We use char because int might match the return type of a gcc2
5774     builtin and then its argument prototype would still apply.  */
5775 char $ac_func();
5776
5777 int main() {
5778
5779 /* The GNU C library defines this for functions which it implements
5780     to always fail with ENOSYS.  Some functions are actually named
5781     something starting with __ and the normal name is an alias.  */
5782 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5783 choke me
5784 #else
5785 $ac_func();
5786 #endif
5787
5788 ; return 0; }
5789 EOF
5790 if { (eval echo configure:5791: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5791   rm -rf conftest*
5792   eval "ac_cv_func_$ac_func=yes"
5793 else
5794   echo "configure: failed program was:" >&5
5795   cat conftest.$ac_ext >&5
5796   rm -rf conftest*
5797   eval "ac_cv_func_$ac_func=no"
5798 fi
5799 rm -f conftest*
5800 fi
5801
5802 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5803   echo "$ac_t""yes" 1>&6
5804     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5805   cat >> confdefs.h <<EOF
5806 #define $ac_tr_func 1
5807 EOF
5808
5809 else
5810   echo "$ac_t""no" 1>&6
5811 fi
5812 done
5813
5814   fi
5815
5816
5817   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5818 echo "configure:5819: checking for asinf declaration" >&5
5819   if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
5820   echo $ac_n "(cached) $ac_c" 1>&6
5821 else
5822
5823
5824     ac_ext=C
5825 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5826 ac_cpp='$CXXCPP $CPPFLAGS'
5827 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5828 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5829 cross_compiling=$ac_cv_prog_cxx_cross
5830
5831     cat > conftest.$ac_ext <<EOF
5832 #line 5833 "configure"
5833 #include "confdefs.h"
5834 #include <math.h>
5835 int main() {
5836  asinf(0);
5837 ; return 0; }
5838 EOF
5839 if { (eval echo configure:5840: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5840   rm -rf conftest*
5841   glibcpp_cv_func_asinf_use=yes
5842 else
5843   echo "configure: failed program was:" >&5
5844   cat conftest.$ac_ext >&5
5845   rm -rf conftest*
5846   glibcpp_cv_func_asinf_use=no
5847 fi
5848 rm -f conftest*
5849     ac_ext=c
5850 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5851 ac_cpp='$CPP $CPPFLAGS'
5852 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5853 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5854 cross_compiling=$ac_cv_prog_cc_cross
5855
5856
5857 fi
5858
5859   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
5860   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
5861     for ac_func in asinf
5862 do
5863 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5864 echo "configure:5865: checking for $ac_func" >&5
5865 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5866   echo $ac_n "(cached) $ac_c" 1>&6
5867 else
5868   cat > conftest.$ac_ext <<EOF
5869 #line 5870 "configure"
5870 #include "confdefs.h"
5871 /* System header to define __stub macros and hopefully few prototypes,
5872     which can conflict with char $ac_func(); below.  */
5873 #include <assert.h>
5874 /* Override any gcc2 internal prototype to avoid an error.  */
5875 /* We use char because int might match the return type of a gcc2
5876     builtin and then its argument prototype would still apply.  */
5877 char $ac_func();
5878
5879 int main() {
5880
5881 /* The GNU C library defines this for functions which it implements
5882     to always fail with ENOSYS.  Some functions are actually named
5883     something starting with __ and the normal name is an alias.  */
5884 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5885 choke me
5886 #else
5887 $ac_func();
5888 #endif
5889
5890 ; return 0; }
5891 EOF
5892 if { (eval echo configure:5893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5893   rm -rf conftest*
5894   eval "ac_cv_func_$ac_func=yes"
5895 else
5896   echo "configure: failed program was:" >&5
5897   cat conftest.$ac_ext >&5
5898   rm -rf conftest*
5899   eval "ac_cv_func_$ac_func=no"
5900 fi
5901 rm -f conftest*
5902 fi
5903
5904 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5905   echo "$ac_t""yes" 1>&6
5906     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5907   cat >> confdefs.h <<EOF
5908 #define $ac_tr_func 1
5909 EOF
5910
5911 else
5912   echo "$ac_t""no" 1>&6
5913 fi
5914 done
5915
5916   fi
5917
5918
5919   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5920 echo "configure:5921: checking for atanf declaration" >&5
5921   if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
5922   echo $ac_n "(cached) $ac_c" 1>&6
5923 else
5924
5925
5926     ac_ext=C
5927 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5928 ac_cpp='$CXXCPP $CPPFLAGS'
5929 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5930 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5931 cross_compiling=$ac_cv_prog_cxx_cross
5932
5933     cat > conftest.$ac_ext <<EOF
5934 #line 5935 "configure"
5935 #include "confdefs.h"
5936 #include <math.h>
5937 int main() {
5938  atanf(0);
5939 ; return 0; }
5940 EOF
5941 if { (eval echo configure:5942: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5942   rm -rf conftest*
5943   glibcpp_cv_func_atanf_use=yes
5944 else
5945   echo "configure: failed program was:" >&5
5946   cat conftest.$ac_ext >&5
5947   rm -rf conftest*
5948   glibcpp_cv_func_atanf_use=no
5949 fi
5950 rm -f conftest*
5951     ac_ext=c
5952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5953 ac_cpp='$CPP $CPPFLAGS'
5954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5956 cross_compiling=$ac_cv_prog_cc_cross
5957
5958
5959 fi
5960
5961   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
5962   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
5963     for ac_func in atanf
5964 do
5965 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5966 echo "configure:5967: checking for $ac_func" >&5
5967 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5968   echo $ac_n "(cached) $ac_c" 1>&6
5969 else
5970   cat > conftest.$ac_ext <<EOF
5971 #line 5972 "configure"
5972 #include "confdefs.h"
5973 /* System header to define __stub macros and hopefully few prototypes,
5974     which can conflict with char $ac_func(); below.  */
5975 #include <assert.h>
5976 /* Override any gcc2 internal prototype to avoid an error.  */
5977 /* We use char because int might match the return type of a gcc2
5978     builtin and then its argument prototype would still apply.  */
5979 char $ac_func();
5980
5981 int main() {
5982
5983 /* The GNU C library defines this for functions which it implements
5984     to always fail with ENOSYS.  Some functions are actually named
5985     something starting with __ and the normal name is an alias.  */
5986 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5987 choke me
5988 #else
5989 $ac_func();
5990 #endif
5991
5992 ; return 0; }
5993 EOF
5994 if { (eval echo configure:5995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5995   rm -rf conftest*
5996   eval "ac_cv_func_$ac_func=yes"
5997 else
5998   echo "configure: failed program was:" >&5
5999   cat conftest.$ac_ext >&5
6000   rm -rf conftest*
6001   eval "ac_cv_func_$ac_func=no"
6002 fi
6003 rm -f conftest*
6004 fi
6005
6006 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6007   echo "$ac_t""yes" 1>&6
6008     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6009   cat >> confdefs.h <<EOF
6010 #define $ac_tr_func 1
6011 EOF
6012
6013 else
6014   echo "$ac_t""no" 1>&6
6015 fi
6016 done
6017
6018   fi
6019
6020
6021   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
6022 echo "configure:6023: checking for atan2f declaration" >&5
6023   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
6024   echo $ac_n "(cached) $ac_c" 1>&6
6025 else
6026
6027
6028     ac_ext=C
6029 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6030 ac_cpp='$CXXCPP $CPPFLAGS'
6031 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6032 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6033 cross_compiling=$ac_cv_prog_cxx_cross
6034
6035     cat > conftest.$ac_ext <<EOF
6036 #line 6037 "configure"
6037 #include "confdefs.h"
6038 #include <math.h>
6039 int main() {
6040  atan2f(0, 0);
6041 ; return 0; }
6042 EOF
6043 if { (eval echo configure:6044: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6044   rm -rf conftest*
6045   glibcpp_cv_func_atan2f_use=yes
6046 else
6047   echo "configure: failed program was:" >&5
6048   cat conftest.$ac_ext >&5
6049   rm -rf conftest*
6050   glibcpp_cv_func_atan2f_use=no
6051 fi
6052 rm -f conftest*
6053     ac_ext=c
6054 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6055 ac_cpp='$CPP $CPPFLAGS'
6056 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6057 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6058 cross_compiling=$ac_cv_prog_cc_cross
6059
6060
6061 fi
6062
6063   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
6064   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
6065     for ac_func in atan2f
6066 do
6067 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6068 echo "configure:6069: checking for $ac_func" >&5
6069 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6070   echo $ac_n "(cached) $ac_c" 1>&6
6071 else
6072   cat > conftest.$ac_ext <<EOF
6073 #line 6074 "configure"
6074 #include "confdefs.h"
6075 /* System header to define __stub macros and hopefully few prototypes,
6076     which can conflict with char $ac_func(); below.  */
6077 #include <assert.h>
6078 /* Override any gcc2 internal prototype to avoid an error.  */
6079 /* We use char because int might match the return type of a gcc2
6080     builtin and then its argument prototype would still apply.  */
6081 char $ac_func();
6082
6083 int main() {
6084
6085 /* The GNU C library defines this for functions which it implements
6086     to always fail with ENOSYS.  Some functions are actually named
6087     something starting with __ and the normal name is an alias.  */
6088 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6089 choke me
6090 #else
6091 $ac_func();
6092 #endif
6093
6094 ; return 0; }
6095 EOF
6096 if { (eval echo configure:6097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6097   rm -rf conftest*
6098   eval "ac_cv_func_$ac_func=yes"
6099 else
6100   echo "configure: failed program was:" >&5
6101   cat conftest.$ac_ext >&5
6102   rm -rf conftest*
6103   eval "ac_cv_func_$ac_func=no"
6104 fi
6105 rm -f conftest*
6106 fi
6107
6108 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6109   echo "$ac_t""yes" 1>&6
6110     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6111   cat >> confdefs.h <<EOF
6112 #define $ac_tr_func 1
6113 EOF
6114
6115 else
6116   echo "$ac_t""no" 1>&6
6117 fi
6118 done
6119
6120   fi
6121
6122
6123   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6124 echo "configure:6125: checking for ceilf declaration" >&5
6125   if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
6126   echo $ac_n "(cached) $ac_c" 1>&6
6127 else
6128
6129
6130     ac_ext=C
6131 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6132 ac_cpp='$CXXCPP $CPPFLAGS'
6133 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6134 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6135 cross_compiling=$ac_cv_prog_cxx_cross
6136
6137     cat > conftest.$ac_ext <<EOF
6138 #line 6139 "configure"
6139 #include "confdefs.h"
6140 #include <math.h>
6141 int main() {
6142  ceilf(0);
6143 ; return 0; }
6144 EOF
6145 if { (eval echo configure:6146: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6146   rm -rf conftest*
6147   glibcpp_cv_func_ceilf_use=yes
6148 else
6149   echo "configure: failed program was:" >&5
6150   cat conftest.$ac_ext >&5
6151   rm -rf conftest*
6152   glibcpp_cv_func_ceilf_use=no
6153 fi
6154 rm -f conftest*
6155     ac_ext=c
6156 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6157 ac_cpp='$CPP $CPPFLAGS'
6158 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6159 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6160 cross_compiling=$ac_cv_prog_cc_cross
6161
6162
6163 fi
6164
6165   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
6166   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
6167     for ac_func in ceilf
6168 do
6169 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6170 echo "configure:6171: checking for $ac_func" >&5
6171 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6172   echo $ac_n "(cached) $ac_c" 1>&6
6173 else
6174   cat > conftest.$ac_ext <<EOF
6175 #line 6176 "configure"
6176 #include "confdefs.h"
6177 /* System header to define __stub macros and hopefully few prototypes,
6178     which can conflict with char $ac_func(); below.  */
6179 #include <assert.h>
6180 /* Override any gcc2 internal prototype to avoid an error.  */
6181 /* We use char because int might match the return type of a gcc2
6182     builtin and then its argument prototype would still apply.  */
6183 char $ac_func();
6184
6185 int main() {
6186
6187 /* The GNU C library defines this for functions which it implements
6188     to always fail with ENOSYS.  Some functions are actually named
6189     something starting with __ and the normal name is an alias.  */
6190 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6191 choke me
6192 #else
6193 $ac_func();
6194 #endif
6195
6196 ; return 0; }
6197 EOF
6198 if { (eval echo configure:6199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6199   rm -rf conftest*
6200   eval "ac_cv_func_$ac_func=yes"
6201 else
6202   echo "configure: failed program was:" >&5
6203   cat conftest.$ac_ext >&5
6204   rm -rf conftest*
6205   eval "ac_cv_func_$ac_func=no"
6206 fi
6207 rm -f conftest*
6208 fi
6209
6210 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6211   echo "$ac_t""yes" 1>&6
6212     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6213   cat >> confdefs.h <<EOF
6214 #define $ac_tr_func 1
6215 EOF
6216
6217 else
6218   echo "$ac_t""no" 1>&6
6219 fi
6220 done
6221
6222   fi
6223
6224
6225   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6226 echo "configure:6227: checking for cosf declaration" >&5
6227   if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
6228   echo $ac_n "(cached) $ac_c" 1>&6
6229 else
6230
6231
6232     ac_ext=C
6233 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6234 ac_cpp='$CXXCPP $CPPFLAGS'
6235 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6236 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6237 cross_compiling=$ac_cv_prog_cxx_cross
6238
6239     cat > conftest.$ac_ext <<EOF
6240 #line 6241 "configure"
6241 #include "confdefs.h"
6242 #include <math.h>
6243 int main() {
6244  cosf(0);
6245 ; return 0; }
6246 EOF
6247 if { (eval echo configure:6248: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6248   rm -rf conftest*
6249   glibcpp_cv_func_cosf_use=yes
6250 else
6251   echo "configure: failed program was:" >&5
6252   cat conftest.$ac_ext >&5
6253   rm -rf conftest*
6254   glibcpp_cv_func_cosf_use=no
6255 fi
6256 rm -f conftest*
6257     ac_ext=c
6258 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6259 ac_cpp='$CPP $CPPFLAGS'
6260 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6261 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6262 cross_compiling=$ac_cv_prog_cc_cross
6263
6264
6265 fi
6266
6267   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
6268   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
6269     for ac_func in cosf
6270 do
6271 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6272 echo "configure:6273: checking for $ac_func" >&5
6273 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6274   echo $ac_n "(cached) $ac_c" 1>&6
6275 else
6276   cat > conftest.$ac_ext <<EOF
6277 #line 6278 "configure"
6278 #include "confdefs.h"
6279 /* System header to define __stub macros and hopefully few prototypes,
6280     which can conflict with char $ac_func(); below.  */
6281 #include <assert.h>
6282 /* Override any gcc2 internal prototype to avoid an error.  */
6283 /* We use char because int might match the return type of a gcc2
6284     builtin and then its argument prototype would still apply.  */
6285 char $ac_func();
6286
6287 int main() {
6288
6289 /* The GNU C library defines this for functions which it implements
6290     to always fail with ENOSYS.  Some functions are actually named
6291     something starting with __ and the normal name is an alias.  */
6292 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6293 choke me
6294 #else
6295 $ac_func();
6296 #endif
6297
6298 ; return 0; }
6299 EOF
6300 if { (eval echo configure:6301: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6301   rm -rf conftest*
6302   eval "ac_cv_func_$ac_func=yes"
6303 else
6304   echo "configure: failed program was:" >&5
6305   cat conftest.$ac_ext >&5
6306   rm -rf conftest*
6307   eval "ac_cv_func_$ac_func=no"
6308 fi
6309 rm -f conftest*
6310 fi
6311
6312 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6313   echo "$ac_t""yes" 1>&6
6314     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6315   cat >> confdefs.h <<EOF
6316 #define $ac_tr_func 1
6317 EOF
6318
6319 else
6320   echo "$ac_t""no" 1>&6
6321 fi
6322 done
6323
6324   fi
6325
6326
6327   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6328 echo "configure:6329: checking for coshf declaration" >&5
6329   if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
6330   echo $ac_n "(cached) $ac_c" 1>&6
6331 else
6332
6333
6334     ac_ext=C
6335 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6336 ac_cpp='$CXXCPP $CPPFLAGS'
6337 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6338 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6339 cross_compiling=$ac_cv_prog_cxx_cross
6340
6341     cat > conftest.$ac_ext <<EOF
6342 #line 6343 "configure"
6343 #include "confdefs.h"
6344 #include <math.h>
6345 int main() {
6346  coshf(0);
6347 ; return 0; }
6348 EOF
6349 if { (eval echo configure:6350: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6350   rm -rf conftest*
6351   glibcpp_cv_func_coshf_use=yes
6352 else
6353   echo "configure: failed program was:" >&5
6354   cat conftest.$ac_ext >&5
6355   rm -rf conftest*
6356   glibcpp_cv_func_coshf_use=no
6357 fi
6358 rm -f conftest*
6359     ac_ext=c
6360 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6361 ac_cpp='$CPP $CPPFLAGS'
6362 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6363 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6364 cross_compiling=$ac_cv_prog_cc_cross
6365
6366
6367 fi
6368
6369   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
6370   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
6371     for ac_func in coshf
6372 do
6373 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6374 echo "configure:6375: checking for $ac_func" >&5
6375 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6376   echo $ac_n "(cached) $ac_c" 1>&6
6377 else
6378   cat > conftest.$ac_ext <<EOF
6379 #line 6380 "configure"
6380 #include "confdefs.h"
6381 /* System header to define __stub macros and hopefully few prototypes,
6382     which can conflict with char $ac_func(); below.  */
6383 #include <assert.h>
6384 /* Override any gcc2 internal prototype to avoid an error.  */
6385 /* We use char because int might match the return type of a gcc2
6386     builtin and then its argument prototype would still apply.  */
6387 char $ac_func();
6388
6389 int main() {
6390
6391 /* The GNU C library defines this for functions which it implements
6392     to always fail with ENOSYS.  Some functions are actually named
6393     something starting with __ and the normal name is an alias.  */
6394 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6395 choke me
6396 #else
6397 $ac_func();
6398 #endif
6399
6400 ; return 0; }
6401 EOF
6402 if { (eval echo configure:6403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6403   rm -rf conftest*
6404   eval "ac_cv_func_$ac_func=yes"
6405 else
6406   echo "configure: failed program was:" >&5
6407   cat conftest.$ac_ext >&5
6408   rm -rf conftest*
6409   eval "ac_cv_func_$ac_func=no"
6410 fi
6411 rm -f conftest*
6412 fi
6413
6414 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6415   echo "$ac_t""yes" 1>&6
6416     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6417   cat >> confdefs.h <<EOF
6418 #define $ac_tr_func 1
6419 EOF
6420
6421 else
6422   echo "$ac_t""no" 1>&6
6423 fi
6424 done
6425
6426   fi
6427
6428
6429   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6430 echo "configure:6431: checking for expf declaration" >&5
6431   if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
6432   echo $ac_n "(cached) $ac_c" 1>&6
6433 else
6434
6435
6436     ac_ext=C
6437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6438 ac_cpp='$CXXCPP $CPPFLAGS'
6439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6441 cross_compiling=$ac_cv_prog_cxx_cross
6442
6443     cat > conftest.$ac_ext <<EOF
6444 #line 6445 "configure"
6445 #include "confdefs.h"
6446 #include <math.h>
6447 int main() {
6448  expf(0);
6449 ; return 0; }
6450 EOF
6451 if { (eval echo configure:6452: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6452   rm -rf conftest*
6453   glibcpp_cv_func_expf_use=yes
6454 else
6455   echo "configure: failed program was:" >&5
6456   cat conftest.$ac_ext >&5
6457   rm -rf conftest*
6458   glibcpp_cv_func_expf_use=no
6459 fi
6460 rm -f conftest*
6461     ac_ext=c
6462 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6463 ac_cpp='$CPP $CPPFLAGS'
6464 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6465 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6466 cross_compiling=$ac_cv_prog_cc_cross
6467
6468
6469 fi
6470
6471   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
6472   if test x$glibcpp_cv_func_expf_use = x"yes"; then
6473     for ac_func in expf
6474 do
6475 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6476 echo "configure:6477: checking for $ac_func" >&5
6477 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6478   echo $ac_n "(cached) $ac_c" 1>&6
6479 else
6480   cat > conftest.$ac_ext <<EOF
6481 #line 6482 "configure"
6482 #include "confdefs.h"
6483 /* System header to define __stub macros and hopefully few prototypes,
6484     which can conflict with char $ac_func(); below.  */
6485 #include <assert.h>
6486 /* Override any gcc2 internal prototype to avoid an error.  */
6487 /* We use char because int might match the return type of a gcc2
6488     builtin and then its argument prototype would still apply.  */
6489 char $ac_func();
6490
6491 int main() {
6492
6493 /* The GNU C library defines this for functions which it implements
6494     to always fail with ENOSYS.  Some functions are actually named
6495     something starting with __ and the normal name is an alias.  */
6496 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6497 choke me
6498 #else
6499 $ac_func();
6500 #endif
6501
6502 ; return 0; }
6503 EOF
6504 if { (eval echo configure:6505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6505   rm -rf conftest*
6506   eval "ac_cv_func_$ac_func=yes"
6507 else
6508   echo "configure: failed program was:" >&5
6509   cat conftest.$ac_ext >&5
6510   rm -rf conftest*
6511   eval "ac_cv_func_$ac_func=no"
6512 fi
6513 rm -f conftest*
6514 fi
6515
6516 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6517   echo "$ac_t""yes" 1>&6
6518     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6519   cat >> confdefs.h <<EOF
6520 #define $ac_tr_func 1
6521 EOF
6522
6523 else
6524   echo "$ac_t""no" 1>&6
6525 fi
6526 done
6527
6528   fi
6529
6530
6531   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6532 echo "configure:6533: checking for fabsf declaration" >&5
6533   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
6534   echo $ac_n "(cached) $ac_c" 1>&6
6535 else
6536
6537
6538     ac_ext=C
6539 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6540 ac_cpp='$CXXCPP $CPPFLAGS'
6541 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6542 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6543 cross_compiling=$ac_cv_prog_cxx_cross
6544
6545     cat > conftest.$ac_ext <<EOF
6546 #line 6547 "configure"
6547 #include "confdefs.h"
6548 #include <math.h>
6549 int main() {
6550  fabsf(0);
6551 ; return 0; }
6552 EOF
6553 if { (eval echo configure:6554: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6554   rm -rf conftest*
6555   glibcpp_cv_func_fabsf_use=yes
6556 else
6557   echo "configure: failed program was:" >&5
6558   cat conftest.$ac_ext >&5
6559   rm -rf conftest*
6560   glibcpp_cv_func_fabsf_use=no
6561 fi
6562 rm -f conftest*
6563     ac_ext=c
6564 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6565 ac_cpp='$CPP $CPPFLAGS'
6566 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6567 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6568 cross_compiling=$ac_cv_prog_cc_cross
6569
6570
6571 fi
6572
6573   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
6574   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
6575     for ac_func in fabsf
6576 do
6577 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6578 echo "configure:6579: checking for $ac_func" >&5
6579 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6580   echo $ac_n "(cached) $ac_c" 1>&6
6581 else
6582   cat > conftest.$ac_ext <<EOF
6583 #line 6584 "configure"
6584 #include "confdefs.h"
6585 /* System header to define __stub macros and hopefully few prototypes,
6586     which can conflict with char $ac_func(); below.  */
6587 #include <assert.h>
6588 /* Override any gcc2 internal prototype to avoid an error.  */
6589 /* We use char because int might match the return type of a gcc2
6590     builtin and then its argument prototype would still apply.  */
6591 char $ac_func();
6592
6593 int main() {
6594
6595 /* The GNU C library defines this for functions which it implements
6596     to always fail with ENOSYS.  Some functions are actually named
6597     something starting with __ and the normal name is an alias.  */
6598 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6599 choke me
6600 #else
6601 $ac_func();
6602 #endif
6603
6604 ; return 0; }
6605 EOF
6606 if { (eval echo configure:6607: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6607   rm -rf conftest*
6608   eval "ac_cv_func_$ac_func=yes"
6609 else
6610   echo "configure: failed program was:" >&5
6611   cat conftest.$ac_ext >&5
6612   rm -rf conftest*
6613   eval "ac_cv_func_$ac_func=no"
6614 fi
6615 rm -f conftest*
6616 fi
6617
6618 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6619   echo "$ac_t""yes" 1>&6
6620     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6621   cat >> confdefs.h <<EOF
6622 #define $ac_tr_func 1
6623 EOF
6624
6625 else
6626   echo "$ac_t""no" 1>&6
6627 fi
6628 done
6629
6630   fi
6631
6632
6633   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6634 echo "configure:6635: checking for floorf declaration" >&5
6635   if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
6636   echo $ac_n "(cached) $ac_c" 1>&6
6637 else
6638
6639
6640     ac_ext=C
6641 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6642 ac_cpp='$CXXCPP $CPPFLAGS'
6643 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6644 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6645 cross_compiling=$ac_cv_prog_cxx_cross
6646
6647     cat > conftest.$ac_ext <<EOF
6648 #line 6649 "configure"
6649 #include "confdefs.h"
6650 #include <math.h>
6651 int main() {
6652  floorf(0);
6653 ; return 0; }
6654 EOF
6655 if { (eval echo configure:6656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6656   rm -rf conftest*
6657   glibcpp_cv_func_floorf_use=yes
6658 else
6659   echo "configure: failed program was:" >&5
6660   cat conftest.$ac_ext >&5
6661   rm -rf conftest*
6662   glibcpp_cv_func_floorf_use=no
6663 fi
6664 rm -f conftest*
6665     ac_ext=c
6666 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6667 ac_cpp='$CPP $CPPFLAGS'
6668 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6669 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6670 cross_compiling=$ac_cv_prog_cc_cross
6671
6672
6673 fi
6674
6675   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
6676   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
6677     for ac_func in floorf
6678 do
6679 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6680 echo "configure:6681: checking for $ac_func" >&5
6681 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6682   echo $ac_n "(cached) $ac_c" 1>&6
6683 else
6684   cat > conftest.$ac_ext <<EOF
6685 #line 6686 "configure"
6686 #include "confdefs.h"
6687 /* System header to define __stub macros and hopefully few prototypes,
6688     which can conflict with char $ac_func(); below.  */
6689 #include <assert.h>
6690 /* Override any gcc2 internal prototype to avoid an error.  */
6691 /* We use char because int might match the return type of a gcc2
6692     builtin and then its argument prototype would still apply.  */
6693 char $ac_func();
6694
6695 int main() {
6696
6697 /* The GNU C library defines this for functions which it implements
6698     to always fail with ENOSYS.  Some functions are actually named
6699     something starting with __ and the normal name is an alias.  */
6700 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6701 choke me
6702 #else
6703 $ac_func();
6704 #endif
6705
6706 ; return 0; }
6707 EOF
6708 if { (eval echo configure:6709: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6709   rm -rf conftest*
6710   eval "ac_cv_func_$ac_func=yes"
6711 else
6712   echo "configure: failed program was:" >&5
6713   cat conftest.$ac_ext >&5
6714   rm -rf conftest*
6715   eval "ac_cv_func_$ac_func=no"
6716 fi
6717 rm -f conftest*
6718 fi
6719
6720 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6721   echo "$ac_t""yes" 1>&6
6722     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6723   cat >> confdefs.h <<EOF
6724 #define $ac_tr_func 1
6725 EOF
6726
6727 else
6728   echo "$ac_t""no" 1>&6
6729 fi
6730 done
6731
6732   fi
6733
6734
6735   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6736 echo "configure:6737: checking for fmodf declaration" >&5
6737   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
6738   echo $ac_n "(cached) $ac_c" 1>&6
6739 else
6740
6741
6742     ac_ext=C
6743 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6744 ac_cpp='$CXXCPP $CPPFLAGS'
6745 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6746 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6747 cross_compiling=$ac_cv_prog_cxx_cross
6748
6749     cat > conftest.$ac_ext <<EOF
6750 #line 6751 "configure"
6751 #include "confdefs.h"
6752 #include <math.h>
6753 int main() {
6754  fmodf(0, 0);
6755 ; return 0; }
6756 EOF
6757 if { (eval echo configure:6758: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6758   rm -rf conftest*
6759   glibcpp_cv_func_fmodf_use=yes
6760 else
6761   echo "configure: failed program was:" >&5
6762   cat conftest.$ac_ext >&5
6763   rm -rf conftest*
6764   glibcpp_cv_func_fmodf_use=no
6765 fi
6766 rm -f conftest*
6767     ac_ext=c
6768 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6769 ac_cpp='$CPP $CPPFLAGS'
6770 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6771 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6772 cross_compiling=$ac_cv_prog_cc_cross
6773
6774
6775 fi
6776
6777   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
6778   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
6779     for ac_func in fmodf
6780 do
6781 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6782 echo "configure:6783: checking for $ac_func" >&5
6783 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6784   echo $ac_n "(cached) $ac_c" 1>&6
6785 else
6786   cat > conftest.$ac_ext <<EOF
6787 #line 6788 "configure"
6788 #include "confdefs.h"
6789 /* System header to define __stub macros and hopefully few prototypes,
6790     which can conflict with char $ac_func(); below.  */
6791 #include <assert.h>
6792 /* Override any gcc2 internal prototype to avoid an error.  */
6793 /* We use char because int might match the return type of a gcc2
6794     builtin and then its argument prototype would still apply.  */
6795 char $ac_func();
6796
6797 int main() {
6798
6799 /* The GNU C library defines this for functions which it implements
6800     to always fail with ENOSYS.  Some functions are actually named
6801     something starting with __ and the normal name is an alias.  */
6802 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6803 choke me
6804 #else
6805 $ac_func();
6806 #endif
6807
6808 ; return 0; }
6809 EOF
6810 if { (eval echo configure:6811: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6811   rm -rf conftest*
6812   eval "ac_cv_func_$ac_func=yes"
6813 else
6814   echo "configure: failed program was:" >&5
6815   cat conftest.$ac_ext >&5
6816   rm -rf conftest*
6817   eval "ac_cv_func_$ac_func=no"
6818 fi
6819 rm -f conftest*
6820 fi
6821
6822 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6823   echo "$ac_t""yes" 1>&6
6824     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6825   cat >> confdefs.h <<EOF
6826 #define $ac_tr_func 1
6827 EOF
6828
6829 else
6830   echo "$ac_t""no" 1>&6
6831 fi
6832 done
6833
6834   fi
6835
6836
6837   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6838 echo "configure:6839: checking for frexpf declaration" >&5
6839   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
6840   echo $ac_n "(cached) $ac_c" 1>&6
6841 else
6842
6843
6844     ac_ext=C
6845 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6846 ac_cpp='$CXXCPP $CPPFLAGS'
6847 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6848 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6849 cross_compiling=$ac_cv_prog_cxx_cross
6850
6851     cat > conftest.$ac_ext <<EOF
6852 #line 6853 "configure"
6853 #include "confdefs.h"
6854 #include <math.h>
6855 int main() {
6856  frexpf(0, 0);
6857 ; return 0; }
6858 EOF
6859 if { (eval echo configure:6860: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6860   rm -rf conftest*
6861   glibcpp_cv_func_frexpf_use=yes
6862 else
6863   echo "configure: failed program was:" >&5
6864   cat conftest.$ac_ext >&5
6865   rm -rf conftest*
6866   glibcpp_cv_func_frexpf_use=no
6867 fi
6868 rm -f conftest*
6869     ac_ext=c
6870 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6871 ac_cpp='$CPP $CPPFLAGS'
6872 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6873 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6874 cross_compiling=$ac_cv_prog_cc_cross
6875
6876
6877 fi
6878
6879   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
6880   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
6881     for ac_func in frexpf
6882 do
6883 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6884 echo "configure:6885: checking for $ac_func" >&5
6885 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6886   echo $ac_n "(cached) $ac_c" 1>&6
6887 else
6888   cat > conftest.$ac_ext <<EOF
6889 #line 6890 "configure"
6890 #include "confdefs.h"
6891 /* System header to define __stub macros and hopefully few prototypes,
6892     which can conflict with char $ac_func(); below.  */
6893 #include <assert.h>
6894 /* Override any gcc2 internal prototype to avoid an error.  */
6895 /* We use char because int might match the return type of a gcc2
6896     builtin and then its argument prototype would still apply.  */
6897 char $ac_func();
6898
6899 int main() {
6900
6901 /* The GNU C library defines this for functions which it implements
6902     to always fail with ENOSYS.  Some functions are actually named
6903     something starting with __ and the normal name is an alias.  */
6904 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6905 choke me
6906 #else
6907 $ac_func();
6908 #endif
6909
6910 ; return 0; }
6911 EOF
6912 if { (eval echo configure:6913: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6913   rm -rf conftest*
6914   eval "ac_cv_func_$ac_func=yes"
6915 else
6916   echo "configure: failed program was:" >&5
6917   cat conftest.$ac_ext >&5
6918   rm -rf conftest*
6919   eval "ac_cv_func_$ac_func=no"
6920 fi
6921 rm -f conftest*
6922 fi
6923
6924 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6925   echo "$ac_t""yes" 1>&6
6926     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6927   cat >> confdefs.h <<EOF
6928 #define $ac_tr_func 1
6929 EOF
6930
6931 else
6932   echo "$ac_t""no" 1>&6
6933 fi
6934 done
6935
6936   fi
6937
6938
6939   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6940 echo "configure:6941: checking for ldexpf declaration" >&5
6941   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
6942   echo $ac_n "(cached) $ac_c" 1>&6
6943 else
6944
6945
6946     ac_ext=C
6947 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6948 ac_cpp='$CXXCPP $CPPFLAGS'
6949 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6950 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6951 cross_compiling=$ac_cv_prog_cxx_cross
6952
6953     cat > conftest.$ac_ext <<EOF
6954 #line 6955 "configure"
6955 #include "confdefs.h"
6956 #include <math.h>
6957 int main() {
6958  ldexpf(0, 0);
6959 ; return 0; }
6960 EOF
6961 if { (eval echo configure:6962: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6962   rm -rf conftest*
6963   glibcpp_cv_func_ldexpf_use=yes
6964 else
6965   echo "configure: failed program was:" >&5
6966   cat conftest.$ac_ext >&5
6967   rm -rf conftest*
6968   glibcpp_cv_func_ldexpf_use=no
6969 fi
6970 rm -f conftest*
6971     ac_ext=c
6972 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6973 ac_cpp='$CPP $CPPFLAGS'
6974 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6975 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6976 cross_compiling=$ac_cv_prog_cc_cross
6977
6978
6979 fi
6980
6981   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
6982   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
6983     for ac_func in ldexpf
6984 do
6985 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6986 echo "configure:6987: checking for $ac_func" >&5
6987 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6988   echo $ac_n "(cached) $ac_c" 1>&6
6989 else
6990   cat > conftest.$ac_ext <<EOF
6991 #line 6992 "configure"
6992 #include "confdefs.h"
6993 /* System header to define __stub macros and hopefully few prototypes,
6994     which can conflict with char $ac_func(); below.  */
6995 #include <assert.h>
6996 /* Override any gcc2 internal prototype to avoid an error.  */
6997 /* We use char because int might match the return type of a gcc2
6998     builtin and then its argument prototype would still apply.  */
6999 char $ac_func();
7000
7001 int main() {
7002
7003 /* The GNU C library defines this for functions which it implements
7004     to always fail with ENOSYS.  Some functions are actually named
7005     something starting with __ and the normal name is an alias.  */
7006 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7007 choke me
7008 #else
7009 $ac_func();
7010 #endif
7011
7012 ; return 0; }
7013 EOF
7014 if { (eval echo configure:7015: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7015   rm -rf conftest*
7016   eval "ac_cv_func_$ac_func=yes"
7017 else
7018   echo "configure: failed program was:" >&5
7019   cat conftest.$ac_ext >&5
7020   rm -rf conftest*
7021   eval "ac_cv_func_$ac_func=no"
7022 fi
7023 rm -f conftest*
7024 fi
7025
7026 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7027   echo "$ac_t""yes" 1>&6
7028     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7029   cat >> confdefs.h <<EOF
7030 #define $ac_tr_func 1
7031 EOF
7032
7033 else
7034   echo "$ac_t""no" 1>&6
7035 fi
7036 done
7037
7038   fi
7039
7040
7041   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
7042 echo "configure:7043: checking for logf declaration" >&5
7043   if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
7044   echo $ac_n "(cached) $ac_c" 1>&6
7045 else
7046
7047
7048     ac_ext=C
7049 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7050 ac_cpp='$CXXCPP $CPPFLAGS'
7051 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7052 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7053 cross_compiling=$ac_cv_prog_cxx_cross
7054
7055     cat > conftest.$ac_ext <<EOF
7056 #line 7057 "configure"
7057 #include "confdefs.h"
7058 #include <math.h>
7059 int main() {
7060  logf(0);
7061 ; return 0; }
7062 EOF
7063 if { (eval echo configure:7064: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7064   rm -rf conftest*
7065   glibcpp_cv_func_logf_use=yes
7066 else
7067   echo "configure: failed program was:" >&5
7068   cat conftest.$ac_ext >&5
7069   rm -rf conftest*
7070   glibcpp_cv_func_logf_use=no
7071 fi
7072 rm -f conftest*
7073     ac_ext=c
7074 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7075 ac_cpp='$CPP $CPPFLAGS'
7076 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7077 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7078 cross_compiling=$ac_cv_prog_cc_cross
7079
7080
7081 fi
7082
7083   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
7084   if test x$glibcpp_cv_func_logf_use = x"yes"; then
7085     for ac_func in logf
7086 do
7087 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7088 echo "configure:7089: checking for $ac_func" >&5
7089 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7090   echo $ac_n "(cached) $ac_c" 1>&6
7091 else
7092   cat > conftest.$ac_ext <<EOF
7093 #line 7094 "configure"
7094 #include "confdefs.h"
7095 /* System header to define __stub macros and hopefully few prototypes,
7096     which can conflict with char $ac_func(); below.  */
7097 #include <assert.h>
7098 /* Override any gcc2 internal prototype to avoid an error.  */
7099 /* We use char because int might match the return type of a gcc2
7100     builtin and then its argument prototype would still apply.  */
7101 char $ac_func();
7102
7103 int main() {
7104
7105 /* The GNU C library defines this for functions which it implements
7106     to always fail with ENOSYS.  Some functions are actually named
7107     something starting with __ and the normal name is an alias.  */
7108 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7109 choke me
7110 #else
7111 $ac_func();
7112 #endif
7113
7114 ; return 0; }
7115 EOF
7116 if { (eval echo configure:7117: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7117   rm -rf conftest*
7118   eval "ac_cv_func_$ac_func=yes"
7119 else
7120   echo "configure: failed program was:" >&5
7121   cat conftest.$ac_ext >&5
7122   rm -rf conftest*
7123   eval "ac_cv_func_$ac_func=no"
7124 fi
7125 rm -f conftest*
7126 fi
7127
7128 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7129   echo "$ac_t""yes" 1>&6
7130     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7131   cat >> confdefs.h <<EOF
7132 #define $ac_tr_func 1
7133 EOF
7134
7135 else
7136   echo "$ac_t""no" 1>&6
7137 fi
7138 done
7139
7140   fi
7141
7142
7143   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7144 echo "configure:7145: checking for log10f declaration" >&5
7145   if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
7146   echo $ac_n "(cached) $ac_c" 1>&6
7147 else
7148
7149
7150     ac_ext=C
7151 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7152 ac_cpp='$CXXCPP $CPPFLAGS'
7153 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7154 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7155 cross_compiling=$ac_cv_prog_cxx_cross
7156
7157     cat > conftest.$ac_ext <<EOF
7158 #line 7159 "configure"
7159 #include "confdefs.h"
7160 #include <math.h>
7161 int main() {
7162  log10f(0);
7163 ; return 0; }
7164 EOF
7165 if { (eval echo configure:7166: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7166   rm -rf conftest*
7167   glibcpp_cv_func_log10f_use=yes
7168 else
7169   echo "configure: failed program was:" >&5
7170   cat conftest.$ac_ext >&5
7171   rm -rf conftest*
7172   glibcpp_cv_func_log10f_use=no
7173 fi
7174 rm -f conftest*
7175     ac_ext=c
7176 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7177 ac_cpp='$CPP $CPPFLAGS'
7178 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7179 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7180 cross_compiling=$ac_cv_prog_cc_cross
7181
7182
7183 fi
7184
7185   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
7186   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
7187     for ac_func in log10f
7188 do
7189 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7190 echo "configure:7191: checking for $ac_func" >&5
7191 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7192   echo $ac_n "(cached) $ac_c" 1>&6
7193 else
7194   cat > conftest.$ac_ext <<EOF
7195 #line 7196 "configure"
7196 #include "confdefs.h"
7197 /* System header to define __stub macros and hopefully few prototypes,
7198     which can conflict with char $ac_func(); below.  */
7199 #include <assert.h>
7200 /* Override any gcc2 internal prototype to avoid an error.  */
7201 /* We use char because int might match the return type of a gcc2
7202     builtin and then its argument prototype would still apply.  */
7203 char $ac_func();
7204
7205 int main() {
7206
7207 /* The GNU C library defines this for functions which it implements
7208     to always fail with ENOSYS.  Some functions are actually named
7209     something starting with __ and the normal name is an alias.  */
7210 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7211 choke me
7212 #else
7213 $ac_func();
7214 #endif
7215
7216 ; return 0; }
7217 EOF
7218 if { (eval echo configure:7219: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7219   rm -rf conftest*
7220   eval "ac_cv_func_$ac_func=yes"
7221 else
7222   echo "configure: failed program was:" >&5
7223   cat conftest.$ac_ext >&5
7224   rm -rf conftest*
7225   eval "ac_cv_func_$ac_func=no"
7226 fi
7227 rm -f conftest*
7228 fi
7229
7230 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7231   echo "$ac_t""yes" 1>&6
7232     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7233   cat >> confdefs.h <<EOF
7234 #define $ac_tr_func 1
7235 EOF
7236
7237 else
7238   echo "$ac_t""no" 1>&6
7239 fi
7240 done
7241
7242   fi
7243
7244
7245   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7246 echo "configure:7247: checking for modff declaration" >&5
7247   if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
7248   echo $ac_n "(cached) $ac_c" 1>&6
7249 else
7250
7251
7252     ac_ext=C
7253 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7254 ac_cpp='$CXXCPP $CPPFLAGS'
7255 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7256 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7257 cross_compiling=$ac_cv_prog_cxx_cross
7258
7259     cat > conftest.$ac_ext <<EOF
7260 #line 7261 "configure"
7261 #include "confdefs.h"
7262 #include <math.h>
7263 int main() {
7264  modff(0, 0);
7265 ; return 0; }
7266 EOF
7267 if { (eval echo configure:7268: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7268   rm -rf conftest*
7269   glibcpp_cv_func_modff_use=yes
7270 else
7271   echo "configure: failed program was:" >&5
7272   cat conftest.$ac_ext >&5
7273   rm -rf conftest*
7274   glibcpp_cv_func_modff_use=no
7275 fi
7276 rm -f conftest*
7277     ac_ext=c
7278 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7279 ac_cpp='$CPP $CPPFLAGS'
7280 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7281 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7282 cross_compiling=$ac_cv_prog_cc_cross
7283
7284
7285 fi
7286
7287   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
7288   if test x$glibcpp_cv_func_modff_use = x"yes"; then
7289     for ac_func in modff
7290 do
7291 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7292 echo "configure:7293: checking for $ac_func" >&5
7293 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7294   echo $ac_n "(cached) $ac_c" 1>&6
7295 else
7296   cat > conftest.$ac_ext <<EOF
7297 #line 7298 "configure"
7298 #include "confdefs.h"
7299 /* System header to define __stub macros and hopefully few prototypes,
7300     which can conflict with char $ac_func(); below.  */
7301 #include <assert.h>
7302 /* Override any gcc2 internal prototype to avoid an error.  */
7303 /* We use char because int might match the return type of a gcc2
7304     builtin and then its argument prototype would still apply.  */
7305 char $ac_func();
7306
7307 int main() {
7308
7309 /* The GNU C library defines this for functions which it implements
7310     to always fail with ENOSYS.  Some functions are actually named
7311     something starting with __ and the normal name is an alias.  */
7312 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7313 choke me
7314 #else
7315 $ac_func();
7316 #endif
7317
7318 ; return 0; }
7319 EOF
7320 if { (eval echo configure:7321: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7321   rm -rf conftest*
7322   eval "ac_cv_func_$ac_func=yes"
7323 else
7324   echo "configure: failed program was:" >&5
7325   cat conftest.$ac_ext >&5
7326   rm -rf conftest*
7327   eval "ac_cv_func_$ac_func=no"
7328 fi
7329 rm -f conftest*
7330 fi
7331
7332 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7333   echo "$ac_t""yes" 1>&6
7334     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7335   cat >> confdefs.h <<EOF
7336 #define $ac_tr_func 1
7337 EOF
7338
7339 else
7340   echo "$ac_t""no" 1>&6
7341 fi
7342 done
7343
7344   fi
7345
7346
7347   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
7348 echo "configure:7349: checking for powf declaration" >&5
7349   if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
7350   echo $ac_n "(cached) $ac_c" 1>&6
7351 else
7352
7353
7354     ac_ext=C
7355 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7356 ac_cpp='$CXXCPP $CPPFLAGS'
7357 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7358 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7359 cross_compiling=$ac_cv_prog_cxx_cross
7360
7361     cat > conftest.$ac_ext <<EOF
7362 #line 7363 "configure"
7363 #include "confdefs.h"
7364 #include <math.h>
7365 int main() {
7366  powf(0, 0);
7367 ; return 0; }
7368 EOF
7369 if { (eval echo configure:7370: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7370   rm -rf conftest*
7371   glibcpp_cv_func_powf_use=yes
7372 else
7373   echo "configure: failed program was:" >&5
7374   cat conftest.$ac_ext >&5
7375   rm -rf conftest*
7376   glibcpp_cv_func_powf_use=no
7377 fi
7378 rm -f conftest*
7379     ac_ext=c
7380 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7381 ac_cpp='$CPP $CPPFLAGS'
7382 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7383 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7384 cross_compiling=$ac_cv_prog_cc_cross
7385
7386
7387 fi
7388
7389   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
7390   if test x$glibcpp_cv_func_powf_use = x"yes"; then
7391     for ac_func in powf
7392 do
7393 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7394 echo "configure:7395: checking for $ac_func" >&5
7395 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7396   echo $ac_n "(cached) $ac_c" 1>&6
7397 else
7398   cat > conftest.$ac_ext <<EOF
7399 #line 7400 "configure"
7400 #include "confdefs.h"
7401 /* System header to define __stub macros and hopefully few prototypes,
7402     which can conflict with char $ac_func(); below.  */
7403 #include <assert.h>
7404 /* Override any gcc2 internal prototype to avoid an error.  */
7405 /* We use char because int might match the return type of a gcc2
7406     builtin and then its argument prototype would still apply.  */
7407 char $ac_func();
7408
7409 int main() {
7410
7411 /* The GNU C library defines this for functions which it implements
7412     to always fail with ENOSYS.  Some functions are actually named
7413     something starting with __ and the normal name is an alias.  */
7414 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7415 choke me
7416 #else
7417 $ac_func();
7418 #endif
7419
7420 ; return 0; }
7421 EOF
7422 if { (eval echo configure:7423: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7423   rm -rf conftest*
7424   eval "ac_cv_func_$ac_func=yes"
7425 else
7426   echo "configure: failed program was:" >&5
7427   cat conftest.$ac_ext >&5
7428   rm -rf conftest*
7429   eval "ac_cv_func_$ac_func=no"
7430 fi
7431 rm -f conftest*
7432 fi
7433
7434 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7435   echo "$ac_t""yes" 1>&6
7436     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7437   cat >> confdefs.h <<EOF
7438 #define $ac_tr_func 1
7439 EOF
7440
7441 else
7442   echo "$ac_t""no" 1>&6
7443 fi
7444 done
7445
7446   fi
7447
7448
7449   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
7450 echo "configure:7451: checking for sinf declaration" >&5
7451   if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
7452   echo $ac_n "(cached) $ac_c" 1>&6
7453 else
7454
7455
7456     ac_ext=C
7457 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7458 ac_cpp='$CXXCPP $CPPFLAGS'
7459 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7460 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7461 cross_compiling=$ac_cv_prog_cxx_cross
7462
7463     cat > conftest.$ac_ext <<EOF
7464 #line 7465 "configure"
7465 #include "confdefs.h"
7466 #include <math.h>
7467 int main() {
7468  sinf(0);
7469 ; return 0; }
7470 EOF
7471 if { (eval echo configure:7472: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7472   rm -rf conftest*
7473   glibcpp_cv_func_sinf_use=yes
7474 else
7475   echo "configure: failed program was:" >&5
7476   cat conftest.$ac_ext >&5
7477   rm -rf conftest*
7478   glibcpp_cv_func_sinf_use=no
7479 fi
7480 rm -f conftest*
7481     ac_ext=c
7482 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7483 ac_cpp='$CPP $CPPFLAGS'
7484 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7485 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7486 cross_compiling=$ac_cv_prog_cc_cross
7487
7488
7489 fi
7490
7491   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
7492   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
7493     for ac_func in sinf
7494 do
7495 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7496 echo "configure:7497: checking for $ac_func" >&5
7497 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7498   echo $ac_n "(cached) $ac_c" 1>&6
7499 else
7500   cat > conftest.$ac_ext <<EOF
7501 #line 7502 "configure"
7502 #include "confdefs.h"
7503 /* System header to define __stub macros and hopefully few prototypes,
7504     which can conflict with char $ac_func(); below.  */
7505 #include <assert.h>
7506 /* Override any gcc2 internal prototype to avoid an error.  */
7507 /* We use char because int might match the return type of a gcc2
7508     builtin and then its argument prototype would still apply.  */
7509 char $ac_func();
7510
7511 int main() {
7512
7513 /* The GNU C library defines this for functions which it implements
7514     to always fail with ENOSYS.  Some functions are actually named
7515     something starting with __ and the normal name is an alias.  */
7516 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7517 choke me
7518 #else
7519 $ac_func();
7520 #endif
7521
7522 ; return 0; }
7523 EOF
7524 if { (eval echo configure:7525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7525   rm -rf conftest*
7526   eval "ac_cv_func_$ac_func=yes"
7527 else
7528   echo "configure: failed program was:" >&5
7529   cat conftest.$ac_ext >&5
7530   rm -rf conftest*
7531   eval "ac_cv_func_$ac_func=no"
7532 fi
7533 rm -f conftest*
7534 fi
7535
7536 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7537   echo "$ac_t""yes" 1>&6
7538     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7539   cat >> confdefs.h <<EOF
7540 #define $ac_tr_func 1
7541 EOF
7542
7543 else
7544   echo "$ac_t""no" 1>&6
7545 fi
7546 done
7547
7548   fi
7549
7550
7551   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
7552 echo "configure:7553: checking for sinhf declaration" >&5
7553   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
7554   echo $ac_n "(cached) $ac_c" 1>&6
7555 else
7556
7557
7558     ac_ext=C
7559 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7560 ac_cpp='$CXXCPP $CPPFLAGS'
7561 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7562 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7563 cross_compiling=$ac_cv_prog_cxx_cross
7564
7565     cat > conftest.$ac_ext <<EOF
7566 #line 7567 "configure"
7567 #include "confdefs.h"
7568 #include <math.h>
7569 int main() {
7570  sinhf(0);
7571 ; return 0; }
7572 EOF
7573 if { (eval echo configure:7574: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7574   rm -rf conftest*
7575   glibcpp_cv_func_sinhf_use=yes
7576 else
7577   echo "configure: failed program was:" >&5
7578   cat conftest.$ac_ext >&5
7579   rm -rf conftest*
7580   glibcpp_cv_func_sinhf_use=no
7581 fi
7582 rm -f conftest*
7583     ac_ext=c
7584 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7585 ac_cpp='$CPP $CPPFLAGS'
7586 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7587 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7588 cross_compiling=$ac_cv_prog_cc_cross
7589
7590
7591 fi
7592
7593   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
7594   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
7595     for ac_func in sinhf
7596 do
7597 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7598 echo "configure:7599: checking for $ac_func" >&5
7599 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7600   echo $ac_n "(cached) $ac_c" 1>&6
7601 else
7602   cat > conftest.$ac_ext <<EOF
7603 #line 7604 "configure"
7604 #include "confdefs.h"
7605 /* System header to define __stub macros and hopefully few prototypes,
7606     which can conflict with char $ac_func(); below.  */
7607 #include <assert.h>
7608 /* Override any gcc2 internal prototype to avoid an error.  */
7609 /* We use char because int might match the return type of a gcc2
7610     builtin and then its argument prototype would still apply.  */
7611 char $ac_func();
7612
7613 int main() {
7614
7615 /* The GNU C library defines this for functions which it implements
7616     to always fail with ENOSYS.  Some functions are actually named
7617     something starting with __ and the normal name is an alias.  */
7618 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7619 choke me
7620 #else
7621 $ac_func();
7622 #endif
7623
7624 ; return 0; }
7625 EOF
7626 if { (eval echo configure:7627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7627   rm -rf conftest*
7628   eval "ac_cv_func_$ac_func=yes"
7629 else
7630   echo "configure: failed program was:" >&5
7631   cat conftest.$ac_ext >&5
7632   rm -rf conftest*
7633   eval "ac_cv_func_$ac_func=no"
7634 fi
7635 rm -f conftest*
7636 fi
7637
7638 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7639   echo "$ac_t""yes" 1>&6
7640     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7641   cat >> confdefs.h <<EOF
7642 #define $ac_tr_func 1
7643 EOF
7644
7645 else
7646   echo "$ac_t""no" 1>&6
7647 fi
7648 done
7649
7650   fi
7651
7652
7653   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
7654 echo "configure:7655: checking for sqrtf declaration" >&5
7655   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
7656   echo $ac_n "(cached) $ac_c" 1>&6
7657 else
7658
7659
7660     ac_ext=C
7661 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7662 ac_cpp='$CXXCPP $CPPFLAGS'
7663 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7664 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7665 cross_compiling=$ac_cv_prog_cxx_cross
7666
7667     cat > conftest.$ac_ext <<EOF
7668 #line 7669 "configure"
7669 #include "confdefs.h"
7670 #include <math.h>
7671 int main() {
7672  sqrtf(0);
7673 ; return 0; }
7674 EOF
7675 if { (eval echo configure:7676: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7676   rm -rf conftest*
7677   glibcpp_cv_func_sqrtf_use=yes
7678 else
7679   echo "configure: failed program was:" >&5
7680   cat conftest.$ac_ext >&5
7681   rm -rf conftest*
7682   glibcpp_cv_func_sqrtf_use=no
7683 fi
7684 rm -f conftest*
7685     ac_ext=c
7686 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7687 ac_cpp='$CPP $CPPFLAGS'
7688 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7689 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7690 cross_compiling=$ac_cv_prog_cc_cross
7691
7692
7693 fi
7694
7695   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
7696   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
7697     for ac_func in sqrtf
7698 do
7699 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7700 echo "configure:7701: checking for $ac_func" >&5
7701 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7702   echo $ac_n "(cached) $ac_c" 1>&6
7703 else
7704   cat > conftest.$ac_ext <<EOF
7705 #line 7706 "configure"
7706 #include "confdefs.h"
7707 /* System header to define __stub macros and hopefully few prototypes,
7708     which can conflict with char $ac_func(); below.  */
7709 #include <assert.h>
7710 /* Override any gcc2 internal prototype to avoid an error.  */
7711 /* We use char because int might match the return type of a gcc2
7712     builtin and then its argument prototype would still apply.  */
7713 char $ac_func();
7714
7715 int main() {
7716
7717 /* The GNU C library defines this for functions which it implements
7718     to always fail with ENOSYS.  Some functions are actually named
7719     something starting with __ and the normal name is an alias.  */
7720 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7721 choke me
7722 #else
7723 $ac_func();
7724 #endif
7725
7726 ; return 0; }
7727 EOF
7728 if { (eval echo configure:7729: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7729   rm -rf conftest*
7730   eval "ac_cv_func_$ac_func=yes"
7731 else
7732   echo "configure: failed program was:" >&5
7733   cat conftest.$ac_ext >&5
7734   rm -rf conftest*
7735   eval "ac_cv_func_$ac_func=no"
7736 fi
7737 rm -f conftest*
7738 fi
7739
7740 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7741   echo "$ac_t""yes" 1>&6
7742     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7743   cat >> confdefs.h <<EOF
7744 #define $ac_tr_func 1
7745 EOF
7746
7747 else
7748   echo "$ac_t""no" 1>&6
7749 fi
7750 done
7751
7752   fi
7753
7754
7755   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
7756 echo "configure:7757: checking for tanf declaration" >&5
7757   if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
7758   echo $ac_n "(cached) $ac_c" 1>&6
7759 else
7760
7761
7762     ac_ext=C
7763 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7764 ac_cpp='$CXXCPP $CPPFLAGS'
7765 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7766 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7767 cross_compiling=$ac_cv_prog_cxx_cross
7768
7769     cat > conftest.$ac_ext <<EOF
7770 #line 7771 "configure"
7771 #include "confdefs.h"
7772 #include <math.h>
7773 int main() {
7774  tanf(0);
7775 ; return 0; }
7776 EOF
7777 if { (eval echo configure:7778: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7778   rm -rf conftest*
7779   glibcpp_cv_func_tanf_use=yes
7780 else
7781   echo "configure: failed program was:" >&5
7782   cat conftest.$ac_ext >&5
7783   rm -rf conftest*
7784   glibcpp_cv_func_tanf_use=no
7785 fi
7786 rm -f conftest*
7787     ac_ext=c
7788 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7789 ac_cpp='$CPP $CPPFLAGS'
7790 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7791 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7792 cross_compiling=$ac_cv_prog_cc_cross
7793
7794
7795 fi
7796
7797   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
7798   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
7799     for ac_func in tanf
7800 do
7801 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7802 echo "configure:7803: checking for $ac_func" >&5
7803 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7804   echo $ac_n "(cached) $ac_c" 1>&6
7805 else
7806   cat > conftest.$ac_ext <<EOF
7807 #line 7808 "configure"
7808 #include "confdefs.h"
7809 /* System header to define __stub macros and hopefully few prototypes,
7810     which can conflict with char $ac_func(); below.  */
7811 #include <assert.h>
7812 /* Override any gcc2 internal prototype to avoid an error.  */
7813 /* We use char because int might match the return type of a gcc2
7814     builtin and then its argument prototype would still apply.  */
7815 char $ac_func();
7816
7817 int main() {
7818
7819 /* The GNU C library defines this for functions which it implements
7820     to always fail with ENOSYS.  Some functions are actually named
7821     something starting with __ and the normal name is an alias.  */
7822 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7823 choke me
7824 #else
7825 $ac_func();
7826 #endif
7827
7828 ; return 0; }
7829 EOF
7830 if { (eval echo configure:7831: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7831   rm -rf conftest*
7832   eval "ac_cv_func_$ac_func=yes"
7833 else
7834   echo "configure: failed program was:" >&5
7835   cat conftest.$ac_ext >&5
7836   rm -rf conftest*
7837   eval "ac_cv_func_$ac_func=no"
7838 fi
7839 rm -f conftest*
7840 fi
7841
7842 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7843   echo "$ac_t""yes" 1>&6
7844     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7845   cat >> confdefs.h <<EOF
7846 #define $ac_tr_func 1
7847 EOF
7848
7849 else
7850   echo "$ac_t""no" 1>&6
7851 fi
7852 done
7853
7854   fi
7855
7856
7857   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
7858 echo "configure:7859: checking for tanhf declaration" >&5
7859   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
7860   echo $ac_n "(cached) $ac_c" 1>&6
7861 else
7862
7863
7864     ac_ext=C
7865 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7866 ac_cpp='$CXXCPP $CPPFLAGS'
7867 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7868 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7869 cross_compiling=$ac_cv_prog_cxx_cross
7870
7871     cat > conftest.$ac_ext <<EOF
7872 #line 7873 "configure"
7873 #include "confdefs.h"
7874 #include <math.h>
7875 int main() {
7876  tanhf(0);
7877 ; return 0; }
7878 EOF
7879 if { (eval echo configure:7880: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7880   rm -rf conftest*
7881   glibcpp_cv_func_tanhf_use=yes
7882 else
7883   echo "configure: failed program was:" >&5
7884   cat conftest.$ac_ext >&5
7885   rm -rf conftest*
7886   glibcpp_cv_func_tanhf_use=no
7887 fi
7888 rm -f conftest*
7889     ac_ext=c
7890 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7891 ac_cpp='$CPP $CPPFLAGS'
7892 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7893 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7894 cross_compiling=$ac_cv_prog_cc_cross
7895
7896
7897 fi
7898
7899   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
7900   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
7901     for ac_func in tanhf
7902 do
7903 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7904 echo "configure:7905: checking for $ac_func" >&5
7905 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7906   echo $ac_n "(cached) $ac_c" 1>&6
7907 else
7908   cat > conftest.$ac_ext <<EOF
7909 #line 7910 "configure"
7910 #include "confdefs.h"
7911 /* System header to define __stub macros and hopefully few prototypes,
7912     which can conflict with char $ac_func(); below.  */
7913 #include <assert.h>
7914 /* Override any gcc2 internal prototype to avoid an error.  */
7915 /* We use char because int might match the return type of a gcc2
7916     builtin and then its argument prototype would still apply.  */
7917 char $ac_func();
7918
7919 int main() {
7920
7921 /* The GNU C library defines this for functions which it implements
7922     to always fail with ENOSYS.  Some functions are actually named
7923     something starting with __ and the normal name is an alias.  */
7924 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7925 choke me
7926 #else
7927 $ac_func();
7928 #endif
7929
7930 ; return 0; }
7931 EOF
7932 if { (eval echo configure:7933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7933   rm -rf conftest*
7934   eval "ac_cv_func_$ac_func=yes"
7935 else
7936   echo "configure: failed program was:" >&5
7937   cat conftest.$ac_ext >&5
7938   rm -rf conftest*
7939   eval "ac_cv_func_$ac_func=no"
7940 fi
7941 rm -f conftest*
7942 fi
7943
7944 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7945   echo "$ac_t""yes" 1>&6
7946     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7947   cat >> confdefs.h <<EOF
7948 #define $ac_tr_func 1
7949 EOF
7950
7951 else
7952   echo "$ac_t""no" 1>&6
7953 fi
7954 done
7955
7956   fi
7957
7958
7959   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7960 echo "configure:7961: checking for sincosf declaration" >&5
7961   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
7962   echo $ac_n "(cached) $ac_c" 1>&6
7963 else
7964
7965
7966     ac_ext=C
7967 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7968 ac_cpp='$CXXCPP $CPPFLAGS'
7969 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7970 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7971 cross_compiling=$ac_cv_prog_cxx_cross
7972
7973     cat > conftest.$ac_ext <<EOF
7974 #line 7975 "configure"
7975 #include "confdefs.h"
7976 #include <math.h>
7977 int main() {
7978  sincosf(0, 0, 0);
7979 ; return 0; }
7980 EOF
7981 if { (eval echo configure:7982: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7982   rm -rf conftest*
7983   glibcpp_cv_func_sincosf_use=yes
7984 else
7985   echo "configure: failed program was:" >&5
7986   cat conftest.$ac_ext >&5
7987   rm -rf conftest*
7988   glibcpp_cv_func_sincosf_use=no
7989 fi
7990 rm -f conftest*
7991     ac_ext=c
7992 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7993 ac_cpp='$CPP $CPPFLAGS'
7994 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7995 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7996 cross_compiling=$ac_cv_prog_cc_cross
7997
7998
7999 fi
8000
8001   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
8002   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
8003     for ac_func in sincosf
8004 do
8005 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8006 echo "configure:8007: checking for $ac_func" >&5
8007 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8008   echo $ac_n "(cached) $ac_c" 1>&6
8009 else
8010   cat > conftest.$ac_ext <<EOF
8011 #line 8012 "configure"
8012 #include "confdefs.h"
8013 /* System header to define __stub macros and hopefully few prototypes,
8014     which can conflict with char $ac_func(); below.  */
8015 #include <assert.h>
8016 /* Override any gcc2 internal prototype to avoid an error.  */
8017 /* We use char because int might match the return type of a gcc2
8018     builtin and then its argument prototype would still apply.  */
8019 char $ac_func();
8020
8021 int main() {
8022
8023 /* The GNU C library defines this for functions which it implements
8024     to always fail with ENOSYS.  Some functions are actually named
8025     something starting with __ and the normal name is an alias.  */
8026 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8027 choke me
8028 #else
8029 $ac_func();
8030 #endif
8031
8032 ; return 0; }
8033 EOF
8034 if { (eval echo configure:8035: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8035   rm -rf conftest*
8036   eval "ac_cv_func_$ac_func=yes"
8037 else
8038   echo "configure: failed program was:" >&5
8039   cat conftest.$ac_ext >&5
8040   rm -rf conftest*
8041   eval "ac_cv_func_$ac_func=no"
8042 fi
8043 rm -f conftest*
8044 fi
8045
8046 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8047   echo "$ac_t""yes" 1>&6
8048     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8049   cat >> confdefs.h <<EOF
8050 #define $ac_tr_func 1
8051 EOF
8052
8053 else
8054   echo "$ac_t""no" 1>&6
8055 fi
8056 done
8057
8058   fi
8059
8060
8061   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
8062 echo "configure:8063: checking for finitef declaration" >&5
8063   if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
8064   echo $ac_n "(cached) $ac_c" 1>&6
8065 else
8066
8067
8068     ac_ext=C
8069 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8070 ac_cpp='$CXXCPP $CPPFLAGS'
8071 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8072 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8073 cross_compiling=$ac_cv_prog_cxx_cross
8074
8075     cat > conftest.$ac_ext <<EOF
8076 #line 8077 "configure"
8077 #include "confdefs.h"
8078 #include <math.h>
8079 int main() {
8080  finitef(0);
8081 ; return 0; }
8082 EOF
8083 if { (eval echo configure:8084: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8084   rm -rf conftest*
8085   glibcpp_cv_func_finitef_use=yes
8086 else
8087   echo "configure: failed program was:" >&5
8088   cat conftest.$ac_ext >&5
8089   rm -rf conftest*
8090   glibcpp_cv_func_finitef_use=no
8091 fi
8092 rm -f conftest*
8093     ac_ext=c
8094 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8095 ac_cpp='$CPP $CPPFLAGS'
8096 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8097 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8098 cross_compiling=$ac_cv_prog_cc_cross
8099
8100
8101 fi
8102
8103   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
8104   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
8105     for ac_func in finitef
8106 do
8107 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8108 echo "configure:8109: checking for $ac_func" >&5
8109 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8110   echo $ac_n "(cached) $ac_c" 1>&6
8111 else
8112   cat > conftest.$ac_ext <<EOF
8113 #line 8114 "configure"
8114 #include "confdefs.h"
8115 /* System header to define __stub macros and hopefully few prototypes,
8116     which can conflict with char $ac_func(); below.  */
8117 #include <assert.h>
8118 /* Override any gcc2 internal prototype to avoid an error.  */
8119 /* We use char because int might match the return type of a gcc2
8120     builtin and then its argument prototype would still apply.  */
8121 char $ac_func();
8122
8123 int main() {
8124
8125 /* The GNU C library defines this for functions which it implements
8126     to always fail with ENOSYS.  Some functions are actually named
8127     something starting with __ and the normal name is an alias.  */
8128 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8129 choke me
8130 #else
8131 $ac_func();
8132 #endif
8133
8134 ; return 0; }
8135 EOF
8136 if { (eval echo configure:8137: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8137   rm -rf conftest*
8138   eval "ac_cv_func_$ac_func=yes"
8139 else
8140   echo "configure: failed program was:" >&5
8141   cat conftest.$ac_ext >&5
8142   rm -rf conftest*
8143   eval "ac_cv_func_$ac_func=no"
8144 fi
8145 rm -f conftest*
8146 fi
8147
8148 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8149   echo "$ac_t""yes" 1>&6
8150     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8151   cat >> confdefs.h <<EOF
8152 #define $ac_tr_func 1
8153 EOF
8154
8155 else
8156   echo "$ac_t""no" 1>&6
8157 fi
8158 done
8159
8160   fi
8161
8162
8163
8164   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8165 echo "configure:8166: checking for isnanl declaration" >&5
8166   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
8167   echo $ac_n "(cached) $ac_c" 1>&6
8168 else
8169
8170
8171     ac_ext=C
8172 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8173 ac_cpp='$CXXCPP $CPPFLAGS'
8174 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8175 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8176 cross_compiling=$ac_cv_prog_cxx_cross
8177
8178     cat > conftest.$ac_ext <<EOF
8179 #line 8180 "configure"
8180 #include "confdefs.h"
8181 #include <math.h>
8182 int main() {
8183  isnanl(0);
8184 ; return 0; }
8185 EOF
8186 if { (eval echo configure:8187: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8187   rm -rf conftest*
8188   glibcpp_cv_func_isnanl_use=yes
8189 else
8190   echo "configure: failed program was:" >&5
8191   cat conftest.$ac_ext >&5
8192   rm -rf conftest*
8193   glibcpp_cv_func_isnanl_use=no
8194 fi
8195 rm -f conftest*
8196     ac_ext=c
8197 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8198 ac_cpp='$CPP $CPPFLAGS'
8199 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8200 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8201 cross_compiling=$ac_cv_prog_cc_cross
8202
8203
8204 fi
8205
8206   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
8207   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
8208     for ac_func in isnanl
8209 do
8210 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8211 echo "configure:8212: checking for $ac_func" >&5
8212 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8213   echo $ac_n "(cached) $ac_c" 1>&6
8214 else
8215   cat > conftest.$ac_ext <<EOF
8216 #line 8217 "configure"
8217 #include "confdefs.h"
8218 /* System header to define __stub macros and hopefully few prototypes,
8219     which can conflict with char $ac_func(); below.  */
8220 #include <assert.h>
8221 /* Override any gcc2 internal prototype to avoid an error.  */
8222 /* We use char because int might match the return type of a gcc2
8223     builtin and then its argument prototype would still apply.  */
8224 char $ac_func();
8225
8226 int main() {
8227
8228 /* The GNU C library defines this for functions which it implements
8229     to always fail with ENOSYS.  Some functions are actually named
8230     something starting with __ and the normal name is an alias.  */
8231 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8232 choke me
8233 #else
8234 $ac_func();
8235 #endif
8236
8237 ; return 0; }
8238 EOF
8239 if { (eval echo configure:8240: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8240   rm -rf conftest*
8241   eval "ac_cv_func_$ac_func=yes"
8242 else
8243   echo "configure: failed program was:" >&5
8244   cat conftest.$ac_ext >&5
8245   rm -rf conftest*
8246   eval "ac_cv_func_$ac_func=no"
8247 fi
8248 rm -f conftest*
8249 fi
8250
8251 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8252   echo "$ac_t""yes" 1>&6
8253     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8254   cat >> confdefs.h <<EOF
8255 #define $ac_tr_func 1
8256 EOF
8257
8258 else
8259   echo "$ac_t""no" 1>&6
8260 fi
8261 done
8262
8263   fi
8264
8265
8266   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8267 echo "configure:8268: checking for isinfl declaration" >&5
8268   if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
8269   echo $ac_n "(cached) $ac_c" 1>&6
8270 else
8271
8272
8273     ac_ext=C
8274 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8275 ac_cpp='$CXXCPP $CPPFLAGS'
8276 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8277 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8278 cross_compiling=$ac_cv_prog_cxx_cross
8279
8280     cat > conftest.$ac_ext <<EOF
8281 #line 8282 "configure"
8282 #include "confdefs.h"
8283 #include <math.h>
8284 int main() {
8285  isinfl(0);
8286 ; return 0; }
8287 EOF
8288 if { (eval echo configure:8289: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8289   rm -rf conftest*
8290   glibcpp_cv_func_isinfl_use=yes
8291 else
8292   echo "configure: failed program was:" >&5
8293   cat conftest.$ac_ext >&5
8294   rm -rf conftest*
8295   glibcpp_cv_func_isinfl_use=no
8296 fi
8297 rm -f conftest*
8298     ac_ext=c
8299 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8300 ac_cpp='$CPP $CPPFLAGS'
8301 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8302 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8303 cross_compiling=$ac_cv_prog_cc_cross
8304
8305
8306 fi
8307
8308   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
8309   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
8310     for ac_func in isinfl
8311 do
8312 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8313 echo "configure:8314: checking for $ac_func" >&5
8314 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8315   echo $ac_n "(cached) $ac_c" 1>&6
8316 else
8317   cat > conftest.$ac_ext <<EOF
8318 #line 8319 "configure"
8319 #include "confdefs.h"
8320 /* System header to define __stub macros and hopefully few prototypes,
8321     which can conflict with char $ac_func(); below.  */
8322 #include <assert.h>
8323 /* Override any gcc2 internal prototype to avoid an error.  */
8324 /* We use char because int might match the return type of a gcc2
8325     builtin and then its argument prototype would still apply.  */
8326 char $ac_func();
8327
8328 int main() {
8329
8330 /* The GNU C library defines this for functions which it implements
8331     to always fail with ENOSYS.  Some functions are actually named
8332     something starting with __ and the normal name is an alias.  */
8333 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8334 choke me
8335 #else
8336 $ac_func();
8337 #endif
8338
8339 ; return 0; }
8340 EOF
8341 if { (eval echo configure:8342: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8342   rm -rf conftest*
8343   eval "ac_cv_func_$ac_func=yes"
8344 else
8345   echo "configure: failed program was:" >&5
8346   cat conftest.$ac_ext >&5
8347   rm -rf conftest*
8348   eval "ac_cv_func_$ac_func=no"
8349 fi
8350 rm -f conftest*
8351 fi
8352
8353 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8354   echo "$ac_t""yes" 1>&6
8355     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8356   cat >> confdefs.h <<EOF
8357 #define $ac_tr_func 1
8358 EOF
8359
8360 else
8361   echo "$ac_t""no" 1>&6
8362 fi
8363 done
8364
8365   fi
8366
8367
8368   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8369 echo "configure:8370: checking for copysignl declaration" >&5
8370   if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
8371   echo $ac_n "(cached) $ac_c" 1>&6
8372 else
8373
8374
8375     ac_ext=C
8376 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8377 ac_cpp='$CXXCPP $CPPFLAGS'
8378 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8379 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8380 cross_compiling=$ac_cv_prog_cxx_cross
8381
8382     cat > conftest.$ac_ext <<EOF
8383 #line 8384 "configure"
8384 #include "confdefs.h"
8385 #include <math.h>
8386 int main() {
8387  copysignl(0, 0);
8388 ; return 0; }
8389 EOF
8390 if { (eval echo configure:8391: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8391   rm -rf conftest*
8392   glibcpp_cv_func_copysignl_use=yes
8393 else
8394   echo "configure: failed program was:" >&5
8395   cat conftest.$ac_ext >&5
8396   rm -rf conftest*
8397   glibcpp_cv_func_copysignl_use=no
8398 fi
8399 rm -f conftest*
8400     ac_ext=c
8401 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8402 ac_cpp='$CPP $CPPFLAGS'
8403 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8404 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8405 cross_compiling=$ac_cv_prog_cc_cross
8406
8407
8408 fi
8409
8410   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
8411   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
8412     for ac_func in copysignl
8413 do
8414 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8415 echo "configure:8416: checking for $ac_func" >&5
8416 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8417   echo $ac_n "(cached) $ac_c" 1>&6
8418 else
8419   cat > conftest.$ac_ext <<EOF
8420 #line 8421 "configure"
8421 #include "confdefs.h"
8422 /* System header to define __stub macros and hopefully few prototypes,
8423     which can conflict with char $ac_func(); below.  */
8424 #include <assert.h>
8425 /* Override any gcc2 internal prototype to avoid an error.  */
8426 /* We use char because int might match the return type of a gcc2
8427     builtin and then its argument prototype would still apply.  */
8428 char $ac_func();
8429
8430 int main() {
8431
8432 /* The GNU C library defines this for functions which it implements
8433     to always fail with ENOSYS.  Some functions are actually named
8434     something starting with __ and the normal name is an alias.  */
8435 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8436 choke me
8437 #else
8438 $ac_func();
8439 #endif
8440
8441 ; return 0; }
8442 EOF
8443 if { (eval echo configure:8444: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8444   rm -rf conftest*
8445   eval "ac_cv_func_$ac_func=yes"
8446 else
8447   echo "configure: failed program was:" >&5
8448   cat conftest.$ac_ext >&5
8449   rm -rf conftest*
8450   eval "ac_cv_func_$ac_func=no"
8451 fi
8452 rm -f conftest*
8453 fi
8454
8455 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8456   echo "$ac_t""yes" 1>&6
8457     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8458   cat >> confdefs.h <<EOF
8459 #define $ac_tr_func 1
8460 EOF
8461
8462 else
8463   echo "$ac_t""no" 1>&6
8464 fi
8465 done
8466
8467   fi
8468
8469
8470   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8471 echo "configure:8472: checking for acosl declaration" >&5
8472   if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
8473   echo $ac_n "(cached) $ac_c" 1>&6
8474 else
8475
8476
8477     ac_ext=C
8478 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8479 ac_cpp='$CXXCPP $CPPFLAGS'
8480 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8481 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8482 cross_compiling=$ac_cv_prog_cxx_cross
8483
8484     cat > conftest.$ac_ext <<EOF
8485 #line 8486 "configure"
8486 #include "confdefs.h"
8487 #include <math.h>
8488 int main() {
8489  acosl(0);
8490 ; return 0; }
8491 EOF
8492 if { (eval echo configure:8493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8493   rm -rf conftest*
8494   glibcpp_cv_func_acosl_use=yes
8495 else
8496   echo "configure: failed program was:" >&5
8497   cat conftest.$ac_ext >&5
8498   rm -rf conftest*
8499   glibcpp_cv_func_acosl_use=no
8500 fi
8501 rm -f conftest*
8502     ac_ext=c
8503 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8504 ac_cpp='$CPP $CPPFLAGS'
8505 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8506 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8507 cross_compiling=$ac_cv_prog_cc_cross
8508
8509
8510 fi
8511
8512   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
8513   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
8514     for ac_func in acosl
8515 do
8516 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8517 echo "configure:8518: checking for $ac_func" >&5
8518 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8519   echo $ac_n "(cached) $ac_c" 1>&6
8520 else
8521   cat > conftest.$ac_ext <<EOF
8522 #line 8523 "configure"
8523 #include "confdefs.h"
8524 /* System header to define __stub macros and hopefully few prototypes,
8525     which can conflict with char $ac_func(); below.  */
8526 #include <assert.h>
8527 /* Override any gcc2 internal prototype to avoid an error.  */
8528 /* We use char because int might match the return type of a gcc2
8529     builtin and then its argument prototype would still apply.  */
8530 char $ac_func();
8531
8532 int main() {
8533
8534 /* The GNU C library defines this for functions which it implements
8535     to always fail with ENOSYS.  Some functions are actually named
8536     something starting with __ and the normal name is an alias.  */
8537 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8538 choke me
8539 #else
8540 $ac_func();
8541 #endif
8542
8543 ; return 0; }
8544 EOF
8545 if { (eval echo configure:8546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8546   rm -rf conftest*
8547   eval "ac_cv_func_$ac_func=yes"
8548 else
8549   echo "configure: failed program was:" >&5
8550   cat conftest.$ac_ext >&5
8551   rm -rf conftest*
8552   eval "ac_cv_func_$ac_func=no"
8553 fi
8554 rm -f conftest*
8555 fi
8556
8557 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8558   echo "$ac_t""yes" 1>&6
8559     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8560   cat >> confdefs.h <<EOF
8561 #define $ac_tr_func 1
8562 EOF
8563
8564 else
8565   echo "$ac_t""no" 1>&6
8566 fi
8567 done
8568
8569   fi
8570
8571
8572   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8573 echo "configure:8574: checking for asinl declaration" >&5
8574   if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
8575   echo $ac_n "(cached) $ac_c" 1>&6
8576 else
8577
8578
8579     ac_ext=C
8580 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8581 ac_cpp='$CXXCPP $CPPFLAGS'
8582 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8583 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8584 cross_compiling=$ac_cv_prog_cxx_cross
8585
8586     cat > conftest.$ac_ext <<EOF
8587 #line 8588 "configure"
8588 #include "confdefs.h"
8589 #include <math.h>
8590 int main() {
8591  asinl(0);
8592 ; return 0; }
8593 EOF
8594 if { (eval echo configure:8595: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8595   rm -rf conftest*
8596   glibcpp_cv_func_asinl_use=yes
8597 else
8598   echo "configure: failed program was:" >&5
8599   cat conftest.$ac_ext >&5
8600   rm -rf conftest*
8601   glibcpp_cv_func_asinl_use=no
8602 fi
8603 rm -f conftest*
8604     ac_ext=c
8605 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8606 ac_cpp='$CPP $CPPFLAGS'
8607 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8608 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8609 cross_compiling=$ac_cv_prog_cc_cross
8610
8611
8612 fi
8613
8614   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
8615   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
8616     for ac_func in asinl
8617 do
8618 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8619 echo "configure:8620: checking for $ac_func" >&5
8620 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8621   echo $ac_n "(cached) $ac_c" 1>&6
8622 else
8623   cat > conftest.$ac_ext <<EOF
8624 #line 8625 "configure"
8625 #include "confdefs.h"
8626 /* System header to define __stub macros and hopefully few prototypes,
8627     which can conflict with char $ac_func(); below.  */
8628 #include <assert.h>
8629 /* Override any gcc2 internal prototype to avoid an error.  */
8630 /* We use char because int might match the return type of a gcc2
8631     builtin and then its argument prototype would still apply.  */
8632 char $ac_func();
8633
8634 int main() {
8635
8636 /* The GNU C library defines this for functions which it implements
8637     to always fail with ENOSYS.  Some functions are actually named
8638     something starting with __ and the normal name is an alias.  */
8639 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8640 choke me
8641 #else
8642 $ac_func();
8643 #endif
8644
8645 ; return 0; }
8646 EOF
8647 if { (eval echo configure:8648: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8648   rm -rf conftest*
8649   eval "ac_cv_func_$ac_func=yes"
8650 else
8651   echo "configure: failed program was:" >&5
8652   cat conftest.$ac_ext >&5
8653   rm -rf conftest*
8654   eval "ac_cv_func_$ac_func=no"
8655 fi
8656 rm -f conftest*
8657 fi
8658
8659 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8660   echo "$ac_t""yes" 1>&6
8661     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8662   cat >> confdefs.h <<EOF
8663 #define $ac_tr_func 1
8664 EOF
8665
8666 else
8667   echo "$ac_t""no" 1>&6
8668 fi
8669 done
8670
8671   fi
8672
8673
8674   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8675 echo "configure:8676: checking for atanl declaration" >&5
8676   if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
8677   echo $ac_n "(cached) $ac_c" 1>&6
8678 else
8679
8680
8681     ac_ext=C
8682 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8683 ac_cpp='$CXXCPP $CPPFLAGS'
8684 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8685 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8686 cross_compiling=$ac_cv_prog_cxx_cross
8687
8688     cat > conftest.$ac_ext <<EOF
8689 #line 8690 "configure"
8690 #include "confdefs.h"
8691 #include <math.h>
8692 int main() {
8693  atanl(0);
8694 ; return 0; }
8695 EOF
8696 if { (eval echo configure:8697: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8697   rm -rf conftest*
8698   glibcpp_cv_func_atanl_use=yes
8699 else
8700   echo "configure: failed program was:" >&5
8701   cat conftest.$ac_ext >&5
8702   rm -rf conftest*
8703   glibcpp_cv_func_atanl_use=no
8704 fi
8705 rm -f conftest*
8706     ac_ext=c
8707 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8708 ac_cpp='$CPP $CPPFLAGS'
8709 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8710 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8711 cross_compiling=$ac_cv_prog_cc_cross
8712
8713
8714 fi
8715
8716   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
8717   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
8718     for ac_func in atanl
8719 do
8720 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8721 echo "configure:8722: checking for $ac_func" >&5
8722 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8723   echo $ac_n "(cached) $ac_c" 1>&6
8724 else
8725   cat > conftest.$ac_ext <<EOF
8726 #line 8727 "configure"
8727 #include "confdefs.h"
8728 /* System header to define __stub macros and hopefully few prototypes,
8729     which can conflict with char $ac_func(); below.  */
8730 #include <assert.h>
8731 /* Override any gcc2 internal prototype to avoid an error.  */
8732 /* We use char because int might match the return type of a gcc2
8733     builtin and then its argument prototype would still apply.  */
8734 char $ac_func();
8735
8736 int main() {
8737
8738 /* The GNU C library defines this for functions which it implements
8739     to always fail with ENOSYS.  Some functions are actually named
8740     something starting with __ and the normal name is an alias.  */
8741 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8742 choke me
8743 #else
8744 $ac_func();
8745 #endif
8746
8747 ; return 0; }
8748 EOF
8749 if { (eval echo configure:8750: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8750   rm -rf conftest*
8751   eval "ac_cv_func_$ac_func=yes"
8752 else
8753   echo "configure: failed program was:" >&5
8754   cat conftest.$ac_ext >&5
8755   rm -rf conftest*
8756   eval "ac_cv_func_$ac_func=no"
8757 fi
8758 rm -f conftest*
8759 fi
8760
8761 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8762   echo "$ac_t""yes" 1>&6
8763     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8764   cat >> confdefs.h <<EOF
8765 #define $ac_tr_func 1
8766 EOF
8767
8768 else
8769   echo "$ac_t""no" 1>&6
8770 fi
8771 done
8772
8773   fi
8774
8775
8776   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8777 echo "configure:8778: checking for atan2l declaration" >&5
8778   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
8779   echo $ac_n "(cached) $ac_c" 1>&6
8780 else
8781
8782
8783     ac_ext=C
8784 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8785 ac_cpp='$CXXCPP $CPPFLAGS'
8786 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8787 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8788 cross_compiling=$ac_cv_prog_cxx_cross
8789
8790     cat > conftest.$ac_ext <<EOF
8791 #line 8792 "configure"
8792 #include "confdefs.h"
8793 #include <math.h>
8794 int main() {
8795  atan2l(0, 0);
8796 ; return 0; }
8797 EOF
8798 if { (eval echo configure:8799: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8799   rm -rf conftest*
8800   glibcpp_cv_func_atan2l_use=yes
8801 else
8802   echo "configure: failed program was:" >&5
8803   cat conftest.$ac_ext >&5
8804   rm -rf conftest*
8805   glibcpp_cv_func_atan2l_use=no
8806 fi
8807 rm -f conftest*
8808     ac_ext=c
8809 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8810 ac_cpp='$CPP $CPPFLAGS'
8811 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8812 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8813 cross_compiling=$ac_cv_prog_cc_cross
8814
8815
8816 fi
8817
8818   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
8819   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
8820     for ac_func in atan2l
8821 do
8822 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8823 echo "configure:8824: checking for $ac_func" >&5
8824 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8825   echo $ac_n "(cached) $ac_c" 1>&6
8826 else
8827   cat > conftest.$ac_ext <<EOF
8828 #line 8829 "configure"
8829 #include "confdefs.h"
8830 /* System header to define __stub macros and hopefully few prototypes,
8831     which can conflict with char $ac_func(); below.  */
8832 #include <assert.h>
8833 /* Override any gcc2 internal prototype to avoid an error.  */
8834 /* We use char because int might match the return type of a gcc2
8835     builtin and then its argument prototype would still apply.  */
8836 char $ac_func();
8837
8838 int main() {
8839
8840 /* The GNU C library defines this for functions which it implements
8841     to always fail with ENOSYS.  Some functions are actually named
8842     something starting with __ and the normal name is an alias.  */
8843 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8844 choke me
8845 #else
8846 $ac_func();
8847 #endif
8848
8849 ; return 0; }
8850 EOF
8851 if { (eval echo configure:8852: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8852   rm -rf conftest*
8853   eval "ac_cv_func_$ac_func=yes"
8854 else
8855   echo "configure: failed program was:" >&5
8856   cat conftest.$ac_ext >&5
8857   rm -rf conftest*
8858   eval "ac_cv_func_$ac_func=no"
8859 fi
8860 rm -f conftest*
8861 fi
8862
8863 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8864   echo "$ac_t""yes" 1>&6
8865     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8866   cat >> confdefs.h <<EOF
8867 #define $ac_tr_func 1
8868 EOF
8869
8870 else
8871   echo "$ac_t""no" 1>&6
8872 fi
8873 done
8874
8875   fi
8876
8877
8878   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8879 echo "configure:8880: checking for ceill declaration" >&5
8880   if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
8881   echo $ac_n "(cached) $ac_c" 1>&6
8882 else
8883
8884
8885     ac_ext=C
8886 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8887 ac_cpp='$CXXCPP $CPPFLAGS'
8888 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8889 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8890 cross_compiling=$ac_cv_prog_cxx_cross
8891
8892     cat > conftest.$ac_ext <<EOF
8893 #line 8894 "configure"
8894 #include "confdefs.h"
8895 #include <math.h>
8896 int main() {
8897  ceill(0);
8898 ; return 0; }
8899 EOF
8900 if { (eval echo configure:8901: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8901   rm -rf conftest*
8902   glibcpp_cv_func_ceill_use=yes
8903 else
8904   echo "configure: failed program was:" >&5
8905   cat conftest.$ac_ext >&5
8906   rm -rf conftest*
8907   glibcpp_cv_func_ceill_use=no
8908 fi
8909 rm -f conftest*
8910     ac_ext=c
8911 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8912 ac_cpp='$CPP $CPPFLAGS'
8913 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8914 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8915 cross_compiling=$ac_cv_prog_cc_cross
8916
8917
8918 fi
8919
8920   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
8921   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
8922     for ac_func in ceill
8923 do
8924 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8925 echo "configure:8926: checking for $ac_func" >&5
8926 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8927   echo $ac_n "(cached) $ac_c" 1>&6
8928 else
8929   cat > conftest.$ac_ext <<EOF
8930 #line 8931 "configure"
8931 #include "confdefs.h"
8932 /* System header to define __stub macros and hopefully few prototypes,
8933     which can conflict with char $ac_func(); below.  */
8934 #include <assert.h>
8935 /* Override any gcc2 internal prototype to avoid an error.  */
8936 /* We use char because int might match the return type of a gcc2
8937     builtin and then its argument prototype would still apply.  */
8938 char $ac_func();
8939
8940 int main() {
8941
8942 /* The GNU C library defines this for functions which it implements
8943     to always fail with ENOSYS.  Some functions are actually named
8944     something starting with __ and the normal name is an alias.  */
8945 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8946 choke me
8947 #else
8948 $ac_func();
8949 #endif
8950
8951 ; return 0; }
8952 EOF
8953 if { (eval echo configure:8954: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8954   rm -rf conftest*
8955   eval "ac_cv_func_$ac_func=yes"
8956 else
8957   echo "configure: failed program was:" >&5
8958   cat conftest.$ac_ext >&5
8959   rm -rf conftest*
8960   eval "ac_cv_func_$ac_func=no"
8961 fi
8962 rm -f conftest*
8963 fi
8964
8965 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8966   echo "$ac_t""yes" 1>&6
8967     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8968   cat >> confdefs.h <<EOF
8969 #define $ac_tr_func 1
8970 EOF
8971
8972 else
8973   echo "$ac_t""no" 1>&6
8974 fi
8975 done
8976
8977   fi
8978
8979
8980   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8981 echo "configure:8982: checking for cosl declaration" >&5
8982   if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
8983   echo $ac_n "(cached) $ac_c" 1>&6
8984 else
8985
8986
8987     ac_ext=C
8988 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8989 ac_cpp='$CXXCPP $CPPFLAGS'
8990 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8991 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8992 cross_compiling=$ac_cv_prog_cxx_cross
8993
8994     cat > conftest.$ac_ext <<EOF
8995 #line 8996 "configure"
8996 #include "confdefs.h"
8997 #include <math.h>
8998 int main() {
8999  cosl(0);
9000 ; return 0; }
9001 EOF
9002 if { (eval echo configure:9003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9003   rm -rf conftest*
9004   glibcpp_cv_func_cosl_use=yes
9005 else
9006   echo "configure: failed program was:" >&5
9007   cat conftest.$ac_ext >&5
9008   rm -rf conftest*
9009   glibcpp_cv_func_cosl_use=no
9010 fi
9011 rm -f conftest*
9012     ac_ext=c
9013 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9014 ac_cpp='$CPP $CPPFLAGS'
9015 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9016 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9017 cross_compiling=$ac_cv_prog_cc_cross
9018
9019
9020 fi
9021
9022   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
9023   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
9024     for ac_func in cosl
9025 do
9026 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9027 echo "configure:9028: checking for $ac_func" >&5
9028 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9029   echo $ac_n "(cached) $ac_c" 1>&6
9030 else
9031   cat > conftest.$ac_ext <<EOF
9032 #line 9033 "configure"
9033 #include "confdefs.h"
9034 /* System header to define __stub macros and hopefully few prototypes,
9035     which can conflict with char $ac_func(); below.  */
9036 #include <assert.h>
9037 /* Override any gcc2 internal prototype to avoid an error.  */
9038 /* We use char because int might match the return type of a gcc2
9039     builtin and then its argument prototype would still apply.  */
9040 char $ac_func();
9041
9042 int main() {
9043
9044 /* The GNU C library defines this for functions which it implements
9045     to always fail with ENOSYS.  Some functions are actually named
9046     something starting with __ and the normal name is an alias.  */
9047 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9048 choke me
9049 #else
9050 $ac_func();
9051 #endif
9052
9053 ; return 0; }
9054 EOF
9055 if { (eval echo configure:9056: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9056   rm -rf conftest*
9057   eval "ac_cv_func_$ac_func=yes"
9058 else
9059   echo "configure: failed program was:" >&5
9060   cat conftest.$ac_ext >&5
9061   rm -rf conftest*
9062   eval "ac_cv_func_$ac_func=no"
9063 fi
9064 rm -f conftest*
9065 fi
9066
9067 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9068   echo "$ac_t""yes" 1>&6
9069     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9070   cat >> confdefs.h <<EOF
9071 #define $ac_tr_func 1
9072 EOF
9073
9074 else
9075   echo "$ac_t""no" 1>&6
9076 fi
9077 done
9078
9079   fi
9080
9081
9082   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
9083 echo "configure:9084: checking for coshl declaration" >&5
9084   if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
9085   echo $ac_n "(cached) $ac_c" 1>&6
9086 else
9087
9088
9089     ac_ext=C
9090 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9091 ac_cpp='$CXXCPP $CPPFLAGS'
9092 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9093 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9094 cross_compiling=$ac_cv_prog_cxx_cross
9095
9096     cat > conftest.$ac_ext <<EOF
9097 #line 9098 "configure"
9098 #include "confdefs.h"
9099 #include <math.h>
9100 int main() {
9101  coshl(0);
9102 ; return 0; }
9103 EOF
9104 if { (eval echo configure:9105: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9105   rm -rf conftest*
9106   glibcpp_cv_func_coshl_use=yes
9107 else
9108   echo "configure: failed program was:" >&5
9109   cat conftest.$ac_ext >&5
9110   rm -rf conftest*
9111   glibcpp_cv_func_coshl_use=no
9112 fi
9113 rm -f conftest*
9114     ac_ext=c
9115 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9116 ac_cpp='$CPP $CPPFLAGS'
9117 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9118 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9119 cross_compiling=$ac_cv_prog_cc_cross
9120
9121
9122 fi
9123
9124   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
9125   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
9126     for ac_func in coshl
9127 do
9128 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9129 echo "configure:9130: checking for $ac_func" >&5
9130 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9131   echo $ac_n "(cached) $ac_c" 1>&6
9132 else
9133   cat > conftest.$ac_ext <<EOF
9134 #line 9135 "configure"
9135 #include "confdefs.h"
9136 /* System header to define __stub macros and hopefully few prototypes,
9137     which can conflict with char $ac_func(); below.  */
9138 #include <assert.h>
9139 /* Override any gcc2 internal prototype to avoid an error.  */
9140 /* We use char because int might match the return type of a gcc2
9141     builtin and then its argument prototype would still apply.  */
9142 char $ac_func();
9143
9144 int main() {
9145
9146 /* The GNU C library defines this for functions which it implements
9147     to always fail with ENOSYS.  Some functions are actually named
9148     something starting with __ and the normal name is an alias.  */
9149 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9150 choke me
9151 #else
9152 $ac_func();
9153 #endif
9154
9155 ; return 0; }
9156 EOF
9157 if { (eval echo configure:9158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9158   rm -rf conftest*
9159   eval "ac_cv_func_$ac_func=yes"
9160 else
9161   echo "configure: failed program was:" >&5
9162   cat conftest.$ac_ext >&5
9163   rm -rf conftest*
9164   eval "ac_cv_func_$ac_func=no"
9165 fi
9166 rm -f conftest*
9167 fi
9168
9169 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9170   echo "$ac_t""yes" 1>&6
9171     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9172   cat >> confdefs.h <<EOF
9173 #define $ac_tr_func 1
9174 EOF
9175
9176 else
9177   echo "$ac_t""no" 1>&6
9178 fi
9179 done
9180
9181   fi
9182
9183
9184   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
9185 echo "configure:9186: checking for expl declaration" >&5
9186   if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
9187   echo $ac_n "(cached) $ac_c" 1>&6
9188 else
9189
9190
9191     ac_ext=C
9192 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9193 ac_cpp='$CXXCPP $CPPFLAGS'
9194 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9195 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9196 cross_compiling=$ac_cv_prog_cxx_cross
9197
9198     cat > conftest.$ac_ext <<EOF
9199 #line 9200 "configure"
9200 #include "confdefs.h"
9201 #include <math.h>
9202 int main() {
9203  expl(0);
9204 ; return 0; }
9205 EOF
9206 if { (eval echo configure:9207: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9207   rm -rf conftest*
9208   glibcpp_cv_func_expl_use=yes
9209 else
9210   echo "configure: failed program was:" >&5
9211   cat conftest.$ac_ext >&5
9212   rm -rf conftest*
9213   glibcpp_cv_func_expl_use=no
9214 fi
9215 rm -f conftest*
9216     ac_ext=c
9217 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9218 ac_cpp='$CPP $CPPFLAGS'
9219 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9220 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9221 cross_compiling=$ac_cv_prog_cc_cross
9222
9223
9224 fi
9225
9226   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
9227   if test x$glibcpp_cv_func_expl_use = x"yes"; then
9228     for ac_func in expl
9229 do
9230 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9231 echo "configure:9232: checking for $ac_func" >&5
9232 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9233   echo $ac_n "(cached) $ac_c" 1>&6
9234 else
9235   cat > conftest.$ac_ext <<EOF
9236 #line 9237 "configure"
9237 #include "confdefs.h"
9238 /* System header to define __stub macros and hopefully few prototypes,
9239     which can conflict with char $ac_func(); below.  */
9240 #include <assert.h>
9241 /* Override any gcc2 internal prototype to avoid an error.  */
9242 /* We use char because int might match the return type of a gcc2
9243     builtin and then its argument prototype would still apply.  */
9244 char $ac_func();
9245
9246 int main() {
9247
9248 /* The GNU C library defines this for functions which it implements
9249     to always fail with ENOSYS.  Some functions are actually named
9250     something starting with __ and the normal name is an alias.  */
9251 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9252 choke me
9253 #else
9254 $ac_func();
9255 #endif
9256
9257 ; return 0; }
9258 EOF
9259 if { (eval echo configure:9260: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9260   rm -rf conftest*
9261   eval "ac_cv_func_$ac_func=yes"
9262 else
9263   echo "configure: failed program was:" >&5
9264   cat conftest.$ac_ext >&5
9265   rm -rf conftest*
9266   eval "ac_cv_func_$ac_func=no"
9267 fi
9268 rm -f conftest*
9269 fi
9270
9271 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9272   echo "$ac_t""yes" 1>&6
9273     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9274   cat >> confdefs.h <<EOF
9275 #define $ac_tr_func 1
9276 EOF
9277
9278 else
9279   echo "$ac_t""no" 1>&6
9280 fi
9281 done
9282
9283   fi
9284
9285
9286   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9287 echo "configure:9288: checking for fabsl declaration" >&5
9288   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
9289   echo $ac_n "(cached) $ac_c" 1>&6
9290 else
9291
9292
9293     ac_ext=C
9294 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9295 ac_cpp='$CXXCPP $CPPFLAGS'
9296 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9297 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9298 cross_compiling=$ac_cv_prog_cxx_cross
9299
9300     cat > conftest.$ac_ext <<EOF
9301 #line 9302 "configure"
9302 #include "confdefs.h"
9303 #include <math.h>
9304 int main() {
9305  fabsl(0);
9306 ; return 0; }
9307 EOF
9308 if { (eval echo configure:9309: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9309   rm -rf conftest*
9310   glibcpp_cv_func_fabsl_use=yes
9311 else
9312   echo "configure: failed program was:" >&5
9313   cat conftest.$ac_ext >&5
9314   rm -rf conftest*
9315   glibcpp_cv_func_fabsl_use=no
9316 fi
9317 rm -f conftest*
9318     ac_ext=c
9319 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9320 ac_cpp='$CPP $CPPFLAGS'
9321 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9322 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9323 cross_compiling=$ac_cv_prog_cc_cross
9324
9325
9326 fi
9327
9328   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
9329   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
9330     for ac_func in fabsl
9331 do
9332 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9333 echo "configure:9334: checking for $ac_func" >&5
9334 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9335   echo $ac_n "(cached) $ac_c" 1>&6
9336 else
9337   cat > conftest.$ac_ext <<EOF
9338 #line 9339 "configure"
9339 #include "confdefs.h"
9340 /* System header to define __stub macros and hopefully few prototypes,
9341     which can conflict with char $ac_func(); below.  */
9342 #include <assert.h>
9343 /* Override any gcc2 internal prototype to avoid an error.  */
9344 /* We use char because int might match the return type of a gcc2
9345     builtin and then its argument prototype would still apply.  */
9346 char $ac_func();
9347
9348 int main() {
9349
9350 /* The GNU C library defines this for functions which it implements
9351     to always fail with ENOSYS.  Some functions are actually named
9352     something starting with __ and the normal name is an alias.  */
9353 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9354 choke me
9355 #else
9356 $ac_func();
9357 #endif
9358
9359 ; return 0; }
9360 EOF
9361 if { (eval echo configure:9362: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9362   rm -rf conftest*
9363   eval "ac_cv_func_$ac_func=yes"
9364 else
9365   echo "configure: failed program was:" >&5
9366   cat conftest.$ac_ext >&5
9367   rm -rf conftest*
9368   eval "ac_cv_func_$ac_func=no"
9369 fi
9370 rm -f conftest*
9371 fi
9372
9373 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9374   echo "$ac_t""yes" 1>&6
9375     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9376   cat >> confdefs.h <<EOF
9377 #define $ac_tr_func 1
9378 EOF
9379
9380 else
9381   echo "$ac_t""no" 1>&6
9382 fi
9383 done
9384
9385   fi
9386
9387
9388   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9389 echo "configure:9390: checking for floorl declaration" >&5
9390   if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
9391   echo $ac_n "(cached) $ac_c" 1>&6
9392 else
9393
9394
9395     ac_ext=C
9396 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9397 ac_cpp='$CXXCPP $CPPFLAGS'
9398 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9399 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9400 cross_compiling=$ac_cv_prog_cxx_cross
9401
9402     cat > conftest.$ac_ext <<EOF
9403 #line 9404 "configure"
9404 #include "confdefs.h"
9405 #include <math.h>
9406 int main() {
9407  floorl(0);
9408 ; return 0; }
9409 EOF
9410 if { (eval echo configure:9411: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9411   rm -rf conftest*
9412   glibcpp_cv_func_floorl_use=yes
9413 else
9414   echo "configure: failed program was:" >&5
9415   cat conftest.$ac_ext >&5
9416   rm -rf conftest*
9417   glibcpp_cv_func_floorl_use=no
9418 fi
9419 rm -f conftest*
9420     ac_ext=c
9421 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9422 ac_cpp='$CPP $CPPFLAGS'
9423 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9424 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9425 cross_compiling=$ac_cv_prog_cc_cross
9426
9427
9428 fi
9429
9430   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
9431   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
9432     for ac_func in floorl
9433 do
9434 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9435 echo "configure:9436: checking for $ac_func" >&5
9436 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9437   echo $ac_n "(cached) $ac_c" 1>&6
9438 else
9439   cat > conftest.$ac_ext <<EOF
9440 #line 9441 "configure"
9441 #include "confdefs.h"
9442 /* System header to define __stub macros and hopefully few prototypes,
9443     which can conflict with char $ac_func(); below.  */
9444 #include <assert.h>
9445 /* Override any gcc2 internal prototype to avoid an error.  */
9446 /* We use char because int might match the return type of a gcc2
9447     builtin and then its argument prototype would still apply.  */
9448 char $ac_func();
9449
9450 int main() {
9451
9452 /* The GNU C library defines this for functions which it implements
9453     to always fail with ENOSYS.  Some functions are actually named
9454     something starting with __ and the normal name is an alias.  */
9455 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9456 choke me
9457 #else
9458 $ac_func();
9459 #endif
9460
9461 ; return 0; }
9462 EOF
9463 if { (eval echo configure:9464: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9464   rm -rf conftest*
9465   eval "ac_cv_func_$ac_func=yes"
9466 else
9467   echo "configure: failed program was:" >&5
9468   cat conftest.$ac_ext >&5
9469   rm -rf conftest*
9470   eval "ac_cv_func_$ac_func=no"
9471 fi
9472 rm -f conftest*
9473 fi
9474
9475 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9476   echo "$ac_t""yes" 1>&6
9477     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9478   cat >> confdefs.h <<EOF
9479 #define $ac_tr_func 1
9480 EOF
9481
9482 else
9483   echo "$ac_t""no" 1>&6
9484 fi
9485 done
9486
9487   fi
9488
9489
9490   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9491 echo "configure:9492: checking for fmodl declaration" >&5
9492   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
9493   echo $ac_n "(cached) $ac_c" 1>&6
9494 else
9495
9496
9497     ac_ext=C
9498 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9499 ac_cpp='$CXXCPP $CPPFLAGS'
9500 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9501 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9502 cross_compiling=$ac_cv_prog_cxx_cross
9503
9504     cat > conftest.$ac_ext <<EOF
9505 #line 9506 "configure"
9506 #include "confdefs.h"
9507 #include <math.h>
9508 int main() {
9509  fmodl(0, 0);
9510 ; return 0; }
9511 EOF
9512 if { (eval echo configure:9513: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9513   rm -rf conftest*
9514   glibcpp_cv_func_fmodl_use=yes
9515 else
9516   echo "configure: failed program was:" >&5
9517   cat conftest.$ac_ext >&5
9518   rm -rf conftest*
9519   glibcpp_cv_func_fmodl_use=no
9520 fi
9521 rm -f conftest*
9522     ac_ext=c
9523 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9524 ac_cpp='$CPP $CPPFLAGS'
9525 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9526 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9527 cross_compiling=$ac_cv_prog_cc_cross
9528
9529
9530 fi
9531
9532   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
9533   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
9534     for ac_func in fmodl
9535 do
9536 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9537 echo "configure:9538: checking for $ac_func" >&5
9538 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9539   echo $ac_n "(cached) $ac_c" 1>&6
9540 else
9541   cat > conftest.$ac_ext <<EOF
9542 #line 9543 "configure"
9543 #include "confdefs.h"
9544 /* System header to define __stub macros and hopefully few prototypes,
9545     which can conflict with char $ac_func(); below.  */
9546 #include <assert.h>
9547 /* Override any gcc2 internal prototype to avoid an error.  */
9548 /* We use char because int might match the return type of a gcc2
9549     builtin and then its argument prototype would still apply.  */
9550 char $ac_func();
9551
9552 int main() {
9553
9554 /* The GNU C library defines this for functions which it implements
9555     to always fail with ENOSYS.  Some functions are actually named
9556     something starting with __ and the normal name is an alias.  */
9557 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9558 choke me
9559 #else
9560 $ac_func();
9561 #endif
9562
9563 ; return 0; }
9564 EOF
9565 if { (eval echo configure:9566: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9566   rm -rf conftest*
9567   eval "ac_cv_func_$ac_func=yes"
9568 else
9569   echo "configure: failed program was:" >&5
9570   cat conftest.$ac_ext >&5
9571   rm -rf conftest*
9572   eval "ac_cv_func_$ac_func=no"
9573 fi
9574 rm -f conftest*
9575 fi
9576
9577 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9578   echo "$ac_t""yes" 1>&6
9579     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9580   cat >> confdefs.h <<EOF
9581 #define $ac_tr_func 1
9582 EOF
9583
9584 else
9585   echo "$ac_t""no" 1>&6
9586 fi
9587 done
9588
9589   fi
9590
9591
9592   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9593 echo "configure:9594: checking for frexpl declaration" >&5
9594   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
9595   echo $ac_n "(cached) $ac_c" 1>&6
9596 else
9597
9598
9599     ac_ext=C
9600 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9601 ac_cpp='$CXXCPP $CPPFLAGS'
9602 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9603 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9604 cross_compiling=$ac_cv_prog_cxx_cross
9605
9606     cat > conftest.$ac_ext <<EOF
9607 #line 9608 "configure"
9608 #include "confdefs.h"
9609 #include <math.h>
9610 int main() {
9611  frexpl(0, 0);
9612 ; return 0; }
9613 EOF
9614 if { (eval echo configure:9615: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9615   rm -rf conftest*
9616   glibcpp_cv_func_frexpl_use=yes
9617 else
9618   echo "configure: failed program was:" >&5
9619   cat conftest.$ac_ext >&5
9620   rm -rf conftest*
9621   glibcpp_cv_func_frexpl_use=no
9622 fi
9623 rm -f conftest*
9624     ac_ext=c
9625 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9626 ac_cpp='$CPP $CPPFLAGS'
9627 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9628 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9629 cross_compiling=$ac_cv_prog_cc_cross
9630
9631
9632 fi
9633
9634   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
9635   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
9636     for ac_func in frexpl
9637 do
9638 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9639 echo "configure:9640: checking for $ac_func" >&5
9640 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9641   echo $ac_n "(cached) $ac_c" 1>&6
9642 else
9643   cat > conftest.$ac_ext <<EOF
9644 #line 9645 "configure"
9645 #include "confdefs.h"
9646 /* System header to define __stub macros and hopefully few prototypes,
9647     which can conflict with char $ac_func(); below.  */
9648 #include <assert.h>
9649 /* Override any gcc2 internal prototype to avoid an error.  */
9650 /* We use char because int might match the return type of a gcc2
9651     builtin and then its argument prototype would still apply.  */
9652 char $ac_func();
9653
9654 int main() {
9655
9656 /* The GNU C library defines this for functions which it implements
9657     to always fail with ENOSYS.  Some functions are actually named
9658     something starting with __ and the normal name is an alias.  */
9659 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9660 choke me
9661 #else
9662 $ac_func();
9663 #endif
9664
9665 ; return 0; }
9666 EOF
9667 if { (eval echo configure:9668: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9668   rm -rf conftest*
9669   eval "ac_cv_func_$ac_func=yes"
9670 else
9671   echo "configure: failed program was:" >&5
9672   cat conftest.$ac_ext >&5
9673   rm -rf conftest*
9674   eval "ac_cv_func_$ac_func=no"
9675 fi
9676 rm -f conftest*
9677 fi
9678
9679 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9680   echo "$ac_t""yes" 1>&6
9681     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9682   cat >> confdefs.h <<EOF
9683 #define $ac_tr_func 1
9684 EOF
9685
9686 else
9687   echo "$ac_t""no" 1>&6
9688 fi
9689 done
9690
9691   fi
9692
9693
9694   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9695 echo "configure:9696: checking for ldexpl declaration" >&5
9696   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
9697   echo $ac_n "(cached) $ac_c" 1>&6
9698 else
9699
9700
9701     ac_ext=C
9702 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9703 ac_cpp='$CXXCPP $CPPFLAGS'
9704 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9705 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9706 cross_compiling=$ac_cv_prog_cxx_cross
9707
9708     cat > conftest.$ac_ext <<EOF
9709 #line 9710 "configure"
9710 #include "confdefs.h"
9711 #include <math.h>
9712 int main() {
9713  ldexpl(0, 0);
9714 ; return 0; }
9715 EOF
9716 if { (eval echo configure:9717: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9717   rm -rf conftest*
9718   glibcpp_cv_func_ldexpl_use=yes
9719 else
9720   echo "configure: failed program was:" >&5
9721   cat conftest.$ac_ext >&5
9722   rm -rf conftest*
9723   glibcpp_cv_func_ldexpl_use=no
9724 fi
9725 rm -f conftest*
9726     ac_ext=c
9727 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9728 ac_cpp='$CPP $CPPFLAGS'
9729 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9730 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9731 cross_compiling=$ac_cv_prog_cc_cross
9732
9733
9734 fi
9735
9736   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
9737   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
9738     for ac_func in ldexpl
9739 do
9740 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9741 echo "configure:9742: checking for $ac_func" >&5
9742 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9743   echo $ac_n "(cached) $ac_c" 1>&6
9744 else
9745   cat > conftest.$ac_ext <<EOF
9746 #line 9747 "configure"
9747 #include "confdefs.h"
9748 /* System header to define __stub macros and hopefully few prototypes,
9749     which can conflict with char $ac_func(); below.  */
9750 #include <assert.h>
9751 /* Override any gcc2 internal prototype to avoid an error.  */
9752 /* We use char because int might match the return type of a gcc2
9753     builtin and then its argument prototype would still apply.  */
9754 char $ac_func();
9755
9756 int main() {
9757
9758 /* The GNU C library defines this for functions which it implements
9759     to always fail with ENOSYS.  Some functions are actually named
9760     something starting with __ and the normal name is an alias.  */
9761 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9762 choke me
9763 #else
9764 $ac_func();
9765 #endif
9766
9767 ; return 0; }
9768 EOF
9769 if { (eval echo configure:9770: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9770   rm -rf conftest*
9771   eval "ac_cv_func_$ac_func=yes"
9772 else
9773   echo "configure: failed program was:" >&5
9774   cat conftest.$ac_ext >&5
9775   rm -rf conftest*
9776   eval "ac_cv_func_$ac_func=no"
9777 fi
9778 rm -f conftest*
9779 fi
9780
9781 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9782   echo "$ac_t""yes" 1>&6
9783     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9784   cat >> confdefs.h <<EOF
9785 #define $ac_tr_func 1
9786 EOF
9787
9788 else
9789   echo "$ac_t""no" 1>&6
9790 fi
9791 done
9792
9793   fi
9794
9795
9796   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9797 echo "configure:9798: checking for logl declaration" >&5
9798   if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
9799   echo $ac_n "(cached) $ac_c" 1>&6
9800 else
9801
9802
9803     ac_ext=C
9804 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9805 ac_cpp='$CXXCPP $CPPFLAGS'
9806 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9807 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9808 cross_compiling=$ac_cv_prog_cxx_cross
9809
9810     cat > conftest.$ac_ext <<EOF
9811 #line 9812 "configure"
9812 #include "confdefs.h"
9813 #include <math.h>
9814 int main() {
9815  logl(0);
9816 ; return 0; }
9817 EOF
9818 if { (eval echo configure:9819: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9819   rm -rf conftest*
9820   glibcpp_cv_func_logl_use=yes
9821 else
9822   echo "configure: failed program was:" >&5
9823   cat conftest.$ac_ext >&5
9824   rm -rf conftest*
9825   glibcpp_cv_func_logl_use=no
9826 fi
9827 rm -f conftest*
9828     ac_ext=c
9829 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9830 ac_cpp='$CPP $CPPFLAGS'
9831 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9832 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9833 cross_compiling=$ac_cv_prog_cc_cross
9834
9835
9836 fi
9837
9838   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
9839   if test x$glibcpp_cv_func_logl_use = x"yes"; then
9840     for ac_func in logl
9841 do
9842 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9843 echo "configure:9844: checking for $ac_func" >&5
9844 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9845   echo $ac_n "(cached) $ac_c" 1>&6
9846 else
9847   cat > conftest.$ac_ext <<EOF
9848 #line 9849 "configure"
9849 #include "confdefs.h"
9850 /* System header to define __stub macros and hopefully few prototypes,
9851     which can conflict with char $ac_func(); below.  */
9852 #include <assert.h>
9853 /* Override any gcc2 internal prototype to avoid an error.  */
9854 /* We use char because int might match the return type of a gcc2
9855     builtin and then its argument prototype would still apply.  */
9856 char $ac_func();
9857
9858 int main() {
9859
9860 /* The GNU C library defines this for functions which it implements
9861     to always fail with ENOSYS.  Some functions are actually named
9862     something starting with __ and the normal name is an alias.  */
9863 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9864 choke me
9865 #else
9866 $ac_func();
9867 #endif
9868
9869 ; return 0; }
9870 EOF
9871 if { (eval echo configure:9872: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9872   rm -rf conftest*
9873   eval "ac_cv_func_$ac_func=yes"
9874 else
9875   echo "configure: failed program was:" >&5
9876   cat conftest.$ac_ext >&5
9877   rm -rf conftest*
9878   eval "ac_cv_func_$ac_func=no"
9879 fi
9880 rm -f conftest*
9881 fi
9882
9883 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9884   echo "$ac_t""yes" 1>&6
9885     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9886   cat >> confdefs.h <<EOF
9887 #define $ac_tr_func 1
9888 EOF
9889
9890 else
9891   echo "$ac_t""no" 1>&6
9892 fi
9893 done
9894
9895   fi
9896
9897
9898   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9899 echo "configure:9900: checking for log10l declaration" >&5
9900   if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
9901   echo $ac_n "(cached) $ac_c" 1>&6
9902 else
9903
9904
9905     ac_ext=C
9906 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9907 ac_cpp='$CXXCPP $CPPFLAGS'
9908 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9909 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9910 cross_compiling=$ac_cv_prog_cxx_cross
9911
9912     cat > conftest.$ac_ext <<EOF
9913 #line 9914 "configure"
9914 #include "confdefs.h"
9915 #include <math.h>
9916 int main() {
9917  log10l(0);
9918 ; return 0; }
9919 EOF
9920 if { (eval echo configure:9921: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9921   rm -rf conftest*
9922   glibcpp_cv_func_log10l_use=yes
9923 else
9924   echo "configure: failed program was:" >&5
9925   cat conftest.$ac_ext >&5
9926   rm -rf conftest*
9927   glibcpp_cv_func_log10l_use=no
9928 fi
9929 rm -f conftest*
9930     ac_ext=c
9931 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9932 ac_cpp='$CPP $CPPFLAGS'
9933 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9934 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9935 cross_compiling=$ac_cv_prog_cc_cross
9936
9937
9938 fi
9939
9940   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
9941   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
9942     for ac_func in log10l
9943 do
9944 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9945 echo "configure:9946: checking for $ac_func" >&5
9946 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9947   echo $ac_n "(cached) $ac_c" 1>&6
9948 else
9949   cat > conftest.$ac_ext <<EOF
9950 #line 9951 "configure"
9951 #include "confdefs.h"
9952 /* System header to define __stub macros and hopefully few prototypes,
9953     which can conflict with char $ac_func(); below.  */
9954 #include <assert.h>
9955 /* Override any gcc2 internal prototype to avoid an error.  */
9956 /* We use char because int might match the return type of a gcc2
9957     builtin and then its argument prototype would still apply.  */
9958 char $ac_func();
9959
9960 int main() {
9961
9962 /* The GNU C library defines this for functions which it implements
9963     to always fail with ENOSYS.  Some functions are actually named
9964     something starting with __ and the normal name is an alias.  */
9965 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9966 choke me
9967 #else
9968 $ac_func();
9969 #endif
9970
9971 ; return 0; }
9972 EOF
9973 if { (eval echo configure:9974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9974   rm -rf conftest*
9975   eval "ac_cv_func_$ac_func=yes"
9976 else
9977   echo "configure: failed program was:" >&5
9978   cat conftest.$ac_ext >&5
9979   rm -rf conftest*
9980   eval "ac_cv_func_$ac_func=no"
9981 fi
9982 rm -f conftest*
9983 fi
9984
9985 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9986   echo "$ac_t""yes" 1>&6
9987     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9988   cat >> confdefs.h <<EOF
9989 #define $ac_tr_func 1
9990 EOF
9991
9992 else
9993   echo "$ac_t""no" 1>&6
9994 fi
9995 done
9996
9997   fi
9998
9999
10000   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
10001 echo "configure:10002: checking for modfl declaration" >&5
10002   if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
10003   echo $ac_n "(cached) $ac_c" 1>&6
10004 else
10005
10006
10007     ac_ext=C
10008 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10009 ac_cpp='$CXXCPP $CPPFLAGS'
10010 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10011 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10012 cross_compiling=$ac_cv_prog_cxx_cross
10013
10014     cat > conftest.$ac_ext <<EOF
10015 #line 10016 "configure"
10016 #include "confdefs.h"
10017 #include <math.h>
10018 int main() {
10019  modfl(0, 0);
10020 ; return 0; }
10021 EOF
10022 if { (eval echo configure:10023: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10023   rm -rf conftest*
10024   glibcpp_cv_func_modfl_use=yes
10025 else
10026   echo "configure: failed program was:" >&5
10027   cat conftest.$ac_ext >&5
10028   rm -rf conftest*
10029   glibcpp_cv_func_modfl_use=no
10030 fi
10031 rm -f conftest*
10032     ac_ext=c
10033 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10034 ac_cpp='$CPP $CPPFLAGS'
10035 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10036 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10037 cross_compiling=$ac_cv_prog_cc_cross
10038
10039
10040 fi
10041
10042   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
10043   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
10044     for ac_func in modfl
10045 do
10046 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10047 echo "configure:10048: checking for $ac_func" >&5
10048 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10049   echo $ac_n "(cached) $ac_c" 1>&6
10050 else
10051   cat > conftest.$ac_ext <<EOF
10052 #line 10053 "configure"
10053 #include "confdefs.h"
10054 /* System header to define __stub macros and hopefully few prototypes,
10055     which can conflict with char $ac_func(); below.  */
10056 #include <assert.h>
10057 /* Override any gcc2 internal prototype to avoid an error.  */
10058 /* We use char because int might match the return type of a gcc2
10059     builtin and then its argument prototype would still apply.  */
10060 char $ac_func();
10061
10062 int main() {
10063
10064 /* The GNU C library defines this for functions which it implements
10065     to always fail with ENOSYS.  Some functions are actually named
10066     something starting with __ and the normal name is an alias.  */
10067 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10068 choke me
10069 #else
10070 $ac_func();
10071 #endif
10072
10073 ; return 0; }
10074 EOF
10075 if { (eval echo configure:10076: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10076   rm -rf conftest*
10077   eval "ac_cv_func_$ac_func=yes"
10078 else
10079   echo "configure: failed program was:" >&5
10080   cat conftest.$ac_ext >&5
10081   rm -rf conftest*
10082   eval "ac_cv_func_$ac_func=no"
10083 fi
10084 rm -f conftest*
10085 fi
10086
10087 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10088   echo "$ac_t""yes" 1>&6
10089     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10090   cat >> confdefs.h <<EOF
10091 #define $ac_tr_func 1
10092 EOF
10093
10094 else
10095   echo "$ac_t""no" 1>&6
10096 fi
10097 done
10098
10099   fi
10100
10101
10102   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
10103 echo "configure:10104: checking for powl declaration" >&5
10104   if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
10105   echo $ac_n "(cached) $ac_c" 1>&6
10106 else
10107
10108
10109     ac_ext=C
10110 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10111 ac_cpp='$CXXCPP $CPPFLAGS'
10112 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10113 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10114 cross_compiling=$ac_cv_prog_cxx_cross
10115
10116     cat > conftest.$ac_ext <<EOF
10117 #line 10118 "configure"
10118 #include "confdefs.h"
10119 #include <math.h>
10120 int main() {
10121  powl(0, 0);
10122 ; return 0; }
10123 EOF
10124 if { (eval echo configure:10125: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10125   rm -rf conftest*
10126   glibcpp_cv_func_powl_use=yes
10127 else
10128   echo "configure: failed program was:" >&5
10129   cat conftest.$ac_ext >&5
10130   rm -rf conftest*
10131   glibcpp_cv_func_powl_use=no
10132 fi
10133 rm -f conftest*
10134     ac_ext=c
10135 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10136 ac_cpp='$CPP $CPPFLAGS'
10137 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10138 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10139 cross_compiling=$ac_cv_prog_cc_cross
10140
10141
10142 fi
10143
10144   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
10145   if test x$glibcpp_cv_func_powl_use = x"yes"; then
10146     for ac_func in powl
10147 do
10148 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10149 echo "configure:10150: checking for $ac_func" >&5
10150 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10151   echo $ac_n "(cached) $ac_c" 1>&6
10152 else
10153   cat > conftest.$ac_ext <<EOF
10154 #line 10155 "configure"
10155 #include "confdefs.h"
10156 /* System header to define __stub macros and hopefully few prototypes,
10157     which can conflict with char $ac_func(); below.  */
10158 #include <assert.h>
10159 /* Override any gcc2 internal prototype to avoid an error.  */
10160 /* We use char because int might match the return type of a gcc2
10161     builtin and then its argument prototype would still apply.  */
10162 char $ac_func();
10163
10164 int main() {
10165
10166 /* The GNU C library defines this for functions which it implements
10167     to always fail with ENOSYS.  Some functions are actually named
10168     something starting with __ and the normal name is an alias.  */
10169 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10170 choke me
10171 #else
10172 $ac_func();
10173 #endif
10174
10175 ; return 0; }
10176 EOF
10177 if { (eval echo configure:10178: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10178   rm -rf conftest*
10179   eval "ac_cv_func_$ac_func=yes"
10180 else
10181   echo "configure: failed program was:" >&5
10182   cat conftest.$ac_ext >&5
10183   rm -rf conftest*
10184   eval "ac_cv_func_$ac_func=no"
10185 fi
10186 rm -f conftest*
10187 fi
10188
10189 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10190   echo "$ac_t""yes" 1>&6
10191     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10192   cat >> confdefs.h <<EOF
10193 #define $ac_tr_func 1
10194 EOF
10195
10196 else
10197   echo "$ac_t""no" 1>&6
10198 fi
10199 done
10200
10201   fi
10202
10203
10204   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
10205 echo "configure:10206: checking for sinl declaration" >&5
10206   if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
10207   echo $ac_n "(cached) $ac_c" 1>&6
10208 else
10209
10210
10211     ac_ext=C
10212 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10213 ac_cpp='$CXXCPP $CPPFLAGS'
10214 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10215 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10216 cross_compiling=$ac_cv_prog_cxx_cross
10217
10218     cat > conftest.$ac_ext <<EOF
10219 #line 10220 "configure"
10220 #include "confdefs.h"
10221 #include <math.h>
10222 int main() {
10223  sinl(0);
10224 ; return 0; }
10225 EOF
10226 if { (eval echo configure:10227: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10227   rm -rf conftest*
10228   glibcpp_cv_func_sinl_use=yes
10229 else
10230   echo "configure: failed program was:" >&5
10231   cat conftest.$ac_ext >&5
10232   rm -rf conftest*
10233   glibcpp_cv_func_sinl_use=no
10234 fi
10235 rm -f conftest*
10236     ac_ext=c
10237 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10238 ac_cpp='$CPP $CPPFLAGS'
10239 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10240 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10241 cross_compiling=$ac_cv_prog_cc_cross
10242
10243
10244 fi
10245
10246   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
10247   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
10248     for ac_func in sinl
10249 do
10250 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10251 echo "configure:10252: checking for $ac_func" >&5
10252 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10253   echo $ac_n "(cached) $ac_c" 1>&6
10254 else
10255   cat > conftest.$ac_ext <<EOF
10256 #line 10257 "configure"
10257 #include "confdefs.h"
10258 /* System header to define __stub macros and hopefully few prototypes,
10259     which can conflict with char $ac_func(); below.  */
10260 #include <assert.h>
10261 /* Override any gcc2 internal prototype to avoid an error.  */
10262 /* We use char because int might match the return type of a gcc2
10263     builtin and then its argument prototype would still apply.  */
10264 char $ac_func();
10265
10266 int main() {
10267
10268 /* The GNU C library defines this for functions which it implements
10269     to always fail with ENOSYS.  Some functions are actually named
10270     something starting with __ and the normal name is an alias.  */
10271 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10272 choke me
10273 #else
10274 $ac_func();
10275 #endif
10276
10277 ; return 0; }
10278 EOF
10279 if { (eval echo configure:10280: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10280   rm -rf conftest*
10281   eval "ac_cv_func_$ac_func=yes"
10282 else
10283   echo "configure: failed program was:" >&5
10284   cat conftest.$ac_ext >&5
10285   rm -rf conftest*
10286   eval "ac_cv_func_$ac_func=no"
10287 fi
10288 rm -f conftest*
10289 fi
10290
10291 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10292   echo "$ac_t""yes" 1>&6
10293     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10294   cat >> confdefs.h <<EOF
10295 #define $ac_tr_func 1
10296 EOF
10297
10298 else
10299   echo "$ac_t""no" 1>&6
10300 fi
10301 done
10302
10303   fi
10304
10305
10306   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
10307 echo "configure:10308: checking for sinhl declaration" >&5
10308   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
10309   echo $ac_n "(cached) $ac_c" 1>&6
10310 else
10311
10312
10313     ac_ext=C
10314 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10315 ac_cpp='$CXXCPP $CPPFLAGS'
10316 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10317 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10318 cross_compiling=$ac_cv_prog_cxx_cross
10319
10320     cat > conftest.$ac_ext <<EOF
10321 #line 10322 "configure"
10322 #include "confdefs.h"
10323 #include <math.h>
10324 int main() {
10325  sinhl(0);
10326 ; return 0; }
10327 EOF
10328 if { (eval echo configure:10329: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10329   rm -rf conftest*
10330   glibcpp_cv_func_sinhl_use=yes
10331 else
10332   echo "configure: failed program was:" >&5
10333   cat conftest.$ac_ext >&5
10334   rm -rf conftest*
10335   glibcpp_cv_func_sinhl_use=no
10336 fi
10337 rm -f conftest*
10338     ac_ext=c
10339 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10340 ac_cpp='$CPP $CPPFLAGS'
10341 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10342 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10343 cross_compiling=$ac_cv_prog_cc_cross
10344
10345
10346 fi
10347
10348   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
10349   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
10350     for ac_func in sinhl
10351 do
10352 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10353 echo "configure:10354: checking for $ac_func" >&5
10354 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10355   echo $ac_n "(cached) $ac_c" 1>&6
10356 else
10357   cat > conftest.$ac_ext <<EOF
10358 #line 10359 "configure"
10359 #include "confdefs.h"
10360 /* System header to define __stub macros and hopefully few prototypes,
10361     which can conflict with char $ac_func(); below.  */
10362 #include <assert.h>
10363 /* Override any gcc2 internal prototype to avoid an error.  */
10364 /* We use char because int might match the return type of a gcc2
10365     builtin and then its argument prototype would still apply.  */
10366 char $ac_func();
10367
10368 int main() {
10369
10370 /* The GNU C library defines this for functions which it implements
10371     to always fail with ENOSYS.  Some functions are actually named
10372     something starting with __ and the normal name is an alias.  */
10373 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10374 choke me
10375 #else
10376 $ac_func();
10377 #endif
10378
10379 ; return 0; }
10380 EOF
10381 if { (eval echo configure:10382: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10382   rm -rf conftest*
10383   eval "ac_cv_func_$ac_func=yes"
10384 else
10385   echo "configure: failed program was:" >&5
10386   cat conftest.$ac_ext >&5
10387   rm -rf conftest*
10388   eval "ac_cv_func_$ac_func=no"
10389 fi
10390 rm -f conftest*
10391 fi
10392
10393 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10394   echo "$ac_t""yes" 1>&6
10395     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10396   cat >> confdefs.h <<EOF
10397 #define $ac_tr_func 1
10398 EOF
10399
10400 else
10401   echo "$ac_t""no" 1>&6
10402 fi
10403 done
10404
10405   fi
10406
10407
10408   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
10409 echo "configure:10410: checking for sqrtl declaration" >&5
10410   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
10411   echo $ac_n "(cached) $ac_c" 1>&6
10412 else
10413
10414
10415     ac_ext=C
10416 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10417 ac_cpp='$CXXCPP $CPPFLAGS'
10418 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10419 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10420 cross_compiling=$ac_cv_prog_cxx_cross
10421
10422     cat > conftest.$ac_ext <<EOF
10423 #line 10424 "configure"
10424 #include "confdefs.h"
10425 #include <math.h>
10426 int main() {
10427  sqrtl(0);
10428 ; return 0; }
10429 EOF
10430 if { (eval echo configure:10431: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10431   rm -rf conftest*
10432   glibcpp_cv_func_sqrtl_use=yes
10433 else
10434   echo "configure: failed program was:" >&5
10435   cat conftest.$ac_ext >&5
10436   rm -rf conftest*
10437   glibcpp_cv_func_sqrtl_use=no
10438 fi
10439 rm -f conftest*
10440     ac_ext=c
10441 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10442 ac_cpp='$CPP $CPPFLAGS'
10443 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10444 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10445 cross_compiling=$ac_cv_prog_cc_cross
10446
10447
10448 fi
10449
10450   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
10451   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
10452     for ac_func in sqrtl
10453 do
10454 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10455 echo "configure:10456: checking for $ac_func" >&5
10456 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10457   echo $ac_n "(cached) $ac_c" 1>&6
10458 else
10459   cat > conftest.$ac_ext <<EOF
10460 #line 10461 "configure"
10461 #include "confdefs.h"
10462 /* System header to define __stub macros and hopefully few prototypes,
10463     which can conflict with char $ac_func(); below.  */
10464 #include <assert.h>
10465 /* Override any gcc2 internal prototype to avoid an error.  */
10466 /* We use char because int might match the return type of a gcc2
10467     builtin and then its argument prototype would still apply.  */
10468 char $ac_func();
10469
10470 int main() {
10471
10472 /* The GNU C library defines this for functions which it implements
10473     to always fail with ENOSYS.  Some functions are actually named
10474     something starting with __ and the normal name is an alias.  */
10475 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10476 choke me
10477 #else
10478 $ac_func();
10479 #endif
10480
10481 ; return 0; }
10482 EOF
10483 if { (eval echo configure:10484: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10484   rm -rf conftest*
10485   eval "ac_cv_func_$ac_func=yes"
10486 else
10487   echo "configure: failed program was:" >&5
10488   cat conftest.$ac_ext >&5
10489   rm -rf conftest*
10490   eval "ac_cv_func_$ac_func=no"
10491 fi
10492 rm -f conftest*
10493 fi
10494
10495 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10496   echo "$ac_t""yes" 1>&6
10497     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10498   cat >> confdefs.h <<EOF
10499 #define $ac_tr_func 1
10500 EOF
10501
10502 else
10503   echo "$ac_t""no" 1>&6
10504 fi
10505 done
10506
10507   fi
10508
10509
10510   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
10511 echo "configure:10512: checking for tanl declaration" >&5
10512   if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
10513   echo $ac_n "(cached) $ac_c" 1>&6
10514 else
10515
10516
10517     ac_ext=C
10518 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10519 ac_cpp='$CXXCPP $CPPFLAGS'
10520 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10521 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10522 cross_compiling=$ac_cv_prog_cxx_cross
10523
10524     cat > conftest.$ac_ext <<EOF
10525 #line 10526 "configure"
10526 #include "confdefs.h"
10527 #include <math.h>
10528 int main() {
10529  tanl(0);
10530 ; return 0; }
10531 EOF
10532 if { (eval echo configure:10533: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10533   rm -rf conftest*
10534   glibcpp_cv_func_tanl_use=yes
10535 else
10536   echo "configure: failed program was:" >&5
10537   cat conftest.$ac_ext >&5
10538   rm -rf conftest*
10539   glibcpp_cv_func_tanl_use=no
10540 fi
10541 rm -f conftest*
10542     ac_ext=c
10543 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10544 ac_cpp='$CPP $CPPFLAGS'
10545 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10546 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10547 cross_compiling=$ac_cv_prog_cc_cross
10548
10549
10550 fi
10551
10552   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
10553   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
10554     for ac_func in tanl
10555 do
10556 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10557 echo "configure:10558: checking for $ac_func" >&5
10558 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10559   echo $ac_n "(cached) $ac_c" 1>&6
10560 else
10561   cat > conftest.$ac_ext <<EOF
10562 #line 10563 "configure"
10563 #include "confdefs.h"
10564 /* System header to define __stub macros and hopefully few prototypes,
10565     which can conflict with char $ac_func(); below.  */
10566 #include <assert.h>
10567 /* Override any gcc2 internal prototype to avoid an error.  */
10568 /* We use char because int might match the return type of a gcc2
10569     builtin and then its argument prototype would still apply.  */
10570 char $ac_func();
10571
10572 int main() {
10573
10574 /* The GNU C library defines this for functions which it implements
10575     to always fail with ENOSYS.  Some functions are actually named
10576     something starting with __ and the normal name is an alias.  */
10577 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10578 choke me
10579 #else
10580 $ac_func();
10581 #endif
10582
10583 ; return 0; }
10584 EOF
10585 if { (eval echo configure:10586: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10586   rm -rf conftest*
10587   eval "ac_cv_func_$ac_func=yes"
10588 else
10589   echo "configure: failed program was:" >&5
10590   cat conftest.$ac_ext >&5
10591   rm -rf conftest*
10592   eval "ac_cv_func_$ac_func=no"
10593 fi
10594 rm -f conftest*
10595 fi
10596
10597 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10598   echo "$ac_t""yes" 1>&6
10599     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10600   cat >> confdefs.h <<EOF
10601 #define $ac_tr_func 1
10602 EOF
10603
10604 else
10605   echo "$ac_t""no" 1>&6
10606 fi
10607 done
10608
10609   fi
10610
10611
10612   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
10613 echo "configure:10614: checking for tanhl declaration" >&5
10614   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
10615   echo $ac_n "(cached) $ac_c" 1>&6
10616 else
10617
10618
10619     ac_ext=C
10620 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10621 ac_cpp='$CXXCPP $CPPFLAGS'
10622 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10623 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10624 cross_compiling=$ac_cv_prog_cxx_cross
10625
10626     cat > conftest.$ac_ext <<EOF
10627 #line 10628 "configure"
10628 #include "confdefs.h"
10629 #include <math.h>
10630 int main() {
10631  tanhl(0);
10632 ; return 0; }
10633 EOF
10634 if { (eval echo configure:10635: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10635   rm -rf conftest*
10636   glibcpp_cv_func_tanhl_use=yes
10637 else
10638   echo "configure: failed program was:" >&5
10639   cat conftest.$ac_ext >&5
10640   rm -rf conftest*
10641   glibcpp_cv_func_tanhl_use=no
10642 fi
10643 rm -f conftest*
10644     ac_ext=c
10645 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10646 ac_cpp='$CPP $CPPFLAGS'
10647 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10648 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10649 cross_compiling=$ac_cv_prog_cc_cross
10650
10651
10652 fi
10653
10654   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
10655   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
10656     for ac_func in tanhl
10657 do
10658 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10659 echo "configure:10660: checking for $ac_func" >&5
10660 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10661   echo $ac_n "(cached) $ac_c" 1>&6
10662 else
10663   cat > conftest.$ac_ext <<EOF
10664 #line 10665 "configure"
10665 #include "confdefs.h"
10666 /* System header to define __stub macros and hopefully few prototypes,
10667     which can conflict with char $ac_func(); below.  */
10668 #include <assert.h>
10669 /* Override any gcc2 internal prototype to avoid an error.  */
10670 /* We use char because int might match the return type of a gcc2
10671     builtin and then its argument prototype would still apply.  */
10672 char $ac_func();
10673
10674 int main() {
10675
10676 /* The GNU C library defines this for functions which it implements
10677     to always fail with ENOSYS.  Some functions are actually named
10678     something starting with __ and the normal name is an alias.  */
10679 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10680 choke me
10681 #else
10682 $ac_func();
10683 #endif
10684
10685 ; return 0; }
10686 EOF
10687 if { (eval echo configure:10688: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10688   rm -rf conftest*
10689   eval "ac_cv_func_$ac_func=yes"
10690 else
10691   echo "configure: failed program was:" >&5
10692   cat conftest.$ac_ext >&5
10693   rm -rf conftest*
10694   eval "ac_cv_func_$ac_func=no"
10695 fi
10696 rm -f conftest*
10697 fi
10698
10699 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10700   echo "$ac_t""yes" 1>&6
10701     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10702   cat >> confdefs.h <<EOF
10703 #define $ac_tr_func 1
10704 EOF
10705
10706 else
10707   echo "$ac_t""no" 1>&6
10708 fi
10709 done
10710
10711   fi
10712
10713
10714   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
10715 echo "configure:10716: checking for sincosl declaration" >&5
10716   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
10717   echo $ac_n "(cached) $ac_c" 1>&6
10718 else
10719
10720
10721     ac_ext=C
10722 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10723 ac_cpp='$CXXCPP $CPPFLAGS'
10724 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10725 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10726 cross_compiling=$ac_cv_prog_cxx_cross
10727
10728     cat > conftest.$ac_ext <<EOF
10729 #line 10730 "configure"
10730 #include "confdefs.h"
10731 #include <math.h>
10732 int main() {
10733  sincosl(0, 0, 0);
10734 ; return 0; }
10735 EOF
10736 if { (eval echo configure:10737: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10737   rm -rf conftest*
10738   glibcpp_cv_func_sincosl_use=yes
10739 else
10740   echo "configure: failed program was:" >&5
10741   cat conftest.$ac_ext >&5
10742   rm -rf conftest*
10743   glibcpp_cv_func_sincosl_use=no
10744 fi
10745 rm -f conftest*
10746     ac_ext=c
10747 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10748 ac_cpp='$CPP $CPPFLAGS'
10749 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10750 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10751 cross_compiling=$ac_cv_prog_cc_cross
10752
10753
10754 fi
10755
10756   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
10757   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
10758     for ac_func in sincosl
10759 do
10760 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10761 echo "configure:10762: checking for $ac_func" >&5
10762 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10763   echo $ac_n "(cached) $ac_c" 1>&6
10764 else
10765   cat > conftest.$ac_ext <<EOF
10766 #line 10767 "configure"
10767 #include "confdefs.h"
10768 /* System header to define __stub macros and hopefully few prototypes,
10769     which can conflict with char $ac_func(); below.  */
10770 #include <assert.h>
10771 /* Override any gcc2 internal prototype to avoid an error.  */
10772 /* We use char because int might match the return type of a gcc2
10773     builtin and then its argument prototype would still apply.  */
10774 char $ac_func();
10775
10776 int main() {
10777
10778 /* The GNU C library defines this for functions which it implements
10779     to always fail with ENOSYS.  Some functions are actually named
10780     something starting with __ and the normal name is an alias.  */
10781 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10782 choke me
10783 #else
10784 $ac_func();
10785 #endif
10786
10787 ; return 0; }
10788 EOF
10789 if { (eval echo configure:10790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10790   rm -rf conftest*
10791   eval "ac_cv_func_$ac_func=yes"
10792 else
10793   echo "configure: failed program was:" >&5
10794   cat conftest.$ac_ext >&5
10795   rm -rf conftest*
10796   eval "ac_cv_func_$ac_func=no"
10797 fi
10798 rm -f conftest*
10799 fi
10800
10801 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10802   echo "$ac_t""yes" 1>&6
10803     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10804   cat >> confdefs.h <<EOF
10805 #define $ac_tr_func 1
10806 EOF
10807
10808 else
10809   echo "$ac_t""no" 1>&6
10810 fi
10811 done
10812
10813   fi
10814
10815
10816   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10817 echo "configure:10818: checking for finitel declaration" >&5
10818   if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
10819   echo $ac_n "(cached) $ac_c" 1>&6
10820 else
10821
10822
10823     ac_ext=C
10824 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10825 ac_cpp='$CXXCPP $CPPFLAGS'
10826 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10827 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10828 cross_compiling=$ac_cv_prog_cxx_cross
10829
10830     cat > conftest.$ac_ext <<EOF
10831 #line 10832 "configure"
10832 #include "confdefs.h"
10833 #include <math.h>
10834 int main() {
10835  finitel(0);
10836 ; return 0; }
10837 EOF
10838 if { (eval echo configure:10839: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10839   rm -rf conftest*
10840   glibcpp_cv_func_finitel_use=yes
10841 else
10842   echo "configure: failed program was:" >&5
10843   cat conftest.$ac_ext >&5
10844   rm -rf conftest*
10845   glibcpp_cv_func_finitel_use=no
10846 fi
10847 rm -f conftest*
10848     ac_ext=c
10849 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10850 ac_cpp='$CPP $CPPFLAGS'
10851 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10852 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10853 cross_compiling=$ac_cv_prog_cc_cross
10854
10855
10856 fi
10857
10858   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
10859   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
10860     for ac_func in finitel
10861 do
10862 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10863 echo "configure:10864: checking for $ac_func" >&5
10864 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10865   echo $ac_n "(cached) $ac_c" 1>&6
10866 else
10867   cat > conftest.$ac_ext <<EOF
10868 #line 10869 "configure"
10869 #include "confdefs.h"
10870 /* System header to define __stub macros and hopefully few prototypes,
10871     which can conflict with char $ac_func(); below.  */
10872 #include <assert.h>
10873 /* Override any gcc2 internal prototype to avoid an error.  */
10874 /* We use char because int might match the return type of a gcc2
10875     builtin and then its argument prototype would still apply.  */
10876 char $ac_func();
10877
10878 int main() {
10879
10880 /* The GNU C library defines this for functions which it implements
10881     to always fail with ENOSYS.  Some functions are actually named
10882     something starting with __ and the normal name is an alias.  */
10883 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10884 choke me
10885 #else
10886 $ac_func();
10887 #endif
10888
10889 ; return 0; }
10890 EOF
10891 if { (eval echo configure:10892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10892   rm -rf conftest*
10893   eval "ac_cv_func_$ac_func=yes"
10894 else
10895   echo "configure: failed program was:" >&5
10896   cat conftest.$ac_ext >&5
10897   rm -rf conftest*
10898   eval "ac_cv_func_$ac_func=no"
10899 fi
10900 rm -f conftest*
10901 fi
10902
10903 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10904   echo "$ac_t""yes" 1>&6
10905     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10906   cat >> confdefs.h <<EOF
10907 #define $ac_tr_func 1
10908 EOF
10909
10910 else
10911   echo "$ac_t""no" 1>&6
10912 fi
10913 done
10914
10915   fi
10916
10917
10918
10919   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
10920 echo "configure:10921: checking for _isinf declaration" >&5
10921   if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
10922   echo $ac_n "(cached) $ac_c" 1>&6
10923 else
10924
10925
10926     ac_ext=C
10927 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10928 ac_cpp='$CXXCPP $CPPFLAGS'
10929 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10930 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10931 cross_compiling=$ac_cv_prog_cxx_cross
10932
10933     cat > conftest.$ac_ext <<EOF
10934 #line 10935 "configure"
10935 #include "confdefs.h"
10936 #include <math.h>
10937 int main() {
10938  _isinf(0);
10939 ; return 0; }
10940 EOF
10941 if { (eval echo configure:10942: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10942   rm -rf conftest*
10943   glibcpp_cv_func__isinf_use=yes
10944 else
10945   echo "configure: failed program was:" >&5
10946   cat conftest.$ac_ext >&5
10947   rm -rf conftest*
10948   glibcpp_cv_func__isinf_use=no
10949 fi
10950 rm -f conftest*
10951     ac_ext=c
10952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10953 ac_cpp='$CPP $CPPFLAGS'
10954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10956 cross_compiling=$ac_cv_prog_cc_cross
10957
10958
10959 fi
10960
10961   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
10962   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
10963     for ac_func in _isinf
10964 do
10965 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10966 echo "configure:10967: checking for $ac_func" >&5
10967 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10968   echo $ac_n "(cached) $ac_c" 1>&6
10969 else
10970   cat > conftest.$ac_ext <<EOF
10971 #line 10972 "configure"
10972 #include "confdefs.h"
10973 /* System header to define __stub macros and hopefully few prototypes,
10974     which can conflict with char $ac_func(); below.  */
10975 #include <assert.h>
10976 /* Override any gcc2 internal prototype to avoid an error.  */
10977 /* We use char because int might match the return type of a gcc2
10978     builtin and then its argument prototype would still apply.  */
10979 char $ac_func();
10980
10981 int main() {
10982
10983 /* The GNU C library defines this for functions which it implements
10984     to always fail with ENOSYS.  Some functions are actually named
10985     something starting with __ and the normal name is an alias.  */
10986 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10987 choke me
10988 #else
10989 $ac_func();
10990 #endif
10991
10992 ; return 0; }
10993 EOF
10994 if { (eval echo configure:10995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10995   rm -rf conftest*
10996   eval "ac_cv_func_$ac_func=yes"
10997 else
10998   echo "configure: failed program was:" >&5
10999   cat conftest.$ac_ext >&5
11000   rm -rf conftest*
11001   eval "ac_cv_func_$ac_func=no"
11002 fi
11003 rm -f conftest*
11004 fi
11005
11006 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11007   echo "$ac_t""yes" 1>&6
11008     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11009   cat >> confdefs.h <<EOF
11010 #define $ac_tr_func 1
11011 EOF
11012
11013 else
11014   echo "$ac_t""no" 1>&6
11015 fi
11016 done
11017
11018   fi
11019
11020
11021   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
11022 echo "configure:11023: checking for _isnan declaration" >&5
11023   if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
11024   echo $ac_n "(cached) $ac_c" 1>&6
11025 else
11026
11027
11028     ac_ext=C
11029 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11030 ac_cpp='$CXXCPP $CPPFLAGS'
11031 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11032 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11033 cross_compiling=$ac_cv_prog_cxx_cross
11034
11035     cat > conftest.$ac_ext <<EOF
11036 #line 11037 "configure"
11037 #include "confdefs.h"
11038 #include <math.h>
11039 int main() {
11040  _isnan(0);
11041 ; return 0; }
11042 EOF
11043 if { (eval echo configure:11044: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11044   rm -rf conftest*
11045   glibcpp_cv_func__isnan_use=yes
11046 else
11047   echo "configure: failed program was:" >&5
11048   cat conftest.$ac_ext >&5
11049   rm -rf conftest*
11050   glibcpp_cv_func__isnan_use=no
11051 fi
11052 rm -f conftest*
11053     ac_ext=c
11054 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11055 ac_cpp='$CPP $CPPFLAGS'
11056 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11057 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11058 cross_compiling=$ac_cv_prog_cc_cross
11059
11060
11061 fi
11062
11063   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
11064   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
11065     for ac_func in _isnan
11066 do
11067 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11068 echo "configure:11069: checking for $ac_func" >&5
11069 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11070   echo $ac_n "(cached) $ac_c" 1>&6
11071 else
11072   cat > conftest.$ac_ext <<EOF
11073 #line 11074 "configure"
11074 #include "confdefs.h"
11075 /* System header to define __stub macros and hopefully few prototypes,
11076     which can conflict with char $ac_func(); below.  */
11077 #include <assert.h>
11078 /* Override any gcc2 internal prototype to avoid an error.  */
11079 /* We use char because int might match the return type of a gcc2
11080     builtin and then its argument prototype would still apply.  */
11081 char $ac_func();
11082
11083 int main() {
11084
11085 /* The GNU C library defines this for functions which it implements
11086     to always fail with ENOSYS.  Some functions are actually named
11087     something starting with __ and the normal name is an alias.  */
11088 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11089 choke me
11090 #else
11091 $ac_func();
11092 #endif
11093
11094 ; return 0; }
11095 EOF
11096 if { (eval echo configure:11097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11097   rm -rf conftest*
11098   eval "ac_cv_func_$ac_func=yes"
11099 else
11100   echo "configure: failed program was:" >&5
11101   cat conftest.$ac_ext >&5
11102   rm -rf conftest*
11103   eval "ac_cv_func_$ac_func=no"
11104 fi
11105 rm -f conftest*
11106 fi
11107
11108 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11109   echo "$ac_t""yes" 1>&6
11110     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11111   cat >> confdefs.h <<EOF
11112 #define $ac_tr_func 1
11113 EOF
11114
11115 else
11116   echo "$ac_t""no" 1>&6
11117 fi
11118 done
11119
11120   fi
11121
11122
11123   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
11124 echo "configure:11125: checking for _finite declaration" >&5
11125   if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
11126   echo $ac_n "(cached) $ac_c" 1>&6
11127 else
11128
11129
11130     ac_ext=C
11131 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11132 ac_cpp='$CXXCPP $CPPFLAGS'
11133 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11134 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11135 cross_compiling=$ac_cv_prog_cxx_cross
11136
11137     cat > conftest.$ac_ext <<EOF
11138 #line 11139 "configure"
11139 #include "confdefs.h"
11140 #include <math.h>
11141 int main() {
11142  _finite(0);
11143 ; return 0; }
11144 EOF
11145 if { (eval echo configure:11146: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11146   rm -rf conftest*
11147   glibcpp_cv_func__finite_use=yes
11148 else
11149   echo "configure: failed program was:" >&5
11150   cat conftest.$ac_ext >&5
11151   rm -rf conftest*
11152   glibcpp_cv_func__finite_use=no
11153 fi
11154 rm -f conftest*
11155     ac_ext=c
11156 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11157 ac_cpp='$CPP $CPPFLAGS'
11158 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11159 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11160 cross_compiling=$ac_cv_prog_cc_cross
11161
11162
11163 fi
11164
11165   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
11166   if test x$glibcpp_cv_func__finite_use = x"yes"; then
11167     for ac_func in _finite
11168 do
11169 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11170 echo "configure:11171: checking for $ac_func" >&5
11171 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11172   echo $ac_n "(cached) $ac_c" 1>&6
11173 else
11174   cat > conftest.$ac_ext <<EOF
11175 #line 11176 "configure"
11176 #include "confdefs.h"
11177 /* System header to define __stub macros and hopefully few prototypes,
11178     which can conflict with char $ac_func(); below.  */
11179 #include <assert.h>
11180 /* Override any gcc2 internal prototype to avoid an error.  */
11181 /* We use char because int might match the return type of a gcc2
11182     builtin and then its argument prototype would still apply.  */
11183 char $ac_func();
11184
11185 int main() {
11186
11187 /* The GNU C library defines this for functions which it implements
11188     to always fail with ENOSYS.  Some functions are actually named
11189     something starting with __ and the normal name is an alias.  */
11190 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11191 choke me
11192 #else
11193 $ac_func();
11194 #endif
11195
11196 ; return 0; }
11197 EOF
11198 if { (eval echo configure:11199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11199   rm -rf conftest*
11200   eval "ac_cv_func_$ac_func=yes"
11201 else
11202   echo "configure: failed program was:" >&5
11203   cat conftest.$ac_ext >&5
11204   rm -rf conftest*
11205   eval "ac_cv_func_$ac_func=no"
11206 fi
11207 rm -f conftest*
11208 fi
11209
11210 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11211   echo "$ac_t""yes" 1>&6
11212     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11213   cat >> confdefs.h <<EOF
11214 #define $ac_tr_func 1
11215 EOF
11216
11217 else
11218   echo "$ac_t""no" 1>&6
11219 fi
11220 done
11221
11222   fi
11223
11224
11225   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
11226 echo "configure:11227: checking for _copysign declaration" >&5
11227   if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
11228   echo $ac_n "(cached) $ac_c" 1>&6
11229 else
11230
11231
11232     ac_ext=C
11233 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11234 ac_cpp='$CXXCPP $CPPFLAGS'
11235 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11236 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11237 cross_compiling=$ac_cv_prog_cxx_cross
11238
11239     cat > conftest.$ac_ext <<EOF
11240 #line 11241 "configure"
11241 #include "confdefs.h"
11242 #include <math.h>
11243 int main() {
11244  _copysign(0, 0);
11245 ; return 0; }
11246 EOF
11247 if { (eval echo configure:11248: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11248   rm -rf conftest*
11249   glibcpp_cv_func__copysign_use=yes
11250 else
11251   echo "configure: failed program was:" >&5
11252   cat conftest.$ac_ext >&5
11253   rm -rf conftest*
11254   glibcpp_cv_func__copysign_use=no
11255 fi
11256 rm -f conftest*
11257     ac_ext=c
11258 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11259 ac_cpp='$CPP $CPPFLAGS'
11260 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11261 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11262 cross_compiling=$ac_cv_prog_cc_cross
11263
11264
11265 fi
11266
11267   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
11268   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
11269     for ac_func in _copysign
11270 do
11271 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11272 echo "configure:11273: checking for $ac_func" >&5
11273 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11274   echo $ac_n "(cached) $ac_c" 1>&6
11275 else
11276   cat > conftest.$ac_ext <<EOF
11277 #line 11278 "configure"
11278 #include "confdefs.h"
11279 /* System header to define __stub macros and hopefully few prototypes,
11280     which can conflict with char $ac_func(); below.  */
11281 #include <assert.h>
11282 /* Override any gcc2 internal prototype to avoid an error.  */
11283 /* We use char because int might match the return type of a gcc2
11284     builtin and then its argument prototype would still apply.  */
11285 char $ac_func();
11286
11287 int main() {
11288
11289 /* The GNU C library defines this for functions which it implements
11290     to always fail with ENOSYS.  Some functions are actually named
11291     something starting with __ and the normal name is an alias.  */
11292 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11293 choke me
11294 #else
11295 $ac_func();
11296 #endif
11297
11298 ; return 0; }
11299 EOF
11300 if { (eval echo configure:11301: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11301   rm -rf conftest*
11302   eval "ac_cv_func_$ac_func=yes"
11303 else
11304   echo "configure: failed program was:" >&5
11305   cat conftest.$ac_ext >&5
11306   rm -rf conftest*
11307   eval "ac_cv_func_$ac_func=no"
11308 fi
11309 rm -f conftest*
11310 fi
11311
11312 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11313   echo "$ac_t""yes" 1>&6
11314     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11315   cat >> confdefs.h <<EOF
11316 #define $ac_tr_func 1
11317 EOF
11318
11319 else
11320   echo "$ac_t""no" 1>&6
11321 fi
11322 done
11323
11324   fi
11325
11326
11327   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
11328 echo "configure:11329: checking for _sincos declaration" >&5
11329   if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
11330   echo $ac_n "(cached) $ac_c" 1>&6
11331 else
11332
11333
11334     ac_ext=C
11335 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11336 ac_cpp='$CXXCPP $CPPFLAGS'
11337 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11338 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11339 cross_compiling=$ac_cv_prog_cxx_cross
11340
11341     cat > conftest.$ac_ext <<EOF
11342 #line 11343 "configure"
11343 #include "confdefs.h"
11344 #include <math.h>
11345 int main() {
11346  _sincos(0, 0, 0);
11347 ; return 0; }
11348 EOF
11349 if { (eval echo configure:11350: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11350   rm -rf conftest*
11351   glibcpp_cv_func__sincos_use=yes
11352 else
11353   echo "configure: failed program was:" >&5
11354   cat conftest.$ac_ext >&5
11355   rm -rf conftest*
11356   glibcpp_cv_func__sincos_use=no
11357 fi
11358 rm -f conftest*
11359     ac_ext=c
11360 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11361 ac_cpp='$CPP $CPPFLAGS'
11362 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11363 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11364 cross_compiling=$ac_cv_prog_cc_cross
11365
11366
11367 fi
11368
11369   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
11370   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
11371     for ac_func in _sincos
11372 do
11373 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11374 echo "configure:11375: checking for $ac_func" >&5
11375 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11376   echo $ac_n "(cached) $ac_c" 1>&6
11377 else
11378   cat > conftest.$ac_ext <<EOF
11379 #line 11380 "configure"
11380 #include "confdefs.h"
11381 /* System header to define __stub macros and hopefully few prototypes,
11382     which can conflict with char $ac_func(); below.  */
11383 #include <assert.h>
11384 /* Override any gcc2 internal prototype to avoid an error.  */
11385 /* We use char because int might match the return type of a gcc2
11386     builtin and then its argument prototype would still apply.  */
11387 char $ac_func();
11388
11389 int main() {
11390
11391 /* The GNU C library defines this for functions which it implements
11392     to always fail with ENOSYS.  Some functions are actually named
11393     something starting with __ and the normal name is an alias.  */
11394 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11395 choke me
11396 #else
11397 $ac_func();
11398 #endif
11399
11400 ; return 0; }
11401 EOF
11402 if { (eval echo configure:11403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11403   rm -rf conftest*
11404   eval "ac_cv_func_$ac_func=yes"
11405 else
11406   echo "configure: failed program was:" >&5
11407   cat conftest.$ac_ext >&5
11408   rm -rf conftest*
11409   eval "ac_cv_func_$ac_func=no"
11410 fi
11411 rm -f conftest*
11412 fi
11413
11414 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11415   echo "$ac_t""yes" 1>&6
11416     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11417   cat >> confdefs.h <<EOF
11418 #define $ac_tr_func 1
11419 EOF
11420
11421 else
11422   echo "$ac_t""no" 1>&6
11423 fi
11424 done
11425
11426   fi
11427
11428
11429   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
11430 echo "configure:11431: checking for _fpclass declaration" >&5
11431   if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
11432   echo $ac_n "(cached) $ac_c" 1>&6
11433 else
11434
11435
11436     ac_ext=C
11437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11438 ac_cpp='$CXXCPP $CPPFLAGS'
11439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11441 cross_compiling=$ac_cv_prog_cxx_cross
11442
11443     cat > conftest.$ac_ext <<EOF
11444 #line 11445 "configure"
11445 #include "confdefs.h"
11446 #include <math.h>
11447 int main() {
11448  _fpclass(0);
11449 ; return 0; }
11450 EOF
11451 if { (eval echo configure:11452: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11452   rm -rf conftest*
11453   glibcpp_cv_func__fpclass_use=yes
11454 else
11455   echo "configure: failed program was:" >&5
11456   cat conftest.$ac_ext >&5
11457   rm -rf conftest*
11458   glibcpp_cv_func__fpclass_use=no
11459 fi
11460 rm -f conftest*
11461     ac_ext=c
11462 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11463 ac_cpp='$CPP $CPPFLAGS'
11464 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11465 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11466 cross_compiling=$ac_cv_prog_cc_cross
11467
11468
11469 fi
11470
11471   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
11472   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
11473     for ac_func in _fpclass
11474 do
11475 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11476 echo "configure:11477: checking for $ac_func" >&5
11477 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11478   echo $ac_n "(cached) $ac_c" 1>&6
11479 else
11480   cat > conftest.$ac_ext <<EOF
11481 #line 11482 "configure"
11482 #include "confdefs.h"
11483 /* System header to define __stub macros and hopefully few prototypes,
11484     which can conflict with char $ac_func(); below.  */
11485 #include <assert.h>
11486 /* Override any gcc2 internal prototype to avoid an error.  */
11487 /* We use char because int might match the return type of a gcc2
11488     builtin and then its argument prototype would still apply.  */
11489 char $ac_func();
11490
11491 int main() {
11492
11493 /* The GNU C library defines this for functions which it implements
11494     to always fail with ENOSYS.  Some functions are actually named
11495     something starting with __ and the normal name is an alias.  */
11496 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11497 choke me
11498 #else
11499 $ac_func();
11500 #endif
11501
11502 ; return 0; }
11503 EOF
11504 if { (eval echo configure:11505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11505   rm -rf conftest*
11506   eval "ac_cv_func_$ac_func=yes"
11507 else
11508   echo "configure: failed program was:" >&5
11509   cat conftest.$ac_ext >&5
11510   rm -rf conftest*
11511   eval "ac_cv_func_$ac_func=no"
11512 fi
11513 rm -f conftest*
11514 fi
11515
11516 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11517   echo "$ac_t""yes" 1>&6
11518     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11519   cat >> confdefs.h <<EOF
11520 #define $ac_tr_func 1
11521 EOF
11522
11523 else
11524   echo "$ac_t""no" 1>&6
11525 fi
11526 done
11527
11528   fi
11529
11530
11531   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
11532 echo "configure:11533: checking for _qfpclass declaration" >&5
11533   if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
11534   echo $ac_n "(cached) $ac_c" 1>&6
11535 else
11536
11537
11538     ac_ext=C
11539 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11540 ac_cpp='$CXXCPP $CPPFLAGS'
11541 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11542 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11543 cross_compiling=$ac_cv_prog_cxx_cross
11544
11545     cat > conftest.$ac_ext <<EOF
11546 #line 11547 "configure"
11547 #include "confdefs.h"
11548 #include <math.h>
11549 int main() {
11550  _qfpclass(0);
11551 ; return 0; }
11552 EOF
11553 if { (eval echo configure:11554: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11554   rm -rf conftest*
11555   glibcpp_cv_func__qfpclass_use=yes
11556 else
11557   echo "configure: failed program was:" >&5
11558   cat conftest.$ac_ext >&5
11559   rm -rf conftest*
11560   glibcpp_cv_func__qfpclass_use=no
11561 fi
11562 rm -f conftest*
11563     ac_ext=c
11564 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11565 ac_cpp='$CPP $CPPFLAGS'
11566 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11567 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11568 cross_compiling=$ac_cv_prog_cc_cross
11569
11570
11571 fi
11572
11573   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
11574   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
11575     for ac_func in _qfpclass
11576 do
11577 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11578 echo "configure:11579: checking for $ac_func" >&5
11579 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11580   echo $ac_n "(cached) $ac_c" 1>&6
11581 else
11582   cat > conftest.$ac_ext <<EOF
11583 #line 11584 "configure"
11584 #include "confdefs.h"
11585 /* System header to define __stub macros and hopefully few prototypes,
11586     which can conflict with char $ac_func(); below.  */
11587 #include <assert.h>
11588 /* Override any gcc2 internal prototype to avoid an error.  */
11589 /* We use char because int might match the return type of a gcc2
11590     builtin and then its argument prototype would still apply.  */
11591 char $ac_func();
11592
11593 int main() {
11594
11595 /* The GNU C library defines this for functions which it implements
11596     to always fail with ENOSYS.  Some functions are actually named
11597     something starting with __ and the normal name is an alias.  */
11598 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11599 choke me
11600 #else
11601 $ac_func();
11602 #endif
11603
11604 ; return 0; }
11605 EOF
11606 if { (eval echo configure:11607: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11607   rm -rf conftest*
11608   eval "ac_cv_func_$ac_func=yes"
11609 else
11610   echo "configure: failed program was:" >&5
11611   cat conftest.$ac_ext >&5
11612   rm -rf conftest*
11613   eval "ac_cv_func_$ac_func=no"
11614 fi
11615 rm -f conftest*
11616 fi
11617
11618 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11619   echo "$ac_t""yes" 1>&6
11620     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11621   cat >> confdefs.h <<EOF
11622 #define $ac_tr_func 1
11623 EOF
11624
11625 else
11626   echo "$ac_t""no" 1>&6
11627 fi
11628 done
11629
11630   fi
11631
11632
11633
11634   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11635 echo "configure:11636: checking for _isnanf declaration" >&5
11636   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
11637   echo $ac_n "(cached) $ac_c" 1>&6
11638 else
11639
11640
11641     ac_ext=C
11642 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11643 ac_cpp='$CXXCPP $CPPFLAGS'
11644 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11645 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11646 cross_compiling=$ac_cv_prog_cxx_cross
11647
11648     cat > conftest.$ac_ext <<EOF
11649 #line 11650 "configure"
11650 #include "confdefs.h"
11651 #include <math.h>
11652 int main() {
11653  _isnanf(0);
11654 ; return 0; }
11655 EOF
11656 if { (eval echo configure:11657: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11657   rm -rf conftest*
11658   glibcpp_cv_func__isnanf_use=yes
11659 else
11660   echo "configure: failed program was:" >&5
11661   cat conftest.$ac_ext >&5
11662   rm -rf conftest*
11663   glibcpp_cv_func__isnanf_use=no
11664 fi
11665 rm -f conftest*
11666     ac_ext=c
11667 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11668 ac_cpp='$CPP $CPPFLAGS'
11669 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11670 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11671 cross_compiling=$ac_cv_prog_cc_cross
11672
11673
11674 fi
11675
11676   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
11677   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
11678     for ac_func in _isnanf
11679 do
11680 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11681 echo "configure:11682: checking for $ac_func" >&5
11682 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11683   echo $ac_n "(cached) $ac_c" 1>&6
11684 else
11685   cat > conftest.$ac_ext <<EOF
11686 #line 11687 "configure"
11687 #include "confdefs.h"
11688 /* System header to define __stub macros and hopefully few prototypes,
11689     which can conflict with char $ac_func(); below.  */
11690 #include <assert.h>
11691 /* Override any gcc2 internal prototype to avoid an error.  */
11692 /* We use char because int might match the return type of a gcc2
11693     builtin and then its argument prototype would still apply.  */
11694 char $ac_func();
11695
11696 int main() {
11697
11698 /* The GNU C library defines this for functions which it implements
11699     to always fail with ENOSYS.  Some functions are actually named
11700     something starting with __ and the normal name is an alias.  */
11701 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11702 choke me
11703 #else
11704 $ac_func();
11705 #endif
11706
11707 ; return 0; }
11708 EOF
11709 if { (eval echo configure:11710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11710   rm -rf conftest*
11711   eval "ac_cv_func_$ac_func=yes"
11712 else
11713   echo "configure: failed program was:" >&5
11714   cat conftest.$ac_ext >&5
11715   rm -rf conftest*
11716   eval "ac_cv_func_$ac_func=no"
11717 fi
11718 rm -f conftest*
11719 fi
11720
11721 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11722   echo "$ac_t""yes" 1>&6
11723     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11724   cat >> confdefs.h <<EOF
11725 #define $ac_tr_func 1
11726 EOF
11727
11728 else
11729   echo "$ac_t""no" 1>&6
11730 fi
11731 done
11732
11733   fi
11734
11735
11736   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11737 echo "configure:11738: checking for _isinff declaration" >&5
11738   if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
11739   echo $ac_n "(cached) $ac_c" 1>&6
11740 else
11741
11742
11743     ac_ext=C
11744 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11745 ac_cpp='$CXXCPP $CPPFLAGS'
11746 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11747 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11748 cross_compiling=$ac_cv_prog_cxx_cross
11749
11750     cat > conftest.$ac_ext <<EOF
11751 #line 11752 "configure"
11752 #include "confdefs.h"
11753 #include <math.h>
11754 int main() {
11755  _isinff(0);
11756 ; return 0; }
11757 EOF
11758 if { (eval echo configure:11759: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11759   rm -rf conftest*
11760   glibcpp_cv_func__isinff_use=yes
11761 else
11762   echo "configure: failed program was:" >&5
11763   cat conftest.$ac_ext >&5
11764   rm -rf conftest*
11765   glibcpp_cv_func__isinff_use=no
11766 fi
11767 rm -f conftest*
11768     ac_ext=c
11769 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11770 ac_cpp='$CPP $CPPFLAGS'
11771 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11772 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11773 cross_compiling=$ac_cv_prog_cc_cross
11774
11775
11776 fi
11777
11778   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
11779   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
11780     for ac_func in _isinff
11781 do
11782 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11783 echo "configure:11784: checking for $ac_func" >&5
11784 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11785   echo $ac_n "(cached) $ac_c" 1>&6
11786 else
11787   cat > conftest.$ac_ext <<EOF
11788 #line 11789 "configure"
11789 #include "confdefs.h"
11790 /* System header to define __stub macros and hopefully few prototypes,
11791     which can conflict with char $ac_func(); below.  */
11792 #include <assert.h>
11793 /* Override any gcc2 internal prototype to avoid an error.  */
11794 /* We use char because int might match the return type of a gcc2
11795     builtin and then its argument prototype would still apply.  */
11796 char $ac_func();
11797
11798 int main() {
11799
11800 /* The GNU C library defines this for functions which it implements
11801     to always fail with ENOSYS.  Some functions are actually named
11802     something starting with __ and the normal name is an alias.  */
11803 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11804 choke me
11805 #else
11806 $ac_func();
11807 #endif
11808
11809 ; return 0; }
11810 EOF
11811 if { (eval echo configure:11812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11812   rm -rf conftest*
11813   eval "ac_cv_func_$ac_func=yes"
11814 else
11815   echo "configure: failed program was:" >&5
11816   cat conftest.$ac_ext >&5
11817   rm -rf conftest*
11818   eval "ac_cv_func_$ac_func=no"
11819 fi
11820 rm -f conftest*
11821 fi
11822
11823 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11824   echo "$ac_t""yes" 1>&6
11825     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11826   cat >> confdefs.h <<EOF
11827 #define $ac_tr_func 1
11828 EOF
11829
11830 else
11831   echo "$ac_t""no" 1>&6
11832 fi
11833 done
11834
11835   fi
11836
11837
11838   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11839 echo "configure:11840: checking for _acosf declaration" >&5
11840   if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
11841   echo $ac_n "(cached) $ac_c" 1>&6
11842 else
11843
11844
11845     ac_ext=C
11846 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11847 ac_cpp='$CXXCPP $CPPFLAGS'
11848 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11849 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11850 cross_compiling=$ac_cv_prog_cxx_cross
11851
11852     cat > conftest.$ac_ext <<EOF
11853 #line 11854 "configure"
11854 #include "confdefs.h"
11855 #include <math.h>
11856 int main() {
11857  _acosf(0);
11858 ; return 0; }
11859 EOF
11860 if { (eval echo configure:11861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11861   rm -rf conftest*
11862   glibcpp_cv_func__acosf_use=yes
11863 else
11864   echo "configure: failed program was:" >&5
11865   cat conftest.$ac_ext >&5
11866   rm -rf conftest*
11867   glibcpp_cv_func__acosf_use=no
11868 fi
11869 rm -f conftest*
11870     ac_ext=c
11871 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11872 ac_cpp='$CPP $CPPFLAGS'
11873 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11874 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11875 cross_compiling=$ac_cv_prog_cc_cross
11876
11877
11878 fi
11879
11880   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
11881   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
11882     for ac_func in _acosf
11883 do
11884 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11885 echo "configure:11886: checking for $ac_func" >&5
11886 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11887   echo $ac_n "(cached) $ac_c" 1>&6
11888 else
11889   cat > conftest.$ac_ext <<EOF
11890 #line 11891 "configure"
11891 #include "confdefs.h"
11892 /* System header to define __stub macros and hopefully few prototypes,
11893     which can conflict with char $ac_func(); below.  */
11894 #include <assert.h>
11895 /* Override any gcc2 internal prototype to avoid an error.  */
11896 /* We use char because int might match the return type of a gcc2
11897     builtin and then its argument prototype would still apply.  */
11898 char $ac_func();
11899
11900 int main() {
11901
11902 /* The GNU C library defines this for functions which it implements
11903     to always fail with ENOSYS.  Some functions are actually named
11904     something starting with __ and the normal name is an alias.  */
11905 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11906 choke me
11907 #else
11908 $ac_func();
11909 #endif
11910
11911 ; return 0; }
11912 EOF
11913 if { (eval echo configure:11914: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11914   rm -rf conftest*
11915   eval "ac_cv_func_$ac_func=yes"
11916 else
11917   echo "configure: failed program was:" >&5
11918   cat conftest.$ac_ext >&5
11919   rm -rf conftest*
11920   eval "ac_cv_func_$ac_func=no"
11921 fi
11922 rm -f conftest*
11923 fi
11924
11925 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11926   echo "$ac_t""yes" 1>&6
11927     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11928   cat >> confdefs.h <<EOF
11929 #define $ac_tr_func 1
11930 EOF
11931
11932 else
11933   echo "$ac_t""no" 1>&6
11934 fi
11935 done
11936
11937   fi
11938
11939
11940   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11941 echo "configure:11942: checking for _asinf declaration" >&5
11942   if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
11943   echo $ac_n "(cached) $ac_c" 1>&6
11944 else
11945
11946
11947     ac_ext=C
11948 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11949 ac_cpp='$CXXCPP $CPPFLAGS'
11950 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11951 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11952 cross_compiling=$ac_cv_prog_cxx_cross
11953
11954     cat > conftest.$ac_ext <<EOF
11955 #line 11956 "configure"
11956 #include "confdefs.h"
11957 #include <math.h>
11958 int main() {
11959  _asinf(0);
11960 ; return 0; }
11961 EOF
11962 if { (eval echo configure:11963: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11963   rm -rf conftest*
11964   glibcpp_cv_func__asinf_use=yes
11965 else
11966   echo "configure: failed program was:" >&5
11967   cat conftest.$ac_ext >&5
11968   rm -rf conftest*
11969   glibcpp_cv_func__asinf_use=no
11970 fi
11971 rm -f conftest*
11972     ac_ext=c
11973 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11974 ac_cpp='$CPP $CPPFLAGS'
11975 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11976 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11977 cross_compiling=$ac_cv_prog_cc_cross
11978
11979
11980 fi
11981
11982   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
11983   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
11984     for ac_func in _asinf
11985 do
11986 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11987 echo "configure:11988: checking for $ac_func" >&5
11988 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11989   echo $ac_n "(cached) $ac_c" 1>&6
11990 else
11991   cat > conftest.$ac_ext <<EOF
11992 #line 11993 "configure"
11993 #include "confdefs.h"
11994 /* System header to define __stub macros and hopefully few prototypes,
11995     which can conflict with char $ac_func(); below.  */
11996 #include <assert.h>
11997 /* Override any gcc2 internal prototype to avoid an error.  */
11998 /* We use char because int might match the return type of a gcc2
11999     builtin and then its argument prototype would still apply.  */
12000 char $ac_func();
12001
12002 int main() {
12003
12004 /* The GNU C library defines this for functions which it implements
12005     to always fail with ENOSYS.  Some functions are actually named
12006     something starting with __ and the normal name is an alias.  */
12007 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12008 choke me
12009 #else
12010 $ac_func();
12011 #endif
12012
12013 ; return 0; }
12014 EOF
12015 if { (eval echo configure:12016: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12016   rm -rf conftest*
12017   eval "ac_cv_func_$ac_func=yes"
12018 else
12019   echo "configure: failed program was:" >&5
12020   cat conftest.$ac_ext >&5
12021   rm -rf conftest*
12022   eval "ac_cv_func_$ac_func=no"
12023 fi
12024 rm -f conftest*
12025 fi
12026
12027 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12028   echo "$ac_t""yes" 1>&6
12029     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12030   cat >> confdefs.h <<EOF
12031 #define $ac_tr_func 1
12032 EOF
12033
12034 else
12035   echo "$ac_t""no" 1>&6
12036 fi
12037 done
12038
12039   fi
12040
12041
12042   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
12043 echo "configure:12044: checking for _atanf declaration" >&5
12044   if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
12045   echo $ac_n "(cached) $ac_c" 1>&6
12046 else
12047
12048
12049     ac_ext=C
12050 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12051 ac_cpp='$CXXCPP $CPPFLAGS'
12052 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12053 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12054 cross_compiling=$ac_cv_prog_cxx_cross
12055
12056     cat > conftest.$ac_ext <<EOF
12057 #line 12058 "configure"
12058 #include "confdefs.h"
12059 #include <math.h>
12060 int main() {
12061  _atanf(0);
12062 ; return 0; }
12063 EOF
12064 if { (eval echo configure:12065: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12065   rm -rf conftest*
12066   glibcpp_cv_func__atanf_use=yes
12067 else
12068   echo "configure: failed program was:" >&5
12069   cat conftest.$ac_ext >&5
12070   rm -rf conftest*
12071   glibcpp_cv_func__atanf_use=no
12072 fi
12073 rm -f conftest*
12074     ac_ext=c
12075 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12076 ac_cpp='$CPP $CPPFLAGS'
12077 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12078 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12079 cross_compiling=$ac_cv_prog_cc_cross
12080
12081
12082 fi
12083
12084   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
12085   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
12086     for ac_func in _atanf
12087 do
12088 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12089 echo "configure:12090: checking for $ac_func" >&5
12090 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12091   echo $ac_n "(cached) $ac_c" 1>&6
12092 else
12093   cat > conftest.$ac_ext <<EOF
12094 #line 12095 "configure"
12095 #include "confdefs.h"
12096 /* System header to define __stub macros and hopefully few prototypes,
12097     which can conflict with char $ac_func(); below.  */
12098 #include <assert.h>
12099 /* Override any gcc2 internal prototype to avoid an error.  */
12100 /* We use char because int might match the return type of a gcc2
12101     builtin and then its argument prototype would still apply.  */
12102 char $ac_func();
12103
12104 int main() {
12105
12106 /* The GNU C library defines this for functions which it implements
12107     to always fail with ENOSYS.  Some functions are actually named
12108     something starting with __ and the normal name is an alias.  */
12109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12110 choke me
12111 #else
12112 $ac_func();
12113 #endif
12114
12115 ; return 0; }
12116 EOF
12117 if { (eval echo configure:12118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12118   rm -rf conftest*
12119   eval "ac_cv_func_$ac_func=yes"
12120 else
12121   echo "configure: failed program was:" >&5
12122   cat conftest.$ac_ext >&5
12123   rm -rf conftest*
12124   eval "ac_cv_func_$ac_func=no"
12125 fi
12126 rm -f conftest*
12127 fi
12128
12129 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12130   echo "$ac_t""yes" 1>&6
12131     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12132   cat >> confdefs.h <<EOF
12133 #define $ac_tr_func 1
12134 EOF
12135
12136 else
12137   echo "$ac_t""no" 1>&6
12138 fi
12139 done
12140
12141   fi
12142
12143
12144   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
12145 echo "configure:12146: checking for _atan2f declaration" >&5
12146   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
12147   echo $ac_n "(cached) $ac_c" 1>&6
12148 else
12149
12150
12151     ac_ext=C
12152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12153 ac_cpp='$CXXCPP $CPPFLAGS'
12154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12156 cross_compiling=$ac_cv_prog_cxx_cross
12157
12158     cat > conftest.$ac_ext <<EOF
12159 #line 12160 "configure"
12160 #include "confdefs.h"
12161 #include <math.h>
12162 int main() {
12163  _atan2f(0, 0);
12164 ; return 0; }
12165 EOF
12166 if { (eval echo configure:12167: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12167   rm -rf conftest*
12168   glibcpp_cv_func__atan2f_use=yes
12169 else
12170   echo "configure: failed program was:" >&5
12171   cat conftest.$ac_ext >&5
12172   rm -rf conftest*
12173   glibcpp_cv_func__atan2f_use=no
12174 fi
12175 rm -f conftest*
12176     ac_ext=c
12177 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12178 ac_cpp='$CPP $CPPFLAGS'
12179 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12180 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12181 cross_compiling=$ac_cv_prog_cc_cross
12182
12183
12184 fi
12185
12186   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
12187   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
12188     for ac_func in _atan2f
12189 do
12190 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12191 echo "configure:12192: checking for $ac_func" >&5
12192 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12193   echo $ac_n "(cached) $ac_c" 1>&6
12194 else
12195   cat > conftest.$ac_ext <<EOF
12196 #line 12197 "configure"
12197 #include "confdefs.h"
12198 /* System header to define __stub macros and hopefully few prototypes,
12199     which can conflict with char $ac_func(); below.  */
12200 #include <assert.h>
12201 /* Override any gcc2 internal prototype to avoid an error.  */
12202 /* We use char because int might match the return type of a gcc2
12203     builtin and then its argument prototype would still apply.  */
12204 char $ac_func();
12205
12206 int main() {
12207
12208 /* The GNU C library defines this for functions which it implements
12209     to always fail with ENOSYS.  Some functions are actually named
12210     something starting with __ and the normal name is an alias.  */
12211 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12212 choke me
12213 #else
12214 $ac_func();
12215 #endif
12216
12217 ; return 0; }
12218 EOF
12219 if { (eval echo configure:12220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12220   rm -rf conftest*
12221   eval "ac_cv_func_$ac_func=yes"
12222 else
12223   echo "configure: failed program was:" >&5
12224   cat conftest.$ac_ext >&5
12225   rm -rf conftest*
12226   eval "ac_cv_func_$ac_func=no"
12227 fi
12228 rm -f conftest*
12229 fi
12230
12231 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12232   echo "$ac_t""yes" 1>&6
12233     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12234   cat >> confdefs.h <<EOF
12235 #define $ac_tr_func 1
12236 EOF
12237
12238 else
12239   echo "$ac_t""no" 1>&6
12240 fi
12241 done
12242
12243   fi
12244
12245
12246   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
12247 echo "configure:12248: checking for _ceilf declaration" >&5
12248   if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
12249   echo $ac_n "(cached) $ac_c" 1>&6
12250 else
12251
12252
12253     ac_ext=C
12254 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12255 ac_cpp='$CXXCPP $CPPFLAGS'
12256 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12257 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12258 cross_compiling=$ac_cv_prog_cxx_cross
12259
12260     cat > conftest.$ac_ext <<EOF
12261 #line 12262 "configure"
12262 #include "confdefs.h"
12263 #include <math.h>
12264 int main() {
12265  _ceilf(0);
12266 ; return 0; }
12267 EOF
12268 if { (eval echo configure:12269: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12269   rm -rf conftest*
12270   glibcpp_cv_func__ceilf_use=yes
12271 else
12272   echo "configure: failed program was:" >&5
12273   cat conftest.$ac_ext >&5
12274   rm -rf conftest*
12275   glibcpp_cv_func__ceilf_use=no
12276 fi
12277 rm -f conftest*
12278     ac_ext=c
12279 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12280 ac_cpp='$CPP $CPPFLAGS'
12281 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12282 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12283 cross_compiling=$ac_cv_prog_cc_cross
12284
12285
12286 fi
12287
12288   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
12289   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
12290     for ac_func in _ceilf
12291 do
12292 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12293 echo "configure:12294: checking for $ac_func" >&5
12294 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12295   echo $ac_n "(cached) $ac_c" 1>&6
12296 else
12297   cat > conftest.$ac_ext <<EOF
12298 #line 12299 "configure"
12299 #include "confdefs.h"
12300 /* System header to define __stub macros and hopefully few prototypes,
12301     which can conflict with char $ac_func(); below.  */
12302 #include <assert.h>
12303 /* Override any gcc2 internal prototype to avoid an error.  */
12304 /* We use char because int might match the return type of a gcc2
12305     builtin and then its argument prototype would still apply.  */
12306 char $ac_func();
12307
12308 int main() {
12309
12310 /* The GNU C library defines this for functions which it implements
12311     to always fail with ENOSYS.  Some functions are actually named
12312     something starting with __ and the normal name is an alias.  */
12313 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12314 choke me
12315 #else
12316 $ac_func();
12317 #endif
12318
12319 ; return 0; }
12320 EOF
12321 if { (eval echo configure:12322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12322   rm -rf conftest*
12323   eval "ac_cv_func_$ac_func=yes"
12324 else
12325   echo "configure: failed program was:" >&5
12326   cat conftest.$ac_ext >&5
12327   rm -rf conftest*
12328   eval "ac_cv_func_$ac_func=no"
12329 fi
12330 rm -f conftest*
12331 fi
12332
12333 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12334   echo "$ac_t""yes" 1>&6
12335     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12336   cat >> confdefs.h <<EOF
12337 #define $ac_tr_func 1
12338 EOF
12339
12340 else
12341   echo "$ac_t""no" 1>&6
12342 fi
12343 done
12344
12345   fi
12346
12347
12348   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
12349 echo "configure:12350: checking for _cosf declaration" >&5
12350   if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
12351   echo $ac_n "(cached) $ac_c" 1>&6
12352 else
12353
12354
12355     ac_ext=C
12356 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12357 ac_cpp='$CXXCPP $CPPFLAGS'
12358 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12359 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12360 cross_compiling=$ac_cv_prog_cxx_cross
12361
12362     cat > conftest.$ac_ext <<EOF
12363 #line 12364 "configure"
12364 #include "confdefs.h"
12365 #include <math.h>
12366 int main() {
12367  _cosf(0);
12368 ; return 0; }
12369 EOF
12370 if { (eval echo configure:12371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12371   rm -rf conftest*
12372   glibcpp_cv_func__cosf_use=yes
12373 else
12374   echo "configure: failed program was:" >&5
12375   cat conftest.$ac_ext >&5
12376   rm -rf conftest*
12377   glibcpp_cv_func__cosf_use=no
12378 fi
12379 rm -f conftest*
12380     ac_ext=c
12381 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12382 ac_cpp='$CPP $CPPFLAGS'
12383 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12384 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12385 cross_compiling=$ac_cv_prog_cc_cross
12386
12387
12388 fi
12389
12390   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
12391   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
12392     for ac_func in _cosf
12393 do
12394 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12395 echo "configure:12396: checking for $ac_func" >&5
12396 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12397   echo $ac_n "(cached) $ac_c" 1>&6
12398 else
12399   cat > conftest.$ac_ext <<EOF
12400 #line 12401 "configure"
12401 #include "confdefs.h"
12402 /* System header to define __stub macros and hopefully few prototypes,
12403     which can conflict with char $ac_func(); below.  */
12404 #include <assert.h>
12405 /* Override any gcc2 internal prototype to avoid an error.  */
12406 /* We use char because int might match the return type of a gcc2
12407     builtin and then its argument prototype would still apply.  */
12408 char $ac_func();
12409
12410 int main() {
12411
12412 /* The GNU C library defines this for functions which it implements
12413     to always fail with ENOSYS.  Some functions are actually named
12414     something starting with __ and the normal name is an alias.  */
12415 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12416 choke me
12417 #else
12418 $ac_func();
12419 #endif
12420
12421 ; return 0; }
12422 EOF
12423 if { (eval echo configure:12424: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12424   rm -rf conftest*
12425   eval "ac_cv_func_$ac_func=yes"
12426 else
12427   echo "configure: failed program was:" >&5
12428   cat conftest.$ac_ext >&5
12429   rm -rf conftest*
12430   eval "ac_cv_func_$ac_func=no"
12431 fi
12432 rm -f conftest*
12433 fi
12434
12435 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12436   echo "$ac_t""yes" 1>&6
12437     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12438   cat >> confdefs.h <<EOF
12439 #define $ac_tr_func 1
12440 EOF
12441
12442 else
12443   echo "$ac_t""no" 1>&6
12444 fi
12445 done
12446
12447   fi
12448
12449
12450   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12451 echo "configure:12452: checking for _coshf declaration" >&5
12452   if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
12453   echo $ac_n "(cached) $ac_c" 1>&6
12454 else
12455
12456
12457     ac_ext=C
12458 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12459 ac_cpp='$CXXCPP $CPPFLAGS'
12460 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12461 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12462 cross_compiling=$ac_cv_prog_cxx_cross
12463
12464     cat > conftest.$ac_ext <<EOF
12465 #line 12466 "configure"
12466 #include "confdefs.h"
12467 #include <math.h>
12468 int main() {
12469  _coshf(0);
12470 ; return 0; }
12471 EOF
12472 if { (eval echo configure:12473: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12473   rm -rf conftest*
12474   glibcpp_cv_func__coshf_use=yes
12475 else
12476   echo "configure: failed program was:" >&5
12477   cat conftest.$ac_ext >&5
12478   rm -rf conftest*
12479   glibcpp_cv_func__coshf_use=no
12480 fi
12481 rm -f conftest*
12482     ac_ext=c
12483 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12484 ac_cpp='$CPP $CPPFLAGS'
12485 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12486 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12487 cross_compiling=$ac_cv_prog_cc_cross
12488
12489
12490 fi
12491
12492   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
12493   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
12494     for ac_func in _coshf
12495 do
12496 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12497 echo "configure:12498: checking for $ac_func" >&5
12498 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12499   echo $ac_n "(cached) $ac_c" 1>&6
12500 else
12501   cat > conftest.$ac_ext <<EOF
12502 #line 12503 "configure"
12503 #include "confdefs.h"
12504 /* System header to define __stub macros and hopefully few prototypes,
12505     which can conflict with char $ac_func(); below.  */
12506 #include <assert.h>
12507 /* Override any gcc2 internal prototype to avoid an error.  */
12508 /* We use char because int might match the return type of a gcc2
12509     builtin and then its argument prototype would still apply.  */
12510 char $ac_func();
12511
12512 int main() {
12513
12514 /* The GNU C library defines this for functions which it implements
12515     to always fail with ENOSYS.  Some functions are actually named
12516     something starting with __ and the normal name is an alias.  */
12517 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12518 choke me
12519 #else
12520 $ac_func();
12521 #endif
12522
12523 ; return 0; }
12524 EOF
12525 if { (eval echo configure:12526: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12526   rm -rf conftest*
12527   eval "ac_cv_func_$ac_func=yes"
12528 else
12529   echo "configure: failed program was:" >&5
12530   cat conftest.$ac_ext >&5
12531   rm -rf conftest*
12532   eval "ac_cv_func_$ac_func=no"
12533 fi
12534 rm -f conftest*
12535 fi
12536
12537 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12538   echo "$ac_t""yes" 1>&6
12539     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12540   cat >> confdefs.h <<EOF
12541 #define $ac_tr_func 1
12542 EOF
12543
12544 else
12545   echo "$ac_t""no" 1>&6
12546 fi
12547 done
12548
12549   fi
12550
12551
12552   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12553 echo "configure:12554: checking for _expf declaration" >&5
12554   if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
12555   echo $ac_n "(cached) $ac_c" 1>&6
12556 else
12557
12558
12559     ac_ext=C
12560 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12561 ac_cpp='$CXXCPP $CPPFLAGS'
12562 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12563 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12564 cross_compiling=$ac_cv_prog_cxx_cross
12565
12566     cat > conftest.$ac_ext <<EOF
12567 #line 12568 "configure"
12568 #include "confdefs.h"
12569 #include <math.h>
12570 int main() {
12571  _expf(0);
12572 ; return 0; }
12573 EOF
12574 if { (eval echo configure:12575: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12575   rm -rf conftest*
12576   glibcpp_cv_func__expf_use=yes
12577 else
12578   echo "configure: failed program was:" >&5
12579   cat conftest.$ac_ext >&5
12580   rm -rf conftest*
12581   glibcpp_cv_func__expf_use=no
12582 fi
12583 rm -f conftest*
12584     ac_ext=c
12585 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12586 ac_cpp='$CPP $CPPFLAGS'
12587 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12588 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12589 cross_compiling=$ac_cv_prog_cc_cross
12590
12591
12592 fi
12593
12594   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
12595   if test x$glibcpp_cv_func__expf_use = x"yes"; then
12596     for ac_func in _expf
12597 do
12598 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12599 echo "configure:12600: checking for $ac_func" >&5
12600 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12601   echo $ac_n "(cached) $ac_c" 1>&6
12602 else
12603   cat > conftest.$ac_ext <<EOF
12604 #line 12605 "configure"
12605 #include "confdefs.h"
12606 /* System header to define __stub macros and hopefully few prototypes,
12607     which can conflict with char $ac_func(); below.  */
12608 #include <assert.h>
12609 /* Override any gcc2 internal prototype to avoid an error.  */
12610 /* We use char because int might match the return type of a gcc2
12611     builtin and then its argument prototype would still apply.  */
12612 char $ac_func();
12613
12614 int main() {
12615
12616 /* The GNU C library defines this for functions which it implements
12617     to always fail with ENOSYS.  Some functions are actually named
12618     something starting with __ and the normal name is an alias.  */
12619 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12620 choke me
12621 #else
12622 $ac_func();
12623 #endif
12624
12625 ; return 0; }
12626 EOF
12627 if { (eval echo configure:12628: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12628   rm -rf conftest*
12629   eval "ac_cv_func_$ac_func=yes"
12630 else
12631   echo "configure: failed program was:" >&5
12632   cat conftest.$ac_ext >&5
12633   rm -rf conftest*
12634   eval "ac_cv_func_$ac_func=no"
12635 fi
12636 rm -f conftest*
12637 fi
12638
12639 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12640   echo "$ac_t""yes" 1>&6
12641     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12642   cat >> confdefs.h <<EOF
12643 #define $ac_tr_func 1
12644 EOF
12645
12646 else
12647   echo "$ac_t""no" 1>&6
12648 fi
12649 done
12650
12651   fi
12652
12653
12654   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12655 echo "configure:12656: checking for _fabsf declaration" >&5
12656   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
12657   echo $ac_n "(cached) $ac_c" 1>&6
12658 else
12659
12660
12661     ac_ext=C
12662 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12663 ac_cpp='$CXXCPP $CPPFLAGS'
12664 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12665 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12666 cross_compiling=$ac_cv_prog_cxx_cross
12667
12668     cat > conftest.$ac_ext <<EOF
12669 #line 12670 "configure"
12670 #include "confdefs.h"
12671 #include <math.h>
12672 int main() {
12673  _fabsf(0);
12674 ; return 0; }
12675 EOF
12676 if { (eval echo configure:12677: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12677   rm -rf conftest*
12678   glibcpp_cv_func__fabsf_use=yes
12679 else
12680   echo "configure: failed program was:" >&5
12681   cat conftest.$ac_ext >&5
12682   rm -rf conftest*
12683   glibcpp_cv_func__fabsf_use=no
12684 fi
12685 rm -f conftest*
12686     ac_ext=c
12687 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12688 ac_cpp='$CPP $CPPFLAGS'
12689 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12690 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12691 cross_compiling=$ac_cv_prog_cc_cross
12692
12693
12694 fi
12695
12696   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
12697   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
12698     for ac_func in _fabsf
12699 do
12700 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12701 echo "configure:12702: checking for $ac_func" >&5
12702 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12703   echo $ac_n "(cached) $ac_c" 1>&6
12704 else
12705   cat > conftest.$ac_ext <<EOF
12706 #line 12707 "configure"
12707 #include "confdefs.h"
12708 /* System header to define __stub macros and hopefully few prototypes,
12709     which can conflict with char $ac_func(); below.  */
12710 #include <assert.h>
12711 /* Override any gcc2 internal prototype to avoid an error.  */
12712 /* We use char because int might match the return type of a gcc2
12713     builtin and then its argument prototype would still apply.  */
12714 char $ac_func();
12715
12716 int main() {
12717
12718 /* The GNU C library defines this for functions which it implements
12719     to always fail with ENOSYS.  Some functions are actually named
12720     something starting with __ and the normal name is an alias.  */
12721 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12722 choke me
12723 #else
12724 $ac_func();
12725 #endif
12726
12727 ; return 0; }
12728 EOF
12729 if { (eval echo configure:12730: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12730   rm -rf conftest*
12731   eval "ac_cv_func_$ac_func=yes"
12732 else
12733   echo "configure: failed program was:" >&5
12734   cat conftest.$ac_ext >&5
12735   rm -rf conftest*
12736   eval "ac_cv_func_$ac_func=no"
12737 fi
12738 rm -f conftest*
12739 fi
12740
12741 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12742   echo "$ac_t""yes" 1>&6
12743     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12744   cat >> confdefs.h <<EOF
12745 #define $ac_tr_func 1
12746 EOF
12747
12748 else
12749   echo "$ac_t""no" 1>&6
12750 fi
12751 done
12752
12753   fi
12754
12755
12756   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12757 echo "configure:12758: checking for _floorf declaration" >&5
12758   if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
12759   echo $ac_n "(cached) $ac_c" 1>&6
12760 else
12761
12762
12763     ac_ext=C
12764 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12765 ac_cpp='$CXXCPP $CPPFLAGS'
12766 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12767 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12768 cross_compiling=$ac_cv_prog_cxx_cross
12769
12770     cat > conftest.$ac_ext <<EOF
12771 #line 12772 "configure"
12772 #include "confdefs.h"
12773 #include <math.h>
12774 int main() {
12775  _floorf(0);
12776 ; return 0; }
12777 EOF
12778 if { (eval echo configure:12779: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12779   rm -rf conftest*
12780   glibcpp_cv_func__floorf_use=yes
12781 else
12782   echo "configure: failed program was:" >&5
12783   cat conftest.$ac_ext >&5
12784   rm -rf conftest*
12785   glibcpp_cv_func__floorf_use=no
12786 fi
12787 rm -f conftest*
12788     ac_ext=c
12789 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12790 ac_cpp='$CPP $CPPFLAGS'
12791 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12792 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12793 cross_compiling=$ac_cv_prog_cc_cross
12794
12795
12796 fi
12797
12798   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
12799   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
12800     for ac_func in _floorf
12801 do
12802 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12803 echo "configure:12804: checking for $ac_func" >&5
12804 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12805   echo $ac_n "(cached) $ac_c" 1>&6
12806 else
12807   cat > conftest.$ac_ext <<EOF
12808 #line 12809 "configure"
12809 #include "confdefs.h"
12810 /* System header to define __stub macros and hopefully few prototypes,
12811     which can conflict with char $ac_func(); below.  */
12812 #include <assert.h>
12813 /* Override any gcc2 internal prototype to avoid an error.  */
12814 /* We use char because int might match the return type of a gcc2
12815     builtin and then its argument prototype would still apply.  */
12816 char $ac_func();
12817
12818 int main() {
12819
12820 /* The GNU C library defines this for functions which it implements
12821     to always fail with ENOSYS.  Some functions are actually named
12822     something starting with __ and the normal name is an alias.  */
12823 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12824 choke me
12825 #else
12826 $ac_func();
12827 #endif
12828
12829 ; return 0; }
12830 EOF
12831 if { (eval echo configure:12832: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12832   rm -rf conftest*
12833   eval "ac_cv_func_$ac_func=yes"
12834 else
12835   echo "configure: failed program was:" >&5
12836   cat conftest.$ac_ext >&5
12837   rm -rf conftest*
12838   eval "ac_cv_func_$ac_func=no"
12839 fi
12840 rm -f conftest*
12841 fi
12842
12843 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12844   echo "$ac_t""yes" 1>&6
12845     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12846   cat >> confdefs.h <<EOF
12847 #define $ac_tr_func 1
12848 EOF
12849
12850 else
12851   echo "$ac_t""no" 1>&6
12852 fi
12853 done
12854
12855   fi
12856
12857
12858   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12859 echo "configure:12860: checking for _fmodf declaration" >&5
12860   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
12861   echo $ac_n "(cached) $ac_c" 1>&6
12862 else
12863
12864
12865     ac_ext=C
12866 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12867 ac_cpp='$CXXCPP $CPPFLAGS'
12868 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12869 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12870 cross_compiling=$ac_cv_prog_cxx_cross
12871
12872     cat > conftest.$ac_ext <<EOF
12873 #line 12874 "configure"
12874 #include "confdefs.h"
12875 #include <math.h>
12876 int main() {
12877  _fmodf(0, 0);
12878 ; return 0; }
12879 EOF
12880 if { (eval echo configure:12881: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12881   rm -rf conftest*
12882   glibcpp_cv_func__fmodf_use=yes
12883 else
12884   echo "configure: failed program was:" >&5
12885   cat conftest.$ac_ext >&5
12886   rm -rf conftest*
12887   glibcpp_cv_func__fmodf_use=no
12888 fi
12889 rm -f conftest*
12890     ac_ext=c
12891 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12892 ac_cpp='$CPP $CPPFLAGS'
12893 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12894 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12895 cross_compiling=$ac_cv_prog_cc_cross
12896
12897
12898 fi
12899
12900   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
12901   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
12902     for ac_func in _fmodf
12903 do
12904 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12905 echo "configure:12906: checking for $ac_func" >&5
12906 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12907   echo $ac_n "(cached) $ac_c" 1>&6
12908 else
12909   cat > conftest.$ac_ext <<EOF
12910 #line 12911 "configure"
12911 #include "confdefs.h"
12912 /* System header to define __stub macros and hopefully few prototypes,
12913     which can conflict with char $ac_func(); below.  */
12914 #include <assert.h>
12915 /* Override any gcc2 internal prototype to avoid an error.  */
12916 /* We use char because int might match the return type of a gcc2
12917     builtin and then its argument prototype would still apply.  */
12918 char $ac_func();
12919
12920 int main() {
12921
12922 /* The GNU C library defines this for functions which it implements
12923     to always fail with ENOSYS.  Some functions are actually named
12924     something starting with __ and the normal name is an alias.  */
12925 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12926 choke me
12927 #else
12928 $ac_func();
12929 #endif
12930
12931 ; return 0; }
12932 EOF
12933 if { (eval echo configure:12934: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12934   rm -rf conftest*
12935   eval "ac_cv_func_$ac_func=yes"
12936 else
12937   echo "configure: failed program was:" >&5
12938   cat conftest.$ac_ext >&5
12939   rm -rf conftest*
12940   eval "ac_cv_func_$ac_func=no"
12941 fi
12942 rm -f conftest*
12943 fi
12944
12945 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12946   echo "$ac_t""yes" 1>&6
12947     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12948   cat >> confdefs.h <<EOF
12949 #define $ac_tr_func 1
12950 EOF
12951
12952 else
12953   echo "$ac_t""no" 1>&6
12954 fi
12955 done
12956
12957   fi
12958
12959
12960   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12961 echo "configure:12962: checking for _frexpf declaration" >&5
12962   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
12963   echo $ac_n "(cached) $ac_c" 1>&6
12964 else
12965
12966
12967     ac_ext=C
12968 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12969 ac_cpp='$CXXCPP $CPPFLAGS'
12970 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12971 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12972 cross_compiling=$ac_cv_prog_cxx_cross
12973
12974     cat > conftest.$ac_ext <<EOF
12975 #line 12976 "configure"
12976 #include "confdefs.h"
12977 #include <math.h>
12978 int main() {
12979  _frexpf(0, 0);
12980 ; return 0; }
12981 EOF
12982 if { (eval echo configure:12983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12983   rm -rf conftest*
12984   glibcpp_cv_func__frexpf_use=yes
12985 else
12986   echo "configure: failed program was:" >&5
12987   cat conftest.$ac_ext >&5
12988   rm -rf conftest*
12989   glibcpp_cv_func__frexpf_use=no
12990 fi
12991 rm -f conftest*
12992     ac_ext=c
12993 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12994 ac_cpp='$CPP $CPPFLAGS'
12995 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12996 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12997 cross_compiling=$ac_cv_prog_cc_cross
12998
12999
13000 fi
13001
13002   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
13003   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
13004     for ac_func in _frexpf
13005 do
13006 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13007 echo "configure:13008: checking for $ac_func" >&5
13008 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13009   echo $ac_n "(cached) $ac_c" 1>&6
13010 else
13011   cat > conftest.$ac_ext <<EOF
13012 #line 13013 "configure"
13013 #include "confdefs.h"
13014 /* System header to define __stub macros and hopefully few prototypes,
13015     which can conflict with char $ac_func(); below.  */
13016 #include <assert.h>
13017 /* Override any gcc2 internal prototype to avoid an error.  */
13018 /* We use char because int might match the return type of a gcc2
13019     builtin and then its argument prototype would still apply.  */
13020 char $ac_func();
13021
13022 int main() {
13023
13024 /* The GNU C library defines this for functions which it implements
13025     to always fail with ENOSYS.  Some functions are actually named
13026     something starting with __ and the normal name is an alias.  */
13027 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13028 choke me
13029 #else
13030 $ac_func();
13031 #endif
13032
13033 ; return 0; }
13034 EOF
13035 if { (eval echo configure:13036: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13036   rm -rf conftest*
13037   eval "ac_cv_func_$ac_func=yes"
13038 else
13039   echo "configure: failed program was:" >&5
13040   cat conftest.$ac_ext >&5
13041   rm -rf conftest*
13042   eval "ac_cv_func_$ac_func=no"
13043 fi
13044 rm -f conftest*
13045 fi
13046
13047 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13048   echo "$ac_t""yes" 1>&6
13049     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13050   cat >> confdefs.h <<EOF
13051 #define $ac_tr_func 1
13052 EOF
13053
13054 else
13055   echo "$ac_t""no" 1>&6
13056 fi
13057 done
13058
13059   fi
13060
13061
13062   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13063 echo "configure:13064: checking for _ldexpf declaration" >&5
13064   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13065   echo $ac_n "(cached) $ac_c" 1>&6
13066 else
13067
13068
13069     ac_ext=C
13070 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13071 ac_cpp='$CXXCPP $CPPFLAGS'
13072 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13073 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13074 cross_compiling=$ac_cv_prog_cxx_cross
13075
13076     cat > conftest.$ac_ext <<EOF
13077 #line 13078 "configure"
13078 #include "confdefs.h"
13079 #include <math.h>
13080 int main() {
13081  _ldexpf(0, 0);
13082 ; return 0; }
13083 EOF
13084 if { (eval echo configure:13085: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13085   rm -rf conftest*
13086   glibcpp_cv_func__ldexpf_use=yes
13087 else
13088   echo "configure: failed program was:" >&5
13089   cat conftest.$ac_ext >&5
13090   rm -rf conftest*
13091   glibcpp_cv_func__ldexpf_use=no
13092 fi
13093 rm -f conftest*
13094     ac_ext=c
13095 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13096 ac_cpp='$CPP $CPPFLAGS'
13097 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13098 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13099 cross_compiling=$ac_cv_prog_cc_cross
13100
13101
13102 fi
13103
13104   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13105   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13106     for ac_func in _ldexpf
13107 do
13108 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13109 echo "configure:13110: checking for $ac_func" >&5
13110 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13111   echo $ac_n "(cached) $ac_c" 1>&6
13112 else
13113   cat > conftest.$ac_ext <<EOF
13114 #line 13115 "configure"
13115 #include "confdefs.h"
13116 /* System header to define __stub macros and hopefully few prototypes,
13117     which can conflict with char $ac_func(); below.  */
13118 #include <assert.h>
13119 /* Override any gcc2 internal prototype to avoid an error.  */
13120 /* We use char because int might match the return type of a gcc2
13121     builtin and then its argument prototype would still apply.  */
13122 char $ac_func();
13123
13124 int main() {
13125
13126 /* The GNU C library defines this for functions which it implements
13127     to always fail with ENOSYS.  Some functions are actually named
13128     something starting with __ and the normal name is an alias.  */
13129 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13130 choke me
13131 #else
13132 $ac_func();
13133 #endif
13134
13135 ; return 0; }
13136 EOF
13137 if { (eval echo configure:13138: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13138   rm -rf conftest*
13139   eval "ac_cv_func_$ac_func=yes"
13140 else
13141   echo "configure: failed program was:" >&5
13142   cat conftest.$ac_ext >&5
13143   rm -rf conftest*
13144   eval "ac_cv_func_$ac_func=no"
13145 fi
13146 rm -f conftest*
13147 fi
13148
13149 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13150   echo "$ac_t""yes" 1>&6
13151     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13152   cat >> confdefs.h <<EOF
13153 #define $ac_tr_func 1
13154 EOF
13155
13156 else
13157   echo "$ac_t""no" 1>&6
13158 fi
13159 done
13160
13161   fi
13162
13163
13164   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
13165 echo "configure:13166: checking for _logf declaration" >&5
13166   if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
13167   echo $ac_n "(cached) $ac_c" 1>&6
13168 else
13169
13170
13171     ac_ext=C
13172 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13173 ac_cpp='$CXXCPP $CPPFLAGS'
13174 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13175 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13176 cross_compiling=$ac_cv_prog_cxx_cross
13177
13178     cat > conftest.$ac_ext <<EOF
13179 #line 13180 "configure"
13180 #include "confdefs.h"
13181 #include <math.h>
13182 int main() {
13183  _logf(0);
13184 ; return 0; }
13185 EOF
13186 if { (eval echo configure:13187: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13187   rm -rf conftest*
13188   glibcpp_cv_func__logf_use=yes
13189 else
13190   echo "configure: failed program was:" >&5
13191   cat conftest.$ac_ext >&5
13192   rm -rf conftest*
13193   glibcpp_cv_func__logf_use=no
13194 fi
13195 rm -f conftest*
13196     ac_ext=c
13197 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13198 ac_cpp='$CPP $CPPFLAGS'
13199 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13200 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13201 cross_compiling=$ac_cv_prog_cc_cross
13202
13203
13204 fi
13205
13206   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
13207   if test x$glibcpp_cv_func__logf_use = x"yes"; then
13208     for ac_func in _logf
13209 do
13210 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13211 echo "configure:13212: checking for $ac_func" >&5
13212 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13213   echo $ac_n "(cached) $ac_c" 1>&6
13214 else
13215   cat > conftest.$ac_ext <<EOF
13216 #line 13217 "configure"
13217 #include "confdefs.h"
13218 /* System header to define __stub macros and hopefully few prototypes,
13219     which can conflict with char $ac_func(); below.  */
13220 #include <assert.h>
13221 /* Override any gcc2 internal prototype to avoid an error.  */
13222 /* We use char because int might match the return type of a gcc2
13223     builtin and then its argument prototype would still apply.  */
13224 char $ac_func();
13225
13226 int main() {
13227
13228 /* The GNU C library defines this for functions which it implements
13229     to always fail with ENOSYS.  Some functions are actually named
13230     something starting with __ and the normal name is an alias.  */
13231 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13232 choke me
13233 #else
13234 $ac_func();
13235 #endif
13236
13237 ; return 0; }
13238 EOF
13239 if { (eval echo configure:13240: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13240   rm -rf conftest*
13241   eval "ac_cv_func_$ac_func=yes"
13242 else
13243   echo "configure: failed program was:" >&5
13244   cat conftest.$ac_ext >&5
13245   rm -rf conftest*
13246   eval "ac_cv_func_$ac_func=no"
13247 fi
13248 rm -f conftest*
13249 fi
13250
13251 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13252   echo "$ac_t""yes" 1>&6
13253     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13254   cat >> confdefs.h <<EOF
13255 #define $ac_tr_func 1
13256 EOF
13257
13258 else
13259   echo "$ac_t""no" 1>&6
13260 fi
13261 done
13262
13263   fi
13264
13265
13266   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
13267 echo "configure:13268: checking for _log10f declaration" >&5
13268   if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
13269   echo $ac_n "(cached) $ac_c" 1>&6
13270 else
13271
13272
13273     ac_ext=C
13274 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13275 ac_cpp='$CXXCPP $CPPFLAGS'
13276 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13277 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13278 cross_compiling=$ac_cv_prog_cxx_cross
13279
13280     cat > conftest.$ac_ext <<EOF
13281 #line 13282 "configure"
13282 #include "confdefs.h"
13283 #include <math.h>
13284 int main() {
13285  _log10f(0);
13286 ; return 0; }
13287 EOF
13288 if { (eval echo configure:13289: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13289   rm -rf conftest*
13290   glibcpp_cv_func__log10f_use=yes
13291 else
13292   echo "configure: failed program was:" >&5
13293   cat conftest.$ac_ext >&5
13294   rm -rf conftest*
13295   glibcpp_cv_func__log10f_use=no
13296 fi
13297 rm -f conftest*
13298     ac_ext=c
13299 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13300 ac_cpp='$CPP $CPPFLAGS'
13301 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13302 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13303 cross_compiling=$ac_cv_prog_cc_cross
13304
13305
13306 fi
13307
13308   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
13309   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
13310     for ac_func in _log10f
13311 do
13312 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13313 echo "configure:13314: checking for $ac_func" >&5
13314 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13315   echo $ac_n "(cached) $ac_c" 1>&6
13316 else
13317   cat > conftest.$ac_ext <<EOF
13318 #line 13319 "configure"
13319 #include "confdefs.h"
13320 /* System header to define __stub macros and hopefully few prototypes,
13321     which can conflict with char $ac_func(); below.  */
13322 #include <assert.h>
13323 /* Override any gcc2 internal prototype to avoid an error.  */
13324 /* We use char because int might match the return type of a gcc2
13325     builtin and then its argument prototype would still apply.  */
13326 char $ac_func();
13327
13328 int main() {
13329
13330 /* The GNU C library defines this for functions which it implements
13331     to always fail with ENOSYS.  Some functions are actually named
13332     something starting with __ and the normal name is an alias.  */
13333 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13334 choke me
13335 #else
13336 $ac_func();
13337 #endif
13338
13339 ; return 0; }
13340 EOF
13341 if { (eval echo configure:13342: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13342   rm -rf conftest*
13343   eval "ac_cv_func_$ac_func=yes"
13344 else
13345   echo "configure: failed program was:" >&5
13346   cat conftest.$ac_ext >&5
13347   rm -rf conftest*
13348   eval "ac_cv_func_$ac_func=no"
13349 fi
13350 rm -f conftest*
13351 fi
13352
13353 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13354   echo "$ac_t""yes" 1>&6
13355     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13356   cat >> confdefs.h <<EOF
13357 #define $ac_tr_func 1
13358 EOF
13359
13360 else
13361   echo "$ac_t""no" 1>&6
13362 fi
13363 done
13364
13365   fi
13366
13367
13368   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
13369 echo "configure:13370: checking for _modff declaration" >&5
13370   if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
13371   echo $ac_n "(cached) $ac_c" 1>&6
13372 else
13373
13374
13375     ac_ext=C
13376 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13377 ac_cpp='$CXXCPP $CPPFLAGS'
13378 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13379 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13380 cross_compiling=$ac_cv_prog_cxx_cross
13381
13382     cat > conftest.$ac_ext <<EOF
13383 #line 13384 "configure"
13384 #include "confdefs.h"
13385 #include <math.h>
13386 int main() {
13387  _modff(0, 0);
13388 ; return 0; }
13389 EOF
13390 if { (eval echo configure:13391: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13391   rm -rf conftest*
13392   glibcpp_cv_func__modff_use=yes
13393 else
13394   echo "configure: failed program was:" >&5
13395   cat conftest.$ac_ext >&5
13396   rm -rf conftest*
13397   glibcpp_cv_func__modff_use=no
13398 fi
13399 rm -f conftest*
13400     ac_ext=c
13401 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13402 ac_cpp='$CPP $CPPFLAGS'
13403 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13404 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13405 cross_compiling=$ac_cv_prog_cc_cross
13406
13407
13408 fi
13409
13410   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
13411   if test x$glibcpp_cv_func__modff_use = x"yes"; then
13412     for ac_func in _modff
13413 do
13414 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13415 echo "configure:13416: checking for $ac_func" >&5
13416 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13417   echo $ac_n "(cached) $ac_c" 1>&6
13418 else
13419   cat > conftest.$ac_ext <<EOF
13420 #line 13421 "configure"
13421 #include "confdefs.h"
13422 /* System header to define __stub macros and hopefully few prototypes,
13423     which can conflict with char $ac_func(); below.  */
13424 #include <assert.h>
13425 /* Override any gcc2 internal prototype to avoid an error.  */
13426 /* We use char because int might match the return type of a gcc2
13427     builtin and then its argument prototype would still apply.  */
13428 char $ac_func();
13429
13430 int main() {
13431
13432 /* The GNU C library defines this for functions which it implements
13433     to always fail with ENOSYS.  Some functions are actually named
13434     something starting with __ and the normal name is an alias.  */
13435 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13436 choke me
13437 #else
13438 $ac_func();
13439 #endif
13440
13441 ; return 0; }
13442 EOF
13443 if { (eval echo configure:13444: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13444   rm -rf conftest*
13445   eval "ac_cv_func_$ac_func=yes"
13446 else
13447   echo "configure: failed program was:" >&5
13448   cat conftest.$ac_ext >&5
13449   rm -rf conftest*
13450   eval "ac_cv_func_$ac_func=no"
13451 fi
13452 rm -f conftest*
13453 fi
13454
13455 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13456   echo "$ac_t""yes" 1>&6
13457     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13458   cat >> confdefs.h <<EOF
13459 #define $ac_tr_func 1
13460 EOF
13461
13462 else
13463   echo "$ac_t""no" 1>&6
13464 fi
13465 done
13466
13467   fi
13468
13469
13470   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
13471 echo "configure:13472: checking for _powf declaration" >&5
13472   if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
13473   echo $ac_n "(cached) $ac_c" 1>&6
13474 else
13475
13476
13477     ac_ext=C
13478 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13479 ac_cpp='$CXXCPP $CPPFLAGS'
13480 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13481 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13482 cross_compiling=$ac_cv_prog_cxx_cross
13483
13484     cat > conftest.$ac_ext <<EOF
13485 #line 13486 "configure"
13486 #include "confdefs.h"
13487 #include <math.h>
13488 int main() {
13489  _powf(0, 0);
13490 ; return 0; }
13491 EOF
13492 if { (eval echo configure:13493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13493   rm -rf conftest*
13494   glibcpp_cv_func__powf_use=yes
13495 else
13496   echo "configure: failed program was:" >&5
13497   cat conftest.$ac_ext >&5
13498   rm -rf conftest*
13499   glibcpp_cv_func__powf_use=no
13500 fi
13501 rm -f conftest*
13502     ac_ext=c
13503 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13504 ac_cpp='$CPP $CPPFLAGS'
13505 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13506 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13507 cross_compiling=$ac_cv_prog_cc_cross
13508
13509
13510 fi
13511
13512   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
13513   if test x$glibcpp_cv_func__powf_use = x"yes"; then
13514     for ac_func in _powf
13515 do
13516 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13517 echo "configure:13518: checking for $ac_func" >&5
13518 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13519   echo $ac_n "(cached) $ac_c" 1>&6
13520 else
13521   cat > conftest.$ac_ext <<EOF
13522 #line 13523 "configure"
13523 #include "confdefs.h"
13524 /* System header to define __stub macros and hopefully few prototypes,
13525     which can conflict with char $ac_func(); below.  */
13526 #include <assert.h>
13527 /* Override any gcc2 internal prototype to avoid an error.  */
13528 /* We use char because int might match the return type of a gcc2
13529     builtin and then its argument prototype would still apply.  */
13530 char $ac_func();
13531
13532 int main() {
13533
13534 /* The GNU C library defines this for functions which it implements
13535     to always fail with ENOSYS.  Some functions are actually named
13536     something starting with __ and the normal name is an alias.  */
13537 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13538 choke me
13539 #else
13540 $ac_func();
13541 #endif
13542
13543 ; return 0; }
13544 EOF
13545 if { (eval echo configure:13546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13546   rm -rf conftest*
13547   eval "ac_cv_func_$ac_func=yes"
13548 else
13549   echo "configure: failed program was:" >&5
13550   cat conftest.$ac_ext >&5
13551   rm -rf conftest*
13552   eval "ac_cv_func_$ac_func=no"
13553 fi
13554 rm -f conftest*
13555 fi
13556
13557 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13558   echo "$ac_t""yes" 1>&6
13559     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13560   cat >> confdefs.h <<EOF
13561 #define $ac_tr_func 1
13562 EOF
13563
13564 else
13565   echo "$ac_t""no" 1>&6
13566 fi
13567 done
13568
13569   fi
13570
13571
13572   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
13573 echo "configure:13574: checking for _sinf declaration" >&5
13574   if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
13575   echo $ac_n "(cached) $ac_c" 1>&6
13576 else
13577
13578
13579     ac_ext=C
13580 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13581 ac_cpp='$CXXCPP $CPPFLAGS'
13582 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13583 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13584 cross_compiling=$ac_cv_prog_cxx_cross
13585
13586     cat > conftest.$ac_ext <<EOF
13587 #line 13588 "configure"
13588 #include "confdefs.h"
13589 #include <math.h>
13590 int main() {
13591  _sinf(0);
13592 ; return 0; }
13593 EOF
13594 if { (eval echo configure:13595: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13595   rm -rf conftest*
13596   glibcpp_cv_func__sinf_use=yes
13597 else
13598   echo "configure: failed program was:" >&5
13599   cat conftest.$ac_ext >&5
13600   rm -rf conftest*
13601   glibcpp_cv_func__sinf_use=no
13602 fi
13603 rm -f conftest*
13604     ac_ext=c
13605 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13606 ac_cpp='$CPP $CPPFLAGS'
13607 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13608 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13609 cross_compiling=$ac_cv_prog_cc_cross
13610
13611
13612 fi
13613
13614   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
13615   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
13616     for ac_func in _sinf
13617 do
13618 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13619 echo "configure:13620: checking for $ac_func" >&5
13620 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13621   echo $ac_n "(cached) $ac_c" 1>&6
13622 else
13623   cat > conftest.$ac_ext <<EOF
13624 #line 13625 "configure"
13625 #include "confdefs.h"
13626 /* System header to define __stub macros and hopefully few prototypes,
13627     which can conflict with char $ac_func(); below.  */
13628 #include <assert.h>
13629 /* Override any gcc2 internal prototype to avoid an error.  */
13630 /* We use char because int might match the return type of a gcc2
13631     builtin and then its argument prototype would still apply.  */
13632 char $ac_func();
13633
13634 int main() {
13635
13636 /* The GNU C library defines this for functions which it implements
13637     to always fail with ENOSYS.  Some functions are actually named
13638     something starting with __ and the normal name is an alias.  */
13639 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13640 choke me
13641 #else
13642 $ac_func();
13643 #endif
13644
13645 ; return 0; }
13646 EOF
13647 if { (eval echo configure:13648: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13648   rm -rf conftest*
13649   eval "ac_cv_func_$ac_func=yes"
13650 else
13651   echo "configure: failed program was:" >&5
13652   cat conftest.$ac_ext >&5
13653   rm -rf conftest*
13654   eval "ac_cv_func_$ac_func=no"
13655 fi
13656 rm -f conftest*
13657 fi
13658
13659 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13660   echo "$ac_t""yes" 1>&6
13661     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13662   cat >> confdefs.h <<EOF
13663 #define $ac_tr_func 1
13664 EOF
13665
13666 else
13667   echo "$ac_t""no" 1>&6
13668 fi
13669 done
13670
13671   fi
13672
13673
13674   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
13675 echo "configure:13676: checking for _sinhf declaration" >&5
13676   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
13677   echo $ac_n "(cached) $ac_c" 1>&6
13678 else
13679
13680
13681     ac_ext=C
13682 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13683 ac_cpp='$CXXCPP $CPPFLAGS'
13684 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13685 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13686 cross_compiling=$ac_cv_prog_cxx_cross
13687
13688     cat > conftest.$ac_ext <<EOF
13689 #line 13690 "configure"
13690 #include "confdefs.h"
13691 #include <math.h>
13692 int main() {
13693  _sinhf(0);
13694 ; return 0; }
13695 EOF
13696 if { (eval echo configure:13697: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13697   rm -rf conftest*
13698   glibcpp_cv_func__sinhf_use=yes
13699 else
13700   echo "configure: failed program was:" >&5
13701   cat conftest.$ac_ext >&5
13702   rm -rf conftest*
13703   glibcpp_cv_func__sinhf_use=no
13704 fi
13705 rm -f conftest*
13706     ac_ext=c
13707 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13708 ac_cpp='$CPP $CPPFLAGS'
13709 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13710 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13711 cross_compiling=$ac_cv_prog_cc_cross
13712
13713
13714 fi
13715
13716   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
13717   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
13718     for ac_func in _sinhf
13719 do
13720 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13721 echo "configure:13722: checking for $ac_func" >&5
13722 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13723   echo $ac_n "(cached) $ac_c" 1>&6
13724 else
13725   cat > conftest.$ac_ext <<EOF
13726 #line 13727 "configure"
13727 #include "confdefs.h"
13728 /* System header to define __stub macros and hopefully few prototypes,
13729     which can conflict with char $ac_func(); below.  */
13730 #include <assert.h>
13731 /* Override any gcc2 internal prototype to avoid an error.  */
13732 /* We use char because int might match the return type of a gcc2
13733     builtin and then its argument prototype would still apply.  */
13734 char $ac_func();
13735
13736 int main() {
13737
13738 /* The GNU C library defines this for functions which it implements
13739     to always fail with ENOSYS.  Some functions are actually named
13740     something starting with __ and the normal name is an alias.  */
13741 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13742 choke me
13743 #else
13744 $ac_func();
13745 #endif
13746
13747 ; return 0; }
13748 EOF
13749 if { (eval echo configure:13750: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13750   rm -rf conftest*
13751   eval "ac_cv_func_$ac_func=yes"
13752 else
13753   echo "configure: failed program was:" >&5
13754   cat conftest.$ac_ext >&5
13755   rm -rf conftest*
13756   eval "ac_cv_func_$ac_func=no"
13757 fi
13758 rm -f conftest*
13759 fi
13760
13761 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13762   echo "$ac_t""yes" 1>&6
13763     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13764   cat >> confdefs.h <<EOF
13765 #define $ac_tr_func 1
13766 EOF
13767
13768 else
13769   echo "$ac_t""no" 1>&6
13770 fi
13771 done
13772
13773   fi
13774
13775
13776   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
13777 echo "configure:13778: checking for _sqrtf declaration" >&5
13778   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
13779   echo $ac_n "(cached) $ac_c" 1>&6
13780 else
13781
13782
13783     ac_ext=C
13784 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13785 ac_cpp='$CXXCPP $CPPFLAGS'
13786 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13787 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13788 cross_compiling=$ac_cv_prog_cxx_cross
13789
13790     cat > conftest.$ac_ext <<EOF
13791 #line 13792 "configure"
13792 #include "confdefs.h"
13793 #include <math.h>
13794 int main() {
13795  _sqrtf(0);
13796 ; return 0; }
13797 EOF
13798 if { (eval echo configure:13799: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13799   rm -rf conftest*
13800   glibcpp_cv_func__sqrtf_use=yes
13801 else
13802   echo "configure: failed program was:" >&5
13803   cat conftest.$ac_ext >&5
13804   rm -rf conftest*
13805   glibcpp_cv_func__sqrtf_use=no
13806 fi
13807 rm -f conftest*
13808     ac_ext=c
13809 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13810 ac_cpp='$CPP $CPPFLAGS'
13811 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13812 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13813 cross_compiling=$ac_cv_prog_cc_cross
13814
13815
13816 fi
13817
13818   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
13819   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
13820     for ac_func in _sqrtf
13821 do
13822 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13823 echo "configure:13824: checking for $ac_func" >&5
13824 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13825   echo $ac_n "(cached) $ac_c" 1>&6
13826 else
13827   cat > conftest.$ac_ext <<EOF
13828 #line 13829 "configure"
13829 #include "confdefs.h"
13830 /* System header to define __stub macros and hopefully few prototypes,
13831     which can conflict with char $ac_func(); below.  */
13832 #include <assert.h>
13833 /* Override any gcc2 internal prototype to avoid an error.  */
13834 /* We use char because int might match the return type of a gcc2
13835     builtin and then its argument prototype would still apply.  */
13836 char $ac_func();
13837
13838 int main() {
13839
13840 /* The GNU C library defines this for functions which it implements
13841     to always fail with ENOSYS.  Some functions are actually named
13842     something starting with __ and the normal name is an alias.  */
13843 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13844 choke me
13845 #else
13846 $ac_func();
13847 #endif
13848
13849 ; return 0; }
13850 EOF
13851 if { (eval echo configure:13852: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13852   rm -rf conftest*
13853   eval "ac_cv_func_$ac_func=yes"
13854 else
13855   echo "configure: failed program was:" >&5
13856   cat conftest.$ac_ext >&5
13857   rm -rf conftest*
13858   eval "ac_cv_func_$ac_func=no"
13859 fi
13860 rm -f conftest*
13861 fi
13862
13863 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13864   echo "$ac_t""yes" 1>&6
13865     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13866   cat >> confdefs.h <<EOF
13867 #define $ac_tr_func 1
13868 EOF
13869
13870 else
13871   echo "$ac_t""no" 1>&6
13872 fi
13873 done
13874
13875   fi
13876
13877
13878   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
13879 echo "configure:13880: checking for _tanf declaration" >&5
13880   if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
13881   echo $ac_n "(cached) $ac_c" 1>&6
13882 else
13883
13884
13885     ac_ext=C
13886 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13887 ac_cpp='$CXXCPP $CPPFLAGS'
13888 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13889 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13890 cross_compiling=$ac_cv_prog_cxx_cross
13891
13892     cat > conftest.$ac_ext <<EOF
13893 #line 13894 "configure"
13894 #include "confdefs.h"
13895 #include <math.h>
13896 int main() {
13897  _tanf(0);
13898 ; return 0; }
13899 EOF
13900 if { (eval echo configure:13901: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13901   rm -rf conftest*
13902   glibcpp_cv_func__tanf_use=yes
13903 else
13904   echo "configure: failed program was:" >&5
13905   cat conftest.$ac_ext >&5
13906   rm -rf conftest*
13907   glibcpp_cv_func__tanf_use=no
13908 fi
13909 rm -f conftest*
13910     ac_ext=c
13911 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13912 ac_cpp='$CPP $CPPFLAGS'
13913 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13914 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13915 cross_compiling=$ac_cv_prog_cc_cross
13916
13917
13918 fi
13919
13920   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
13921   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
13922     for ac_func in _tanf
13923 do
13924 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13925 echo "configure:13926: checking for $ac_func" >&5
13926 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13927   echo $ac_n "(cached) $ac_c" 1>&6
13928 else
13929   cat > conftest.$ac_ext <<EOF
13930 #line 13931 "configure"
13931 #include "confdefs.h"
13932 /* System header to define __stub macros and hopefully few prototypes,
13933     which can conflict with char $ac_func(); below.  */
13934 #include <assert.h>
13935 /* Override any gcc2 internal prototype to avoid an error.  */
13936 /* We use char because int might match the return type of a gcc2
13937     builtin and then its argument prototype would still apply.  */
13938 char $ac_func();
13939
13940 int main() {
13941
13942 /* The GNU C library defines this for functions which it implements
13943     to always fail with ENOSYS.  Some functions are actually named
13944     something starting with __ and the normal name is an alias.  */
13945 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13946 choke me
13947 #else
13948 $ac_func();
13949 #endif
13950
13951 ; return 0; }
13952 EOF
13953 if { (eval echo configure:13954: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13954   rm -rf conftest*
13955   eval "ac_cv_func_$ac_func=yes"
13956 else
13957   echo "configure: failed program was:" >&5
13958   cat conftest.$ac_ext >&5
13959   rm -rf conftest*
13960   eval "ac_cv_func_$ac_func=no"
13961 fi
13962 rm -f conftest*
13963 fi
13964
13965 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13966   echo "$ac_t""yes" 1>&6
13967     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13968   cat >> confdefs.h <<EOF
13969 #define $ac_tr_func 1
13970 EOF
13971
13972 else
13973   echo "$ac_t""no" 1>&6
13974 fi
13975 done
13976
13977   fi
13978
13979
13980   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
13981 echo "configure:13982: checking for _tanhf declaration" >&5
13982   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
13983   echo $ac_n "(cached) $ac_c" 1>&6
13984 else
13985
13986
13987     ac_ext=C
13988 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13989 ac_cpp='$CXXCPP $CPPFLAGS'
13990 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13991 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13992 cross_compiling=$ac_cv_prog_cxx_cross
13993
13994     cat > conftest.$ac_ext <<EOF
13995 #line 13996 "configure"
13996 #include "confdefs.h"
13997 #include <math.h>
13998 int main() {
13999  _tanhf(0);
14000 ; return 0; }
14001 EOF
14002 if { (eval echo configure:14003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14003   rm -rf conftest*
14004   glibcpp_cv_func__tanhf_use=yes
14005 else
14006   echo "configure: failed program was:" >&5
14007   cat conftest.$ac_ext >&5
14008   rm -rf conftest*
14009   glibcpp_cv_func__tanhf_use=no
14010 fi
14011 rm -f conftest*
14012     ac_ext=c
14013 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14014 ac_cpp='$CPP $CPPFLAGS'
14015 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14016 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14017 cross_compiling=$ac_cv_prog_cc_cross
14018
14019
14020 fi
14021
14022   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
14023   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
14024     for ac_func in _tanhf
14025 do
14026 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14027 echo "configure:14028: checking for $ac_func" >&5
14028 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14029   echo $ac_n "(cached) $ac_c" 1>&6
14030 else
14031   cat > conftest.$ac_ext <<EOF
14032 #line 14033 "configure"
14033 #include "confdefs.h"
14034 /* System header to define __stub macros and hopefully few prototypes,
14035     which can conflict with char $ac_func(); below.  */
14036 #include <assert.h>
14037 /* Override any gcc2 internal prototype to avoid an error.  */
14038 /* We use char because int might match the return type of a gcc2
14039     builtin and then its argument prototype would still apply.  */
14040 char $ac_func();
14041
14042 int main() {
14043
14044 /* The GNU C library defines this for functions which it implements
14045     to always fail with ENOSYS.  Some functions are actually named
14046     something starting with __ and the normal name is an alias.  */
14047 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14048 choke me
14049 #else
14050 $ac_func();
14051 #endif
14052
14053 ; return 0; }
14054 EOF
14055 if { (eval echo configure:14056: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14056   rm -rf conftest*
14057   eval "ac_cv_func_$ac_func=yes"
14058 else
14059   echo "configure: failed program was:" >&5
14060   cat conftest.$ac_ext >&5
14061   rm -rf conftest*
14062   eval "ac_cv_func_$ac_func=no"
14063 fi
14064 rm -f conftest*
14065 fi
14066
14067 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14068   echo "$ac_t""yes" 1>&6
14069     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14070   cat >> confdefs.h <<EOF
14071 #define $ac_tr_func 1
14072 EOF
14073
14074 else
14075   echo "$ac_t""no" 1>&6
14076 fi
14077 done
14078
14079   fi
14080
14081
14082   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14083 echo "configure:14084: checking for _sincosf declaration" >&5
14084   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14085   echo $ac_n "(cached) $ac_c" 1>&6
14086 else
14087
14088
14089     ac_ext=C
14090 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14091 ac_cpp='$CXXCPP $CPPFLAGS'
14092 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14093 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14094 cross_compiling=$ac_cv_prog_cxx_cross
14095
14096     cat > conftest.$ac_ext <<EOF
14097 #line 14098 "configure"
14098 #include "confdefs.h"
14099 #include <math.h>
14100 int main() {
14101  _sincosf(0, 0, 0);
14102 ; return 0; }
14103 EOF
14104 if { (eval echo configure:14105: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14105   rm -rf conftest*
14106   glibcpp_cv_func__sincosf_use=yes
14107 else
14108   echo "configure: failed program was:" >&5
14109   cat conftest.$ac_ext >&5
14110   rm -rf conftest*
14111   glibcpp_cv_func__sincosf_use=no
14112 fi
14113 rm -f conftest*
14114     ac_ext=c
14115 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14116 ac_cpp='$CPP $CPPFLAGS'
14117 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14118 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14119 cross_compiling=$ac_cv_prog_cc_cross
14120
14121
14122 fi
14123
14124   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
14125   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
14126     for ac_func in _sincosf
14127 do
14128 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14129 echo "configure:14130: checking for $ac_func" >&5
14130 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14131   echo $ac_n "(cached) $ac_c" 1>&6
14132 else
14133   cat > conftest.$ac_ext <<EOF
14134 #line 14135 "configure"
14135 #include "confdefs.h"
14136 /* System header to define __stub macros and hopefully few prototypes,
14137     which can conflict with char $ac_func(); below.  */
14138 #include <assert.h>
14139 /* Override any gcc2 internal prototype to avoid an error.  */
14140 /* We use char because int might match the return type of a gcc2
14141     builtin and then its argument prototype would still apply.  */
14142 char $ac_func();
14143
14144 int main() {
14145
14146 /* The GNU C library defines this for functions which it implements
14147     to always fail with ENOSYS.  Some functions are actually named
14148     something starting with __ and the normal name is an alias.  */
14149 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14150 choke me
14151 #else
14152 $ac_func();
14153 #endif
14154
14155 ; return 0; }
14156 EOF
14157 if { (eval echo configure:14158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14158   rm -rf conftest*
14159   eval "ac_cv_func_$ac_func=yes"
14160 else
14161   echo "configure: failed program was:" >&5
14162   cat conftest.$ac_ext >&5
14163   rm -rf conftest*
14164   eval "ac_cv_func_$ac_func=no"
14165 fi
14166 rm -f conftest*
14167 fi
14168
14169 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14170   echo "$ac_t""yes" 1>&6
14171     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14172   cat >> confdefs.h <<EOF
14173 #define $ac_tr_func 1
14174 EOF
14175
14176 else
14177   echo "$ac_t""no" 1>&6
14178 fi
14179 done
14180
14181   fi
14182
14183
14184   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
14185 echo "configure:14186: checking for _finitef declaration" >&5
14186   if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
14187   echo $ac_n "(cached) $ac_c" 1>&6
14188 else
14189
14190
14191     ac_ext=C
14192 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14193 ac_cpp='$CXXCPP $CPPFLAGS'
14194 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14195 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14196 cross_compiling=$ac_cv_prog_cxx_cross
14197
14198     cat > conftest.$ac_ext <<EOF
14199 #line 14200 "configure"
14200 #include "confdefs.h"
14201 #include <math.h>
14202 int main() {
14203  _finitef(0);
14204 ; return 0; }
14205 EOF
14206 if { (eval echo configure:14207: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14207   rm -rf conftest*
14208   glibcpp_cv_func__finitef_use=yes
14209 else
14210   echo "configure: failed program was:" >&5
14211   cat conftest.$ac_ext >&5
14212   rm -rf conftest*
14213   glibcpp_cv_func__finitef_use=no
14214 fi
14215 rm -f conftest*
14216     ac_ext=c
14217 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14218 ac_cpp='$CPP $CPPFLAGS'
14219 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14220 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14221 cross_compiling=$ac_cv_prog_cc_cross
14222
14223
14224 fi
14225
14226   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
14227   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
14228     for ac_func in _finitef
14229 do
14230 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14231 echo "configure:14232: checking for $ac_func" >&5
14232 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14233   echo $ac_n "(cached) $ac_c" 1>&6
14234 else
14235   cat > conftest.$ac_ext <<EOF
14236 #line 14237 "configure"
14237 #include "confdefs.h"
14238 /* System header to define __stub macros and hopefully few prototypes,
14239     which can conflict with char $ac_func(); below.  */
14240 #include <assert.h>
14241 /* Override any gcc2 internal prototype to avoid an error.  */
14242 /* We use char because int might match the return type of a gcc2
14243     builtin and then its argument prototype would still apply.  */
14244 char $ac_func();
14245
14246 int main() {
14247
14248 /* The GNU C library defines this for functions which it implements
14249     to always fail with ENOSYS.  Some functions are actually named
14250     something starting with __ and the normal name is an alias.  */
14251 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14252 choke me
14253 #else
14254 $ac_func();
14255 #endif
14256
14257 ; return 0; }
14258 EOF
14259 if { (eval echo configure:14260: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14260   rm -rf conftest*
14261   eval "ac_cv_func_$ac_func=yes"
14262 else
14263   echo "configure: failed program was:" >&5
14264   cat conftest.$ac_ext >&5
14265   rm -rf conftest*
14266   eval "ac_cv_func_$ac_func=no"
14267 fi
14268 rm -f conftest*
14269 fi
14270
14271 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14272   echo "$ac_t""yes" 1>&6
14273     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14274   cat >> confdefs.h <<EOF
14275 #define $ac_tr_func 1
14276 EOF
14277
14278 else
14279   echo "$ac_t""no" 1>&6
14280 fi
14281 done
14282
14283   fi
14284
14285
14286
14287   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
14288 echo "configure:14289: checking for _isnanl declaration" >&5
14289   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
14290   echo $ac_n "(cached) $ac_c" 1>&6
14291 else
14292
14293
14294     ac_ext=C
14295 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14296 ac_cpp='$CXXCPP $CPPFLAGS'
14297 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14298 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14299 cross_compiling=$ac_cv_prog_cxx_cross
14300
14301     cat > conftest.$ac_ext <<EOF
14302 #line 14303 "configure"
14303 #include "confdefs.h"
14304 #include <math.h>
14305 int main() {
14306  _isnanl(0);
14307 ; return 0; }
14308 EOF
14309 if { (eval echo configure:14310: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14310   rm -rf conftest*
14311   glibcpp_cv_func__isnanl_use=yes
14312 else
14313   echo "configure: failed program was:" >&5
14314   cat conftest.$ac_ext >&5
14315   rm -rf conftest*
14316   glibcpp_cv_func__isnanl_use=no
14317 fi
14318 rm -f conftest*
14319     ac_ext=c
14320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14321 ac_cpp='$CPP $CPPFLAGS'
14322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14324 cross_compiling=$ac_cv_prog_cc_cross
14325
14326
14327 fi
14328
14329   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
14330   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
14331     for ac_func in _isnanl
14332 do
14333 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14334 echo "configure:14335: checking for $ac_func" >&5
14335 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14336   echo $ac_n "(cached) $ac_c" 1>&6
14337 else
14338   cat > conftest.$ac_ext <<EOF
14339 #line 14340 "configure"
14340 #include "confdefs.h"
14341 /* System header to define __stub macros and hopefully few prototypes,
14342     which can conflict with char $ac_func(); below.  */
14343 #include <assert.h>
14344 /* Override any gcc2 internal prototype to avoid an error.  */
14345 /* We use char because int might match the return type of a gcc2
14346     builtin and then its argument prototype would still apply.  */
14347 char $ac_func();
14348
14349 int main() {
14350
14351 /* The GNU C library defines this for functions which it implements
14352     to always fail with ENOSYS.  Some functions are actually named
14353     something starting with __ and the normal name is an alias.  */
14354 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14355 choke me
14356 #else
14357 $ac_func();
14358 #endif
14359
14360 ; return 0; }
14361 EOF
14362 if { (eval echo configure:14363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14363   rm -rf conftest*
14364   eval "ac_cv_func_$ac_func=yes"
14365 else
14366   echo "configure: failed program was:" >&5
14367   cat conftest.$ac_ext >&5
14368   rm -rf conftest*
14369   eval "ac_cv_func_$ac_func=no"
14370 fi
14371 rm -f conftest*
14372 fi
14373
14374 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14375   echo "$ac_t""yes" 1>&6
14376     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14377   cat >> confdefs.h <<EOF
14378 #define $ac_tr_func 1
14379 EOF
14380
14381 else
14382   echo "$ac_t""no" 1>&6
14383 fi
14384 done
14385
14386   fi
14387
14388
14389   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
14390 echo "configure:14391: checking for _isinfl declaration" >&5
14391   if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
14392   echo $ac_n "(cached) $ac_c" 1>&6
14393 else
14394
14395
14396     ac_ext=C
14397 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14398 ac_cpp='$CXXCPP $CPPFLAGS'
14399 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14400 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14401 cross_compiling=$ac_cv_prog_cxx_cross
14402
14403     cat > conftest.$ac_ext <<EOF
14404 #line 14405 "configure"
14405 #include "confdefs.h"
14406 #include <math.h>
14407 int main() {
14408  _isinfl(0);
14409 ; return 0; }
14410 EOF
14411 if { (eval echo configure:14412: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14412   rm -rf conftest*
14413   glibcpp_cv_func__isinfl_use=yes
14414 else
14415   echo "configure: failed program was:" >&5
14416   cat conftest.$ac_ext >&5
14417   rm -rf conftest*
14418   glibcpp_cv_func__isinfl_use=no
14419 fi
14420 rm -f conftest*
14421     ac_ext=c
14422 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14423 ac_cpp='$CPP $CPPFLAGS'
14424 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14425 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14426 cross_compiling=$ac_cv_prog_cc_cross
14427
14428
14429 fi
14430
14431   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
14432   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
14433     for ac_func in _isinfl
14434 do
14435 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14436 echo "configure:14437: checking for $ac_func" >&5
14437 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14438   echo $ac_n "(cached) $ac_c" 1>&6
14439 else
14440   cat > conftest.$ac_ext <<EOF
14441 #line 14442 "configure"
14442 #include "confdefs.h"
14443 /* System header to define __stub macros and hopefully few prototypes,
14444     which can conflict with char $ac_func(); below.  */
14445 #include <assert.h>
14446 /* Override any gcc2 internal prototype to avoid an error.  */
14447 /* We use char because int might match the return type of a gcc2
14448     builtin and then its argument prototype would still apply.  */
14449 char $ac_func();
14450
14451 int main() {
14452
14453 /* The GNU C library defines this for functions which it implements
14454     to always fail with ENOSYS.  Some functions are actually named
14455     something starting with __ and the normal name is an alias.  */
14456 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14457 choke me
14458 #else
14459 $ac_func();
14460 #endif
14461
14462 ; return 0; }
14463 EOF
14464 if { (eval echo configure:14465: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14465   rm -rf conftest*
14466   eval "ac_cv_func_$ac_func=yes"
14467 else
14468   echo "configure: failed program was:" >&5
14469   cat conftest.$ac_ext >&5
14470   rm -rf conftest*
14471   eval "ac_cv_func_$ac_func=no"
14472 fi
14473 rm -f conftest*
14474 fi
14475
14476 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14477   echo "$ac_t""yes" 1>&6
14478     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14479   cat >> confdefs.h <<EOF
14480 #define $ac_tr_func 1
14481 EOF
14482
14483 else
14484   echo "$ac_t""no" 1>&6
14485 fi
14486 done
14487
14488   fi
14489
14490
14491   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
14492 echo "configure:14493: checking for _copysignl declaration" >&5
14493   if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
14494   echo $ac_n "(cached) $ac_c" 1>&6
14495 else
14496
14497
14498     ac_ext=C
14499 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14500 ac_cpp='$CXXCPP $CPPFLAGS'
14501 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14502 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14503 cross_compiling=$ac_cv_prog_cxx_cross
14504
14505     cat > conftest.$ac_ext <<EOF
14506 #line 14507 "configure"
14507 #include "confdefs.h"
14508 #include <math.h>
14509 int main() {
14510  _copysignl(0, 0);
14511 ; return 0; }
14512 EOF
14513 if { (eval echo configure:14514: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14514   rm -rf conftest*
14515   glibcpp_cv_func__copysignl_use=yes
14516 else
14517   echo "configure: failed program was:" >&5
14518   cat conftest.$ac_ext >&5
14519   rm -rf conftest*
14520   glibcpp_cv_func__copysignl_use=no
14521 fi
14522 rm -f conftest*
14523     ac_ext=c
14524 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14525 ac_cpp='$CPP $CPPFLAGS'
14526 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14527 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14528 cross_compiling=$ac_cv_prog_cc_cross
14529
14530
14531 fi
14532
14533   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
14534   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
14535     for ac_func in _copysignl
14536 do
14537 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14538 echo "configure:14539: checking for $ac_func" >&5
14539 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14540   echo $ac_n "(cached) $ac_c" 1>&6
14541 else
14542   cat > conftest.$ac_ext <<EOF
14543 #line 14544 "configure"
14544 #include "confdefs.h"
14545 /* System header to define __stub macros and hopefully few prototypes,
14546     which can conflict with char $ac_func(); below.  */
14547 #include <assert.h>
14548 /* Override any gcc2 internal prototype to avoid an error.  */
14549 /* We use char because int might match the return type of a gcc2
14550     builtin and then its argument prototype would still apply.  */
14551 char $ac_func();
14552
14553 int main() {
14554
14555 /* The GNU C library defines this for functions which it implements
14556     to always fail with ENOSYS.  Some functions are actually named
14557     something starting with __ and the normal name is an alias.  */
14558 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14559 choke me
14560 #else
14561 $ac_func();
14562 #endif
14563
14564 ; return 0; }
14565 EOF
14566 if { (eval echo configure:14567: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14567   rm -rf conftest*
14568   eval "ac_cv_func_$ac_func=yes"
14569 else
14570   echo "configure: failed program was:" >&5
14571   cat conftest.$ac_ext >&5
14572   rm -rf conftest*
14573   eval "ac_cv_func_$ac_func=no"
14574 fi
14575 rm -f conftest*
14576 fi
14577
14578 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14579   echo "$ac_t""yes" 1>&6
14580     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14581   cat >> confdefs.h <<EOF
14582 #define $ac_tr_func 1
14583 EOF
14584
14585 else
14586   echo "$ac_t""no" 1>&6
14587 fi
14588 done
14589
14590   fi
14591
14592
14593   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14594 echo "configure:14595: checking for _acosl declaration" >&5
14595   if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
14596   echo $ac_n "(cached) $ac_c" 1>&6
14597 else
14598
14599
14600     ac_ext=C
14601 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14602 ac_cpp='$CXXCPP $CPPFLAGS'
14603 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14604 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14605 cross_compiling=$ac_cv_prog_cxx_cross
14606
14607     cat > conftest.$ac_ext <<EOF
14608 #line 14609 "configure"
14609 #include "confdefs.h"
14610 #include <math.h>
14611 int main() {
14612  _acosl(0);
14613 ; return 0; }
14614 EOF
14615 if { (eval echo configure:14616: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14616   rm -rf conftest*
14617   glibcpp_cv_func__acosl_use=yes
14618 else
14619   echo "configure: failed program was:" >&5
14620   cat conftest.$ac_ext >&5
14621   rm -rf conftest*
14622   glibcpp_cv_func__acosl_use=no
14623 fi
14624 rm -f conftest*
14625     ac_ext=c
14626 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14627 ac_cpp='$CPP $CPPFLAGS'
14628 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14629 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14630 cross_compiling=$ac_cv_prog_cc_cross
14631
14632
14633 fi
14634
14635   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
14636   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
14637     for ac_func in _acosl
14638 do
14639 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14640 echo "configure:14641: checking for $ac_func" >&5
14641 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14642   echo $ac_n "(cached) $ac_c" 1>&6
14643 else
14644   cat > conftest.$ac_ext <<EOF
14645 #line 14646 "configure"
14646 #include "confdefs.h"
14647 /* System header to define __stub macros and hopefully few prototypes,
14648     which can conflict with char $ac_func(); below.  */
14649 #include <assert.h>
14650 /* Override any gcc2 internal prototype to avoid an error.  */
14651 /* We use char because int might match the return type of a gcc2
14652     builtin and then its argument prototype would still apply.  */
14653 char $ac_func();
14654
14655 int main() {
14656
14657 /* The GNU C library defines this for functions which it implements
14658     to always fail with ENOSYS.  Some functions are actually named
14659     something starting with __ and the normal name is an alias.  */
14660 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14661 choke me
14662 #else
14663 $ac_func();
14664 #endif
14665
14666 ; return 0; }
14667 EOF
14668 if { (eval echo configure:14669: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14669   rm -rf conftest*
14670   eval "ac_cv_func_$ac_func=yes"
14671 else
14672   echo "configure: failed program was:" >&5
14673   cat conftest.$ac_ext >&5
14674   rm -rf conftest*
14675   eval "ac_cv_func_$ac_func=no"
14676 fi
14677 rm -f conftest*
14678 fi
14679
14680 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14681   echo "$ac_t""yes" 1>&6
14682     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14683   cat >> confdefs.h <<EOF
14684 #define $ac_tr_func 1
14685 EOF
14686
14687 else
14688   echo "$ac_t""no" 1>&6
14689 fi
14690 done
14691
14692   fi
14693
14694
14695   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14696 echo "configure:14697: checking for _asinl declaration" >&5
14697   if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
14698   echo $ac_n "(cached) $ac_c" 1>&6
14699 else
14700
14701
14702     ac_ext=C
14703 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14704 ac_cpp='$CXXCPP $CPPFLAGS'
14705 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14706 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14707 cross_compiling=$ac_cv_prog_cxx_cross
14708
14709     cat > conftest.$ac_ext <<EOF
14710 #line 14711 "configure"
14711 #include "confdefs.h"
14712 #include <math.h>
14713 int main() {
14714  _asinl(0);
14715 ; return 0; }
14716 EOF
14717 if { (eval echo configure:14718: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14718   rm -rf conftest*
14719   glibcpp_cv_func__asinl_use=yes
14720 else
14721   echo "configure: failed program was:" >&5
14722   cat conftest.$ac_ext >&5
14723   rm -rf conftest*
14724   glibcpp_cv_func__asinl_use=no
14725 fi
14726 rm -f conftest*
14727     ac_ext=c
14728 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14729 ac_cpp='$CPP $CPPFLAGS'
14730 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14731 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14732 cross_compiling=$ac_cv_prog_cc_cross
14733
14734
14735 fi
14736
14737   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
14738   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
14739     for ac_func in _asinl
14740 do
14741 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14742 echo "configure:14743: checking for $ac_func" >&5
14743 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14744   echo $ac_n "(cached) $ac_c" 1>&6
14745 else
14746   cat > conftest.$ac_ext <<EOF
14747 #line 14748 "configure"
14748 #include "confdefs.h"
14749 /* System header to define __stub macros and hopefully few prototypes,
14750     which can conflict with char $ac_func(); below.  */
14751 #include <assert.h>
14752 /* Override any gcc2 internal prototype to avoid an error.  */
14753 /* We use char because int might match the return type of a gcc2
14754     builtin and then its argument prototype would still apply.  */
14755 char $ac_func();
14756
14757 int main() {
14758
14759 /* The GNU C library defines this for functions which it implements
14760     to always fail with ENOSYS.  Some functions are actually named
14761     something starting with __ and the normal name is an alias.  */
14762 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14763 choke me
14764 #else
14765 $ac_func();
14766 #endif
14767
14768 ; return 0; }
14769 EOF
14770 if { (eval echo configure:14771: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14771   rm -rf conftest*
14772   eval "ac_cv_func_$ac_func=yes"
14773 else
14774   echo "configure: failed program was:" >&5
14775   cat conftest.$ac_ext >&5
14776   rm -rf conftest*
14777   eval "ac_cv_func_$ac_func=no"
14778 fi
14779 rm -f conftest*
14780 fi
14781
14782 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14783   echo "$ac_t""yes" 1>&6
14784     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14785   cat >> confdefs.h <<EOF
14786 #define $ac_tr_func 1
14787 EOF
14788
14789 else
14790   echo "$ac_t""no" 1>&6
14791 fi
14792 done
14793
14794   fi
14795
14796
14797   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14798 echo "configure:14799: checking for _atanl declaration" >&5
14799   if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
14800   echo $ac_n "(cached) $ac_c" 1>&6
14801 else
14802
14803
14804     ac_ext=C
14805 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14806 ac_cpp='$CXXCPP $CPPFLAGS'
14807 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14808 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14809 cross_compiling=$ac_cv_prog_cxx_cross
14810
14811     cat > conftest.$ac_ext <<EOF
14812 #line 14813 "configure"
14813 #include "confdefs.h"
14814 #include <math.h>
14815 int main() {
14816  _atanl(0);
14817 ; return 0; }
14818 EOF
14819 if { (eval echo configure:14820: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14820   rm -rf conftest*
14821   glibcpp_cv_func__atanl_use=yes
14822 else
14823   echo "configure: failed program was:" >&5
14824   cat conftest.$ac_ext >&5
14825   rm -rf conftest*
14826   glibcpp_cv_func__atanl_use=no
14827 fi
14828 rm -f conftest*
14829     ac_ext=c
14830 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14831 ac_cpp='$CPP $CPPFLAGS'
14832 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14833 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14834 cross_compiling=$ac_cv_prog_cc_cross
14835
14836
14837 fi
14838
14839   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
14840   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
14841     for ac_func in _atanl
14842 do
14843 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14844 echo "configure:14845: checking for $ac_func" >&5
14845 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14846   echo $ac_n "(cached) $ac_c" 1>&6
14847 else
14848   cat > conftest.$ac_ext <<EOF
14849 #line 14850 "configure"
14850 #include "confdefs.h"
14851 /* System header to define __stub macros and hopefully few prototypes,
14852     which can conflict with char $ac_func(); below.  */
14853 #include <assert.h>
14854 /* Override any gcc2 internal prototype to avoid an error.  */
14855 /* We use char because int might match the return type of a gcc2
14856     builtin and then its argument prototype would still apply.  */
14857 char $ac_func();
14858
14859 int main() {
14860
14861 /* The GNU C library defines this for functions which it implements
14862     to always fail with ENOSYS.  Some functions are actually named
14863     something starting with __ and the normal name is an alias.  */
14864 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14865 choke me
14866 #else
14867 $ac_func();
14868 #endif
14869
14870 ; return 0; }
14871 EOF
14872 if { (eval echo configure:14873: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14873   rm -rf conftest*
14874   eval "ac_cv_func_$ac_func=yes"
14875 else
14876   echo "configure: failed program was:" >&5
14877   cat conftest.$ac_ext >&5
14878   rm -rf conftest*
14879   eval "ac_cv_func_$ac_func=no"
14880 fi
14881 rm -f conftest*
14882 fi
14883
14884 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14885   echo "$ac_t""yes" 1>&6
14886     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14887   cat >> confdefs.h <<EOF
14888 #define $ac_tr_func 1
14889 EOF
14890
14891 else
14892   echo "$ac_t""no" 1>&6
14893 fi
14894 done
14895
14896   fi
14897
14898
14899   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14900 echo "configure:14901: checking for _atan2l declaration" >&5
14901   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
14902   echo $ac_n "(cached) $ac_c" 1>&6
14903 else
14904
14905
14906     ac_ext=C
14907 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14908 ac_cpp='$CXXCPP $CPPFLAGS'
14909 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14910 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14911 cross_compiling=$ac_cv_prog_cxx_cross
14912
14913     cat > conftest.$ac_ext <<EOF
14914 #line 14915 "configure"
14915 #include "confdefs.h"
14916 #include <math.h>
14917 int main() {
14918  _atan2l(0, 0);
14919 ; return 0; }
14920 EOF
14921 if { (eval echo configure:14922: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14922   rm -rf conftest*
14923   glibcpp_cv_func__atan2l_use=yes
14924 else
14925   echo "configure: failed program was:" >&5
14926   cat conftest.$ac_ext >&5
14927   rm -rf conftest*
14928   glibcpp_cv_func__atan2l_use=no
14929 fi
14930 rm -f conftest*
14931     ac_ext=c
14932 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14933 ac_cpp='$CPP $CPPFLAGS'
14934 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14935 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14936 cross_compiling=$ac_cv_prog_cc_cross
14937
14938
14939 fi
14940
14941   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
14942   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
14943     for ac_func in _atan2l
14944 do
14945 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14946 echo "configure:14947: checking for $ac_func" >&5
14947 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14948   echo $ac_n "(cached) $ac_c" 1>&6
14949 else
14950   cat > conftest.$ac_ext <<EOF
14951 #line 14952 "configure"
14952 #include "confdefs.h"
14953 /* System header to define __stub macros and hopefully few prototypes,
14954     which can conflict with char $ac_func(); below.  */
14955 #include <assert.h>
14956 /* Override any gcc2 internal prototype to avoid an error.  */
14957 /* We use char because int might match the return type of a gcc2
14958     builtin and then its argument prototype would still apply.  */
14959 char $ac_func();
14960
14961 int main() {
14962
14963 /* The GNU C library defines this for functions which it implements
14964     to always fail with ENOSYS.  Some functions are actually named
14965     something starting with __ and the normal name is an alias.  */
14966 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14967 choke me
14968 #else
14969 $ac_func();
14970 #endif
14971
14972 ; return 0; }
14973 EOF
14974 if { (eval echo configure:14975: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14975   rm -rf conftest*
14976   eval "ac_cv_func_$ac_func=yes"
14977 else
14978   echo "configure: failed program was:" >&5
14979   cat conftest.$ac_ext >&5
14980   rm -rf conftest*
14981   eval "ac_cv_func_$ac_func=no"
14982 fi
14983 rm -f conftest*
14984 fi
14985
14986 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14987   echo "$ac_t""yes" 1>&6
14988     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14989   cat >> confdefs.h <<EOF
14990 #define $ac_tr_func 1
14991 EOF
14992
14993 else
14994   echo "$ac_t""no" 1>&6
14995 fi
14996 done
14997
14998   fi
14999
15000
15001   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
15002 echo "configure:15003: checking for _ceill declaration" >&5
15003   if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
15004   echo $ac_n "(cached) $ac_c" 1>&6
15005 else
15006
15007
15008     ac_ext=C
15009 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15010 ac_cpp='$CXXCPP $CPPFLAGS'
15011 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15012 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15013 cross_compiling=$ac_cv_prog_cxx_cross
15014
15015     cat > conftest.$ac_ext <<EOF
15016 #line 15017 "configure"
15017 #include "confdefs.h"
15018 #include <math.h>
15019 int main() {
15020  _ceill(0);
15021 ; return 0; }
15022 EOF
15023 if { (eval echo configure:15024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15024   rm -rf conftest*
15025   glibcpp_cv_func__ceill_use=yes
15026 else
15027   echo "configure: failed program was:" >&5
15028   cat conftest.$ac_ext >&5
15029   rm -rf conftest*
15030   glibcpp_cv_func__ceill_use=no
15031 fi
15032 rm -f conftest*
15033     ac_ext=c
15034 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15035 ac_cpp='$CPP $CPPFLAGS'
15036 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15037 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15038 cross_compiling=$ac_cv_prog_cc_cross
15039
15040
15041 fi
15042
15043   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
15044   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
15045     for ac_func in _ceill
15046 do
15047 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15048 echo "configure:15049: checking for $ac_func" >&5
15049 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15050   echo $ac_n "(cached) $ac_c" 1>&6
15051 else
15052   cat > conftest.$ac_ext <<EOF
15053 #line 15054 "configure"
15054 #include "confdefs.h"
15055 /* System header to define __stub macros and hopefully few prototypes,
15056     which can conflict with char $ac_func(); below.  */
15057 #include <assert.h>
15058 /* Override any gcc2 internal prototype to avoid an error.  */
15059 /* We use char because int might match the return type of a gcc2
15060     builtin and then its argument prototype would still apply.  */
15061 char $ac_func();
15062
15063 int main() {
15064
15065 /* The GNU C library defines this for functions which it implements
15066     to always fail with ENOSYS.  Some functions are actually named
15067     something starting with __ and the normal name is an alias.  */
15068 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15069 choke me
15070 #else
15071 $ac_func();
15072 #endif
15073
15074 ; return 0; }
15075 EOF
15076 if { (eval echo configure:15077: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15077   rm -rf conftest*
15078   eval "ac_cv_func_$ac_func=yes"
15079 else
15080   echo "configure: failed program was:" >&5
15081   cat conftest.$ac_ext >&5
15082   rm -rf conftest*
15083   eval "ac_cv_func_$ac_func=no"
15084 fi
15085 rm -f conftest*
15086 fi
15087
15088 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15089   echo "$ac_t""yes" 1>&6
15090     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15091   cat >> confdefs.h <<EOF
15092 #define $ac_tr_func 1
15093 EOF
15094
15095 else
15096   echo "$ac_t""no" 1>&6
15097 fi
15098 done
15099
15100   fi
15101
15102
15103   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
15104 echo "configure:15105: checking for _cosl declaration" >&5
15105   if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
15106   echo $ac_n "(cached) $ac_c" 1>&6
15107 else
15108
15109
15110     ac_ext=C
15111 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15112 ac_cpp='$CXXCPP $CPPFLAGS'
15113 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15114 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15115 cross_compiling=$ac_cv_prog_cxx_cross
15116
15117     cat > conftest.$ac_ext <<EOF
15118 #line 15119 "configure"
15119 #include "confdefs.h"
15120 #include <math.h>
15121 int main() {
15122  _cosl(0);
15123 ; return 0; }
15124 EOF
15125 if { (eval echo configure:15126: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15126   rm -rf conftest*
15127   glibcpp_cv_func__cosl_use=yes
15128 else
15129   echo "configure: failed program was:" >&5
15130   cat conftest.$ac_ext >&5
15131   rm -rf conftest*
15132   glibcpp_cv_func__cosl_use=no
15133 fi
15134 rm -f conftest*
15135     ac_ext=c
15136 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15137 ac_cpp='$CPP $CPPFLAGS'
15138 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15139 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15140 cross_compiling=$ac_cv_prog_cc_cross
15141
15142
15143 fi
15144
15145   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
15146   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
15147     for ac_func in _cosl
15148 do
15149 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15150 echo "configure:15151: checking for $ac_func" >&5
15151 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15152   echo $ac_n "(cached) $ac_c" 1>&6
15153 else
15154   cat > conftest.$ac_ext <<EOF
15155 #line 15156 "configure"
15156 #include "confdefs.h"
15157 /* System header to define __stub macros and hopefully few prototypes,
15158     which can conflict with char $ac_func(); below.  */
15159 #include <assert.h>
15160 /* Override any gcc2 internal prototype to avoid an error.  */
15161 /* We use char because int might match the return type of a gcc2
15162     builtin and then its argument prototype would still apply.  */
15163 char $ac_func();
15164
15165 int main() {
15166
15167 /* The GNU C library defines this for functions which it implements
15168     to always fail with ENOSYS.  Some functions are actually named
15169     something starting with __ and the normal name is an alias.  */
15170 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15171 choke me
15172 #else
15173 $ac_func();
15174 #endif
15175
15176 ; return 0; }
15177 EOF
15178 if { (eval echo configure:15179: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15179   rm -rf conftest*
15180   eval "ac_cv_func_$ac_func=yes"
15181 else
15182   echo "configure: failed program was:" >&5
15183   cat conftest.$ac_ext >&5
15184   rm -rf conftest*
15185   eval "ac_cv_func_$ac_func=no"
15186 fi
15187 rm -f conftest*
15188 fi
15189
15190 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15191   echo "$ac_t""yes" 1>&6
15192     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15193   cat >> confdefs.h <<EOF
15194 #define $ac_tr_func 1
15195 EOF
15196
15197 else
15198   echo "$ac_t""no" 1>&6
15199 fi
15200 done
15201
15202   fi
15203
15204
15205   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
15206 echo "configure:15207: checking for _coshl declaration" >&5
15207   if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
15208   echo $ac_n "(cached) $ac_c" 1>&6
15209 else
15210
15211
15212     ac_ext=C
15213 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15214 ac_cpp='$CXXCPP $CPPFLAGS'
15215 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15216 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15217 cross_compiling=$ac_cv_prog_cxx_cross
15218
15219     cat > conftest.$ac_ext <<EOF
15220 #line 15221 "configure"
15221 #include "confdefs.h"
15222 #include <math.h>
15223 int main() {
15224  _coshl(0);
15225 ; return 0; }
15226 EOF
15227 if { (eval echo configure:15228: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15228   rm -rf conftest*
15229   glibcpp_cv_func__coshl_use=yes
15230 else
15231   echo "configure: failed program was:" >&5
15232   cat conftest.$ac_ext >&5
15233   rm -rf conftest*
15234   glibcpp_cv_func__coshl_use=no
15235 fi
15236 rm -f conftest*
15237     ac_ext=c
15238 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15239 ac_cpp='$CPP $CPPFLAGS'
15240 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15241 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15242 cross_compiling=$ac_cv_prog_cc_cross
15243
15244
15245 fi
15246
15247   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
15248   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
15249     for ac_func in _coshl
15250 do
15251 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15252 echo "configure:15253: checking for $ac_func" >&5
15253 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15254   echo $ac_n "(cached) $ac_c" 1>&6
15255 else
15256   cat > conftest.$ac_ext <<EOF
15257 #line 15258 "configure"
15258 #include "confdefs.h"
15259 /* System header to define __stub macros and hopefully few prototypes,
15260     which can conflict with char $ac_func(); below.  */
15261 #include <assert.h>
15262 /* Override any gcc2 internal prototype to avoid an error.  */
15263 /* We use char because int might match the return type of a gcc2
15264     builtin and then its argument prototype would still apply.  */
15265 char $ac_func();
15266
15267 int main() {
15268
15269 /* The GNU C library defines this for functions which it implements
15270     to always fail with ENOSYS.  Some functions are actually named
15271     something starting with __ and the normal name is an alias.  */
15272 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15273 choke me
15274 #else
15275 $ac_func();
15276 #endif
15277
15278 ; return 0; }
15279 EOF
15280 if { (eval echo configure:15281: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15281   rm -rf conftest*
15282   eval "ac_cv_func_$ac_func=yes"
15283 else
15284   echo "configure: failed program was:" >&5
15285   cat conftest.$ac_ext >&5
15286   rm -rf conftest*
15287   eval "ac_cv_func_$ac_func=no"
15288 fi
15289 rm -f conftest*
15290 fi
15291
15292 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15293   echo "$ac_t""yes" 1>&6
15294     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15295   cat >> confdefs.h <<EOF
15296 #define $ac_tr_func 1
15297 EOF
15298
15299 else
15300   echo "$ac_t""no" 1>&6
15301 fi
15302 done
15303
15304   fi
15305
15306
15307   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
15308 echo "configure:15309: checking for _expl declaration" >&5
15309   if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
15310   echo $ac_n "(cached) $ac_c" 1>&6
15311 else
15312
15313
15314     ac_ext=C
15315 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15316 ac_cpp='$CXXCPP $CPPFLAGS'
15317 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15318 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15319 cross_compiling=$ac_cv_prog_cxx_cross
15320
15321     cat > conftest.$ac_ext <<EOF
15322 #line 15323 "configure"
15323 #include "confdefs.h"
15324 #include <math.h>
15325 int main() {
15326  _expl(0);
15327 ; return 0; }
15328 EOF
15329 if { (eval echo configure:15330: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15330   rm -rf conftest*
15331   glibcpp_cv_func__expl_use=yes
15332 else
15333   echo "configure: failed program was:" >&5
15334   cat conftest.$ac_ext >&5
15335   rm -rf conftest*
15336   glibcpp_cv_func__expl_use=no
15337 fi
15338 rm -f conftest*
15339     ac_ext=c
15340 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15341 ac_cpp='$CPP $CPPFLAGS'
15342 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15343 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15344 cross_compiling=$ac_cv_prog_cc_cross
15345
15346
15347 fi
15348
15349   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
15350   if test x$glibcpp_cv_func__expl_use = x"yes"; then
15351     for ac_func in _expl
15352 do
15353 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15354 echo "configure:15355: checking for $ac_func" >&5
15355 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15356   echo $ac_n "(cached) $ac_c" 1>&6
15357 else
15358   cat > conftest.$ac_ext <<EOF
15359 #line 15360 "configure"
15360 #include "confdefs.h"
15361 /* System header to define __stub macros and hopefully few prototypes,
15362     which can conflict with char $ac_func(); below.  */
15363 #include <assert.h>
15364 /* Override any gcc2 internal prototype to avoid an error.  */
15365 /* We use char because int might match the return type of a gcc2
15366     builtin and then its argument prototype would still apply.  */
15367 char $ac_func();
15368
15369 int main() {
15370
15371 /* The GNU C library defines this for functions which it implements
15372     to always fail with ENOSYS.  Some functions are actually named
15373     something starting with __ and the normal name is an alias.  */
15374 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15375 choke me
15376 #else
15377 $ac_func();
15378 #endif
15379
15380 ; return 0; }
15381 EOF
15382 if { (eval echo configure:15383: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15383   rm -rf conftest*
15384   eval "ac_cv_func_$ac_func=yes"
15385 else
15386   echo "configure: failed program was:" >&5
15387   cat conftest.$ac_ext >&5
15388   rm -rf conftest*
15389   eval "ac_cv_func_$ac_func=no"
15390 fi
15391 rm -f conftest*
15392 fi
15393
15394 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15395   echo "$ac_t""yes" 1>&6
15396     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15397   cat >> confdefs.h <<EOF
15398 #define $ac_tr_func 1
15399 EOF
15400
15401 else
15402   echo "$ac_t""no" 1>&6
15403 fi
15404 done
15405
15406   fi
15407
15408
15409   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
15410 echo "configure:15411: checking for _fabsl declaration" >&5
15411   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
15412   echo $ac_n "(cached) $ac_c" 1>&6
15413 else
15414
15415
15416     ac_ext=C
15417 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15418 ac_cpp='$CXXCPP $CPPFLAGS'
15419 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15420 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15421 cross_compiling=$ac_cv_prog_cxx_cross
15422
15423     cat > conftest.$ac_ext <<EOF
15424 #line 15425 "configure"
15425 #include "confdefs.h"
15426 #include <math.h>
15427 int main() {
15428  _fabsl(0);
15429 ; return 0; }
15430 EOF
15431 if { (eval echo configure:15432: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15432   rm -rf conftest*
15433   glibcpp_cv_func__fabsl_use=yes
15434 else
15435   echo "configure: failed program was:" >&5
15436   cat conftest.$ac_ext >&5
15437   rm -rf conftest*
15438   glibcpp_cv_func__fabsl_use=no
15439 fi
15440 rm -f conftest*
15441     ac_ext=c
15442 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15443 ac_cpp='$CPP $CPPFLAGS'
15444 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15445 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15446 cross_compiling=$ac_cv_prog_cc_cross
15447
15448
15449 fi
15450
15451   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
15452   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
15453     for ac_func in _fabsl
15454 do
15455 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15456 echo "configure:15457: checking for $ac_func" >&5
15457 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15458   echo $ac_n "(cached) $ac_c" 1>&6
15459 else
15460   cat > conftest.$ac_ext <<EOF
15461 #line 15462 "configure"
15462 #include "confdefs.h"
15463 /* System header to define __stub macros and hopefully few prototypes,
15464     which can conflict with char $ac_func(); below.  */
15465 #include <assert.h>
15466 /* Override any gcc2 internal prototype to avoid an error.  */
15467 /* We use char because int might match the return type of a gcc2
15468     builtin and then its argument prototype would still apply.  */
15469 char $ac_func();
15470
15471 int main() {
15472
15473 /* The GNU C library defines this for functions which it implements
15474     to always fail with ENOSYS.  Some functions are actually named
15475     something starting with __ and the normal name is an alias.  */
15476 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15477 choke me
15478 #else
15479 $ac_func();
15480 #endif
15481
15482 ; return 0; }
15483 EOF
15484 if { (eval echo configure:15485: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15485   rm -rf conftest*
15486   eval "ac_cv_func_$ac_func=yes"
15487 else
15488   echo "configure: failed program was:" >&5
15489   cat conftest.$ac_ext >&5
15490   rm -rf conftest*
15491   eval "ac_cv_func_$ac_func=no"
15492 fi
15493 rm -f conftest*
15494 fi
15495
15496 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15497   echo "$ac_t""yes" 1>&6
15498     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15499   cat >> confdefs.h <<EOF
15500 #define $ac_tr_func 1
15501 EOF
15502
15503 else
15504   echo "$ac_t""no" 1>&6
15505 fi
15506 done
15507
15508   fi
15509
15510
15511   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
15512 echo "configure:15513: checking for _floorl declaration" >&5
15513   if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
15514   echo $ac_n "(cached) $ac_c" 1>&6
15515 else
15516
15517
15518     ac_ext=C
15519 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15520 ac_cpp='$CXXCPP $CPPFLAGS'
15521 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15522 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15523 cross_compiling=$ac_cv_prog_cxx_cross
15524
15525     cat > conftest.$ac_ext <<EOF
15526 #line 15527 "configure"
15527 #include "confdefs.h"
15528 #include <math.h>
15529 int main() {
15530  _floorl(0);
15531 ; return 0; }
15532 EOF
15533 if { (eval echo configure:15534: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15534   rm -rf conftest*
15535   glibcpp_cv_func__floorl_use=yes
15536 else
15537   echo "configure: failed program was:" >&5
15538   cat conftest.$ac_ext >&5
15539   rm -rf conftest*
15540   glibcpp_cv_func__floorl_use=no
15541 fi
15542 rm -f conftest*
15543     ac_ext=c
15544 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15545 ac_cpp='$CPP $CPPFLAGS'
15546 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15547 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15548 cross_compiling=$ac_cv_prog_cc_cross
15549
15550
15551 fi
15552
15553   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
15554   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
15555     for ac_func in _floorl
15556 do
15557 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15558 echo "configure:15559: checking for $ac_func" >&5
15559 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15560   echo $ac_n "(cached) $ac_c" 1>&6
15561 else
15562   cat > conftest.$ac_ext <<EOF
15563 #line 15564 "configure"
15564 #include "confdefs.h"
15565 /* System header to define __stub macros and hopefully few prototypes,
15566     which can conflict with char $ac_func(); below.  */
15567 #include <assert.h>
15568 /* Override any gcc2 internal prototype to avoid an error.  */
15569 /* We use char because int might match the return type of a gcc2
15570     builtin and then its argument prototype would still apply.  */
15571 char $ac_func();
15572
15573 int main() {
15574
15575 /* The GNU C library defines this for functions which it implements
15576     to always fail with ENOSYS.  Some functions are actually named
15577     something starting with __ and the normal name is an alias.  */
15578 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15579 choke me
15580 #else
15581 $ac_func();
15582 #endif
15583
15584 ; return 0; }
15585 EOF
15586 if { (eval echo configure:15587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15587   rm -rf conftest*
15588   eval "ac_cv_func_$ac_func=yes"
15589 else
15590   echo "configure: failed program was:" >&5
15591   cat conftest.$ac_ext >&5
15592   rm -rf conftest*
15593   eval "ac_cv_func_$ac_func=no"
15594 fi
15595 rm -f conftest*
15596 fi
15597
15598 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15599   echo "$ac_t""yes" 1>&6
15600     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15601   cat >> confdefs.h <<EOF
15602 #define $ac_tr_func 1
15603 EOF
15604
15605 else
15606   echo "$ac_t""no" 1>&6
15607 fi
15608 done
15609
15610   fi
15611
15612
15613   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
15614 echo "configure:15615: checking for _fmodl declaration" >&5
15615   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
15616   echo $ac_n "(cached) $ac_c" 1>&6
15617 else
15618
15619
15620     ac_ext=C
15621 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15622 ac_cpp='$CXXCPP $CPPFLAGS'
15623 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15624 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15625 cross_compiling=$ac_cv_prog_cxx_cross
15626
15627     cat > conftest.$ac_ext <<EOF
15628 #line 15629 "configure"
15629 #include "confdefs.h"
15630 #include <math.h>
15631 int main() {
15632  _fmodl(0, 0);
15633 ; return 0; }
15634 EOF
15635 if { (eval echo configure:15636: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15636   rm -rf conftest*
15637   glibcpp_cv_func__fmodl_use=yes
15638 else
15639   echo "configure: failed program was:" >&5
15640   cat conftest.$ac_ext >&5
15641   rm -rf conftest*
15642   glibcpp_cv_func__fmodl_use=no
15643 fi
15644 rm -f conftest*
15645     ac_ext=c
15646 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15647 ac_cpp='$CPP $CPPFLAGS'
15648 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15649 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15650 cross_compiling=$ac_cv_prog_cc_cross
15651
15652
15653 fi
15654
15655   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
15656   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
15657     for ac_func in _fmodl
15658 do
15659 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15660 echo "configure:15661: checking for $ac_func" >&5
15661 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15662   echo $ac_n "(cached) $ac_c" 1>&6
15663 else
15664   cat > conftest.$ac_ext <<EOF
15665 #line 15666 "configure"
15666 #include "confdefs.h"
15667 /* System header to define __stub macros and hopefully few prototypes,
15668     which can conflict with char $ac_func(); below.  */
15669 #include <assert.h>
15670 /* Override any gcc2 internal prototype to avoid an error.  */
15671 /* We use char because int might match the return type of a gcc2
15672     builtin and then its argument prototype would still apply.  */
15673 char $ac_func();
15674
15675 int main() {
15676
15677 /* The GNU C library defines this for functions which it implements
15678     to always fail with ENOSYS.  Some functions are actually named
15679     something starting with __ and the normal name is an alias.  */
15680 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15681 choke me
15682 #else
15683 $ac_func();
15684 #endif
15685
15686 ; return 0; }
15687 EOF
15688 if { (eval echo configure:15689: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15689   rm -rf conftest*
15690   eval "ac_cv_func_$ac_func=yes"
15691 else
15692   echo "configure: failed program was:" >&5
15693   cat conftest.$ac_ext >&5
15694   rm -rf conftest*
15695   eval "ac_cv_func_$ac_func=no"
15696 fi
15697 rm -f conftest*
15698 fi
15699
15700 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15701   echo "$ac_t""yes" 1>&6
15702     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15703   cat >> confdefs.h <<EOF
15704 #define $ac_tr_func 1
15705 EOF
15706
15707 else
15708   echo "$ac_t""no" 1>&6
15709 fi
15710 done
15711
15712   fi
15713
15714
15715   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15716 echo "configure:15717: checking for _frexpl declaration" >&5
15717   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
15718   echo $ac_n "(cached) $ac_c" 1>&6
15719 else
15720
15721
15722     ac_ext=C
15723 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15724 ac_cpp='$CXXCPP $CPPFLAGS'
15725 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15726 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15727 cross_compiling=$ac_cv_prog_cxx_cross
15728
15729     cat > conftest.$ac_ext <<EOF
15730 #line 15731 "configure"
15731 #include "confdefs.h"
15732 #include <math.h>
15733 int main() {
15734  _frexpl(0, 0);
15735 ; return 0; }
15736 EOF
15737 if { (eval echo configure:15738: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15738   rm -rf conftest*
15739   glibcpp_cv_func__frexpl_use=yes
15740 else
15741   echo "configure: failed program was:" >&5
15742   cat conftest.$ac_ext >&5
15743   rm -rf conftest*
15744   glibcpp_cv_func__frexpl_use=no
15745 fi
15746 rm -f conftest*
15747     ac_ext=c
15748 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15749 ac_cpp='$CPP $CPPFLAGS'
15750 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15751 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15752 cross_compiling=$ac_cv_prog_cc_cross
15753
15754
15755 fi
15756
15757   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
15758   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
15759     for ac_func in _frexpl
15760 do
15761 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15762 echo "configure:15763: checking for $ac_func" >&5
15763 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15764   echo $ac_n "(cached) $ac_c" 1>&6
15765 else
15766   cat > conftest.$ac_ext <<EOF
15767 #line 15768 "configure"
15768 #include "confdefs.h"
15769 /* System header to define __stub macros and hopefully few prototypes,
15770     which can conflict with char $ac_func(); below.  */
15771 #include <assert.h>
15772 /* Override any gcc2 internal prototype to avoid an error.  */
15773 /* We use char because int might match the return type of a gcc2
15774     builtin and then its argument prototype would still apply.  */
15775 char $ac_func();
15776
15777 int main() {
15778
15779 /* The GNU C library defines this for functions which it implements
15780     to always fail with ENOSYS.  Some functions are actually named
15781     something starting with __ and the normal name is an alias.  */
15782 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15783 choke me
15784 #else
15785 $ac_func();
15786 #endif
15787
15788 ; return 0; }
15789 EOF
15790 if { (eval echo configure:15791: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15791   rm -rf conftest*
15792   eval "ac_cv_func_$ac_func=yes"
15793 else
15794   echo "configure: failed program was:" >&5
15795   cat conftest.$ac_ext >&5
15796   rm -rf conftest*
15797   eval "ac_cv_func_$ac_func=no"
15798 fi
15799 rm -f conftest*
15800 fi
15801
15802 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15803   echo "$ac_t""yes" 1>&6
15804     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15805   cat >> confdefs.h <<EOF
15806 #define $ac_tr_func 1
15807 EOF
15808
15809 else
15810   echo "$ac_t""no" 1>&6
15811 fi
15812 done
15813
15814   fi
15815
15816
15817   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15818 echo "configure:15819: checking for _ldexpl declaration" >&5
15819   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
15820   echo $ac_n "(cached) $ac_c" 1>&6
15821 else
15822
15823
15824     ac_ext=C
15825 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15826 ac_cpp='$CXXCPP $CPPFLAGS'
15827 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15828 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15829 cross_compiling=$ac_cv_prog_cxx_cross
15830
15831     cat > conftest.$ac_ext <<EOF
15832 #line 15833 "configure"
15833 #include "confdefs.h"
15834 #include <math.h>
15835 int main() {
15836  _ldexpl(0, 0);
15837 ; return 0; }
15838 EOF
15839 if { (eval echo configure:15840: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15840   rm -rf conftest*
15841   glibcpp_cv_func__ldexpl_use=yes
15842 else
15843   echo "configure: failed program was:" >&5
15844   cat conftest.$ac_ext >&5
15845   rm -rf conftest*
15846   glibcpp_cv_func__ldexpl_use=no
15847 fi
15848 rm -f conftest*
15849     ac_ext=c
15850 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15851 ac_cpp='$CPP $CPPFLAGS'
15852 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15853 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15854 cross_compiling=$ac_cv_prog_cc_cross
15855
15856
15857 fi
15858
15859   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
15860   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
15861     for ac_func in _ldexpl
15862 do
15863 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15864 echo "configure:15865: checking for $ac_func" >&5
15865 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15866   echo $ac_n "(cached) $ac_c" 1>&6
15867 else
15868   cat > conftest.$ac_ext <<EOF
15869 #line 15870 "configure"
15870 #include "confdefs.h"
15871 /* System header to define __stub macros and hopefully few prototypes,
15872     which can conflict with char $ac_func(); below.  */
15873 #include <assert.h>
15874 /* Override any gcc2 internal prototype to avoid an error.  */
15875 /* We use char because int might match the return type of a gcc2
15876     builtin and then its argument prototype would still apply.  */
15877 char $ac_func();
15878
15879 int main() {
15880
15881 /* The GNU C library defines this for functions which it implements
15882     to always fail with ENOSYS.  Some functions are actually named
15883     something starting with __ and the normal name is an alias.  */
15884 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15885 choke me
15886 #else
15887 $ac_func();
15888 #endif
15889
15890 ; return 0; }
15891 EOF
15892 if { (eval echo configure:15893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15893   rm -rf conftest*
15894   eval "ac_cv_func_$ac_func=yes"
15895 else
15896   echo "configure: failed program was:" >&5
15897   cat conftest.$ac_ext >&5
15898   rm -rf conftest*
15899   eval "ac_cv_func_$ac_func=no"
15900 fi
15901 rm -f conftest*
15902 fi
15903
15904 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15905   echo "$ac_t""yes" 1>&6
15906     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15907   cat >> confdefs.h <<EOF
15908 #define $ac_tr_func 1
15909 EOF
15910
15911 else
15912   echo "$ac_t""no" 1>&6
15913 fi
15914 done
15915
15916   fi
15917
15918
15919   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15920 echo "configure:15921: checking for _logl declaration" >&5
15921   if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
15922   echo $ac_n "(cached) $ac_c" 1>&6
15923 else
15924
15925
15926     ac_ext=C
15927 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15928 ac_cpp='$CXXCPP $CPPFLAGS'
15929 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15930 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15931 cross_compiling=$ac_cv_prog_cxx_cross
15932
15933     cat > conftest.$ac_ext <<EOF
15934 #line 15935 "configure"
15935 #include "confdefs.h"
15936 #include <math.h>
15937 int main() {
15938  _logl(0);
15939 ; return 0; }
15940 EOF
15941 if { (eval echo configure:15942: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15942   rm -rf conftest*
15943   glibcpp_cv_func__logl_use=yes
15944 else
15945   echo "configure: failed program was:" >&5
15946   cat conftest.$ac_ext >&5
15947   rm -rf conftest*
15948   glibcpp_cv_func__logl_use=no
15949 fi
15950 rm -f conftest*
15951     ac_ext=c
15952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15953 ac_cpp='$CPP $CPPFLAGS'
15954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15956 cross_compiling=$ac_cv_prog_cc_cross
15957
15958
15959 fi
15960
15961   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
15962   if test x$glibcpp_cv_func__logl_use = x"yes"; then
15963     for ac_func in _logl
15964 do
15965 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15966 echo "configure:15967: checking for $ac_func" >&5
15967 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15968   echo $ac_n "(cached) $ac_c" 1>&6
15969 else
15970   cat > conftest.$ac_ext <<EOF
15971 #line 15972 "configure"
15972 #include "confdefs.h"
15973 /* System header to define __stub macros and hopefully few prototypes,
15974     which can conflict with char $ac_func(); below.  */
15975 #include <assert.h>
15976 /* Override any gcc2 internal prototype to avoid an error.  */
15977 /* We use char because int might match the return type of a gcc2
15978     builtin and then its argument prototype would still apply.  */
15979 char $ac_func();
15980
15981 int main() {
15982
15983 /* The GNU C library defines this for functions which it implements
15984     to always fail with ENOSYS.  Some functions are actually named
15985     something starting with __ and the normal name is an alias.  */
15986 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15987 choke me
15988 #else
15989 $ac_func();
15990 #endif
15991
15992 ; return 0; }
15993 EOF
15994 if { (eval echo configure:15995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15995   rm -rf conftest*
15996   eval "ac_cv_func_$ac_func=yes"
15997 else
15998   echo "configure: failed program was:" >&5
15999   cat conftest.$ac_ext >&5
16000   rm -rf conftest*
16001   eval "ac_cv_func_$ac_func=no"
16002 fi
16003 rm -f conftest*
16004 fi
16005
16006 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16007   echo "$ac_t""yes" 1>&6
16008     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16009   cat >> confdefs.h <<EOF
16010 #define $ac_tr_func 1
16011 EOF
16012
16013 else
16014   echo "$ac_t""no" 1>&6
16015 fi
16016 done
16017
16018   fi
16019
16020
16021   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
16022 echo "configure:16023: checking for _log10l declaration" >&5
16023   if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
16024   echo $ac_n "(cached) $ac_c" 1>&6
16025 else
16026
16027
16028     ac_ext=C
16029 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16030 ac_cpp='$CXXCPP $CPPFLAGS'
16031 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16032 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16033 cross_compiling=$ac_cv_prog_cxx_cross
16034
16035     cat > conftest.$ac_ext <<EOF
16036 #line 16037 "configure"
16037 #include "confdefs.h"
16038 #include <math.h>
16039 int main() {
16040  _log10l(0);
16041 ; return 0; }
16042 EOF
16043 if { (eval echo configure:16044: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16044   rm -rf conftest*
16045   glibcpp_cv_func__log10l_use=yes
16046 else
16047   echo "configure: failed program was:" >&5
16048   cat conftest.$ac_ext >&5
16049   rm -rf conftest*
16050   glibcpp_cv_func__log10l_use=no
16051 fi
16052 rm -f conftest*
16053     ac_ext=c
16054 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16055 ac_cpp='$CPP $CPPFLAGS'
16056 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16057 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16058 cross_compiling=$ac_cv_prog_cc_cross
16059
16060
16061 fi
16062
16063   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16064   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16065     for ac_func in _log10l
16066 do
16067 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16068 echo "configure:16069: checking for $ac_func" >&5
16069 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16070   echo $ac_n "(cached) $ac_c" 1>&6
16071 else
16072   cat > conftest.$ac_ext <<EOF
16073 #line 16074 "configure"
16074 #include "confdefs.h"
16075 /* System header to define __stub macros and hopefully few prototypes,
16076     which can conflict with char $ac_func(); below.  */
16077 #include <assert.h>
16078 /* Override any gcc2 internal prototype to avoid an error.  */
16079 /* We use char because int might match the return type of a gcc2
16080     builtin and then its argument prototype would still apply.  */
16081 char $ac_func();
16082
16083 int main() {
16084
16085 /* The GNU C library defines this for functions which it implements
16086     to always fail with ENOSYS.  Some functions are actually named
16087     something starting with __ and the normal name is an alias.  */
16088 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16089 choke me
16090 #else
16091 $ac_func();
16092 #endif
16093
16094 ; return 0; }
16095 EOF
16096 if { (eval echo configure:16097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16097   rm -rf conftest*
16098   eval "ac_cv_func_$ac_func=yes"
16099 else
16100   echo "configure: failed program was:" >&5
16101   cat conftest.$ac_ext >&5
16102   rm -rf conftest*
16103   eval "ac_cv_func_$ac_func=no"
16104 fi
16105 rm -f conftest*
16106 fi
16107
16108 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16109   echo "$ac_t""yes" 1>&6
16110     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16111   cat >> confdefs.h <<EOF
16112 #define $ac_tr_func 1
16113 EOF
16114
16115 else
16116   echo "$ac_t""no" 1>&6
16117 fi
16118 done
16119
16120   fi
16121
16122
16123   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
16124 echo "configure:16125: checking for _modfl declaration" >&5
16125   if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
16126   echo $ac_n "(cached) $ac_c" 1>&6
16127 else
16128
16129
16130     ac_ext=C
16131 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16132 ac_cpp='$CXXCPP $CPPFLAGS'
16133 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16134 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16135 cross_compiling=$ac_cv_prog_cxx_cross
16136
16137     cat > conftest.$ac_ext <<EOF
16138 #line 16139 "configure"
16139 #include "confdefs.h"
16140 #include <math.h>
16141 int main() {
16142  _modfl(0, 0);
16143 ; return 0; }
16144 EOF
16145 if { (eval echo configure:16146: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16146   rm -rf conftest*
16147   glibcpp_cv_func__modfl_use=yes
16148 else
16149   echo "configure: failed program was:" >&5
16150   cat conftest.$ac_ext >&5
16151   rm -rf conftest*
16152   glibcpp_cv_func__modfl_use=no
16153 fi
16154 rm -f conftest*
16155     ac_ext=c
16156 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16157 ac_cpp='$CPP $CPPFLAGS'
16158 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16159 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16160 cross_compiling=$ac_cv_prog_cc_cross
16161
16162
16163 fi
16164
16165   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
16166   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
16167     for ac_func in _modfl
16168 do
16169 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16170 echo "configure:16171: checking for $ac_func" >&5
16171 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16172   echo $ac_n "(cached) $ac_c" 1>&6
16173 else
16174   cat > conftest.$ac_ext <<EOF
16175 #line 16176 "configure"
16176 #include "confdefs.h"
16177 /* System header to define __stub macros and hopefully few prototypes,
16178     which can conflict with char $ac_func(); below.  */
16179 #include <assert.h>
16180 /* Override any gcc2 internal prototype to avoid an error.  */
16181 /* We use char because int might match the return type of a gcc2
16182     builtin and then its argument prototype would still apply.  */
16183 char $ac_func();
16184
16185 int main() {
16186
16187 /* The GNU C library defines this for functions which it implements
16188     to always fail with ENOSYS.  Some functions are actually named
16189     something starting with __ and the normal name is an alias.  */
16190 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16191 choke me
16192 #else
16193 $ac_func();
16194 #endif
16195
16196 ; return 0; }
16197 EOF
16198 if { (eval echo configure:16199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16199   rm -rf conftest*
16200   eval "ac_cv_func_$ac_func=yes"
16201 else
16202   echo "configure: failed program was:" >&5
16203   cat conftest.$ac_ext >&5
16204   rm -rf conftest*
16205   eval "ac_cv_func_$ac_func=no"
16206 fi
16207 rm -f conftest*
16208 fi
16209
16210 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16211   echo "$ac_t""yes" 1>&6
16212     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16213   cat >> confdefs.h <<EOF
16214 #define $ac_tr_func 1
16215 EOF
16216
16217 else
16218   echo "$ac_t""no" 1>&6
16219 fi
16220 done
16221
16222   fi
16223
16224
16225   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
16226 echo "configure:16227: checking for _powl declaration" >&5
16227   if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
16228   echo $ac_n "(cached) $ac_c" 1>&6
16229 else
16230
16231
16232     ac_ext=C
16233 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16234 ac_cpp='$CXXCPP $CPPFLAGS'
16235 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16236 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16237 cross_compiling=$ac_cv_prog_cxx_cross
16238
16239     cat > conftest.$ac_ext <<EOF
16240 #line 16241 "configure"
16241 #include "confdefs.h"
16242 #include <math.h>
16243 int main() {
16244  _powl(0, 0);
16245 ; return 0; }
16246 EOF
16247 if { (eval echo configure:16248: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16248   rm -rf conftest*
16249   glibcpp_cv_func__powl_use=yes
16250 else
16251   echo "configure: failed program was:" >&5
16252   cat conftest.$ac_ext >&5
16253   rm -rf conftest*
16254   glibcpp_cv_func__powl_use=no
16255 fi
16256 rm -f conftest*
16257     ac_ext=c
16258 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16259 ac_cpp='$CPP $CPPFLAGS'
16260 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16261 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16262 cross_compiling=$ac_cv_prog_cc_cross
16263
16264
16265 fi
16266
16267   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
16268   if test x$glibcpp_cv_func__powl_use = x"yes"; then
16269     for ac_func in _powl
16270 do
16271 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16272 echo "configure:16273: checking for $ac_func" >&5
16273 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16274   echo $ac_n "(cached) $ac_c" 1>&6
16275 else
16276   cat > conftest.$ac_ext <<EOF
16277 #line 16278 "configure"
16278 #include "confdefs.h"
16279 /* System header to define __stub macros and hopefully few prototypes,
16280     which can conflict with char $ac_func(); below.  */
16281 #include <assert.h>
16282 /* Override any gcc2 internal prototype to avoid an error.  */
16283 /* We use char because int might match the return type of a gcc2
16284     builtin and then its argument prototype would still apply.  */
16285 char $ac_func();
16286
16287 int main() {
16288
16289 /* The GNU C library defines this for functions which it implements
16290     to always fail with ENOSYS.  Some functions are actually named
16291     something starting with __ and the normal name is an alias.  */
16292 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16293 choke me
16294 #else
16295 $ac_func();
16296 #endif
16297
16298 ; return 0; }
16299 EOF
16300 if { (eval echo configure:16301: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16301   rm -rf conftest*
16302   eval "ac_cv_func_$ac_func=yes"
16303 else
16304   echo "configure: failed program was:" >&5
16305   cat conftest.$ac_ext >&5
16306   rm -rf conftest*
16307   eval "ac_cv_func_$ac_func=no"
16308 fi
16309 rm -f conftest*
16310 fi
16311
16312 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16313   echo "$ac_t""yes" 1>&6
16314     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16315   cat >> confdefs.h <<EOF
16316 #define $ac_tr_func 1
16317 EOF
16318
16319 else
16320   echo "$ac_t""no" 1>&6
16321 fi
16322 done
16323
16324   fi
16325
16326
16327   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
16328 echo "configure:16329: checking for _sinl declaration" >&5
16329   if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
16330   echo $ac_n "(cached) $ac_c" 1>&6
16331 else
16332
16333
16334     ac_ext=C
16335 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16336 ac_cpp='$CXXCPP $CPPFLAGS'
16337 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16338 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16339 cross_compiling=$ac_cv_prog_cxx_cross
16340
16341     cat > conftest.$ac_ext <<EOF
16342 #line 16343 "configure"
16343 #include "confdefs.h"
16344 #include <math.h>
16345 int main() {
16346  _sinl(0);
16347 ; return 0; }
16348 EOF
16349 if { (eval echo configure:16350: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16350   rm -rf conftest*
16351   glibcpp_cv_func__sinl_use=yes
16352 else
16353   echo "configure: failed program was:" >&5
16354   cat conftest.$ac_ext >&5
16355   rm -rf conftest*
16356   glibcpp_cv_func__sinl_use=no
16357 fi
16358 rm -f conftest*
16359     ac_ext=c
16360 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16361 ac_cpp='$CPP $CPPFLAGS'
16362 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16363 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16364 cross_compiling=$ac_cv_prog_cc_cross
16365
16366
16367 fi
16368
16369   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
16370   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
16371     for ac_func in _sinl
16372 do
16373 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16374 echo "configure:16375: checking for $ac_func" >&5
16375 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16376   echo $ac_n "(cached) $ac_c" 1>&6
16377 else
16378   cat > conftest.$ac_ext <<EOF
16379 #line 16380 "configure"
16380 #include "confdefs.h"
16381 /* System header to define __stub macros and hopefully few prototypes,
16382     which can conflict with char $ac_func(); below.  */
16383 #include <assert.h>
16384 /* Override any gcc2 internal prototype to avoid an error.  */
16385 /* We use char because int might match the return type of a gcc2
16386     builtin and then its argument prototype would still apply.  */
16387 char $ac_func();
16388
16389 int main() {
16390
16391 /* The GNU C library defines this for functions which it implements
16392     to always fail with ENOSYS.  Some functions are actually named
16393     something starting with __ and the normal name is an alias.  */
16394 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16395 choke me
16396 #else
16397 $ac_func();
16398 #endif
16399
16400 ; return 0; }
16401 EOF
16402 if { (eval echo configure:16403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16403   rm -rf conftest*
16404   eval "ac_cv_func_$ac_func=yes"
16405 else
16406   echo "configure: failed program was:" >&5
16407   cat conftest.$ac_ext >&5
16408   rm -rf conftest*
16409   eval "ac_cv_func_$ac_func=no"
16410 fi
16411 rm -f conftest*
16412 fi
16413
16414 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16415   echo "$ac_t""yes" 1>&6
16416     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16417   cat >> confdefs.h <<EOF
16418 #define $ac_tr_func 1
16419 EOF
16420
16421 else
16422   echo "$ac_t""no" 1>&6
16423 fi
16424 done
16425
16426   fi
16427
16428
16429   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
16430 echo "configure:16431: checking for _sinhl declaration" >&5
16431   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
16432   echo $ac_n "(cached) $ac_c" 1>&6
16433 else
16434
16435
16436     ac_ext=C
16437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16438 ac_cpp='$CXXCPP $CPPFLAGS'
16439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16441 cross_compiling=$ac_cv_prog_cxx_cross
16442
16443     cat > conftest.$ac_ext <<EOF
16444 #line 16445 "configure"
16445 #include "confdefs.h"
16446 #include <math.h>
16447 int main() {
16448  _sinhl(0);
16449 ; return 0; }
16450 EOF
16451 if { (eval echo configure:16452: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16452   rm -rf conftest*
16453   glibcpp_cv_func__sinhl_use=yes
16454 else
16455   echo "configure: failed program was:" >&5
16456   cat conftest.$ac_ext >&5
16457   rm -rf conftest*
16458   glibcpp_cv_func__sinhl_use=no
16459 fi
16460 rm -f conftest*
16461     ac_ext=c
16462 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16463 ac_cpp='$CPP $CPPFLAGS'
16464 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16465 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16466 cross_compiling=$ac_cv_prog_cc_cross
16467
16468
16469 fi
16470
16471   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
16472   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
16473     for ac_func in _sinhl
16474 do
16475 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16476 echo "configure:16477: checking for $ac_func" >&5
16477 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16478   echo $ac_n "(cached) $ac_c" 1>&6
16479 else
16480   cat > conftest.$ac_ext <<EOF
16481 #line 16482 "configure"
16482 #include "confdefs.h"
16483 /* System header to define __stub macros and hopefully few prototypes,
16484     which can conflict with char $ac_func(); below.  */
16485 #include <assert.h>
16486 /* Override any gcc2 internal prototype to avoid an error.  */
16487 /* We use char because int might match the return type of a gcc2
16488     builtin and then its argument prototype would still apply.  */
16489 char $ac_func();
16490
16491 int main() {
16492
16493 /* The GNU C library defines this for functions which it implements
16494     to always fail with ENOSYS.  Some functions are actually named
16495     something starting with __ and the normal name is an alias.  */
16496 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16497 choke me
16498 #else
16499 $ac_func();
16500 #endif
16501
16502 ; return 0; }
16503 EOF
16504 if { (eval echo configure:16505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16505   rm -rf conftest*
16506   eval "ac_cv_func_$ac_func=yes"
16507 else
16508   echo "configure: failed program was:" >&5
16509   cat conftest.$ac_ext >&5
16510   rm -rf conftest*
16511   eval "ac_cv_func_$ac_func=no"
16512 fi
16513 rm -f conftest*
16514 fi
16515
16516 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16517   echo "$ac_t""yes" 1>&6
16518     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16519   cat >> confdefs.h <<EOF
16520 #define $ac_tr_func 1
16521 EOF
16522
16523 else
16524   echo "$ac_t""no" 1>&6
16525 fi
16526 done
16527
16528   fi
16529
16530
16531   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
16532 echo "configure:16533: checking for _sqrtl declaration" >&5
16533   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
16534   echo $ac_n "(cached) $ac_c" 1>&6
16535 else
16536
16537
16538     ac_ext=C
16539 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16540 ac_cpp='$CXXCPP $CPPFLAGS'
16541 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16542 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16543 cross_compiling=$ac_cv_prog_cxx_cross
16544
16545     cat > conftest.$ac_ext <<EOF
16546 #line 16547 "configure"
16547 #include "confdefs.h"
16548 #include <math.h>
16549 int main() {
16550  _sqrtl(0);
16551 ; return 0; }
16552 EOF
16553 if { (eval echo configure:16554: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16554   rm -rf conftest*
16555   glibcpp_cv_func__sqrtl_use=yes
16556 else
16557   echo "configure: failed program was:" >&5
16558   cat conftest.$ac_ext >&5
16559   rm -rf conftest*
16560   glibcpp_cv_func__sqrtl_use=no
16561 fi
16562 rm -f conftest*
16563     ac_ext=c
16564 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16565 ac_cpp='$CPP $CPPFLAGS'
16566 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16567 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16568 cross_compiling=$ac_cv_prog_cc_cross
16569
16570
16571 fi
16572
16573   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
16574   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
16575     for ac_func in _sqrtl
16576 do
16577 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16578 echo "configure:16579: checking for $ac_func" >&5
16579 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16580   echo $ac_n "(cached) $ac_c" 1>&6
16581 else
16582   cat > conftest.$ac_ext <<EOF
16583 #line 16584 "configure"
16584 #include "confdefs.h"
16585 /* System header to define __stub macros and hopefully few prototypes,
16586     which can conflict with char $ac_func(); below.  */
16587 #include <assert.h>
16588 /* Override any gcc2 internal prototype to avoid an error.  */
16589 /* We use char because int might match the return type of a gcc2
16590     builtin and then its argument prototype would still apply.  */
16591 char $ac_func();
16592
16593 int main() {
16594
16595 /* The GNU C library defines this for functions which it implements
16596     to always fail with ENOSYS.  Some functions are actually named
16597     something starting with __ and the normal name is an alias.  */
16598 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16599 choke me
16600 #else
16601 $ac_func();
16602 #endif
16603
16604 ; return 0; }
16605 EOF
16606 if { (eval echo configure:16607: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16607   rm -rf conftest*
16608   eval "ac_cv_func_$ac_func=yes"
16609 else
16610   echo "configure: failed program was:" >&5
16611   cat conftest.$ac_ext >&5
16612   rm -rf conftest*
16613   eval "ac_cv_func_$ac_func=no"
16614 fi
16615 rm -f conftest*
16616 fi
16617
16618 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16619   echo "$ac_t""yes" 1>&6
16620     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16621   cat >> confdefs.h <<EOF
16622 #define $ac_tr_func 1
16623 EOF
16624
16625 else
16626   echo "$ac_t""no" 1>&6
16627 fi
16628 done
16629
16630   fi
16631
16632
16633   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
16634 echo "configure:16635: checking for _tanl declaration" >&5
16635   if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
16636   echo $ac_n "(cached) $ac_c" 1>&6
16637 else
16638
16639
16640     ac_ext=C
16641 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16642 ac_cpp='$CXXCPP $CPPFLAGS'
16643 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16644 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16645 cross_compiling=$ac_cv_prog_cxx_cross
16646
16647     cat > conftest.$ac_ext <<EOF
16648 #line 16649 "configure"
16649 #include "confdefs.h"
16650 #include <math.h>
16651 int main() {
16652  _tanl(0);
16653 ; return 0; }
16654 EOF
16655 if { (eval echo configure:16656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16656   rm -rf conftest*
16657   glibcpp_cv_func__tanl_use=yes
16658 else
16659   echo "configure: failed program was:" >&5
16660   cat conftest.$ac_ext >&5
16661   rm -rf conftest*
16662   glibcpp_cv_func__tanl_use=no
16663 fi
16664 rm -f conftest*
16665     ac_ext=c
16666 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16667 ac_cpp='$CPP $CPPFLAGS'
16668 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16669 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16670 cross_compiling=$ac_cv_prog_cc_cross
16671
16672
16673 fi
16674
16675   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
16676   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
16677     for ac_func in _tanl
16678 do
16679 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16680 echo "configure:16681: checking for $ac_func" >&5
16681 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16682   echo $ac_n "(cached) $ac_c" 1>&6
16683 else
16684   cat > conftest.$ac_ext <<EOF
16685 #line 16686 "configure"
16686 #include "confdefs.h"
16687 /* System header to define __stub macros and hopefully few prototypes,
16688     which can conflict with char $ac_func(); below.  */
16689 #include <assert.h>
16690 /* Override any gcc2 internal prototype to avoid an error.  */
16691 /* We use char because int might match the return type of a gcc2
16692     builtin and then its argument prototype would still apply.  */
16693 char $ac_func();
16694
16695 int main() {
16696
16697 /* The GNU C library defines this for functions which it implements
16698     to always fail with ENOSYS.  Some functions are actually named
16699     something starting with __ and the normal name is an alias.  */
16700 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16701 choke me
16702 #else
16703 $ac_func();
16704 #endif
16705
16706 ; return 0; }
16707 EOF
16708 if { (eval echo configure:16709: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16709   rm -rf conftest*
16710   eval "ac_cv_func_$ac_func=yes"
16711 else
16712   echo "configure: failed program was:" >&5
16713   cat conftest.$ac_ext >&5
16714   rm -rf conftest*
16715   eval "ac_cv_func_$ac_func=no"
16716 fi
16717 rm -f conftest*
16718 fi
16719
16720 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16721   echo "$ac_t""yes" 1>&6
16722     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16723   cat >> confdefs.h <<EOF
16724 #define $ac_tr_func 1
16725 EOF
16726
16727 else
16728   echo "$ac_t""no" 1>&6
16729 fi
16730 done
16731
16732   fi
16733
16734
16735   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16736 echo "configure:16737: checking for _tanhl declaration" >&5
16737   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
16738   echo $ac_n "(cached) $ac_c" 1>&6
16739 else
16740
16741
16742     ac_ext=C
16743 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16744 ac_cpp='$CXXCPP $CPPFLAGS'
16745 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16746 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16747 cross_compiling=$ac_cv_prog_cxx_cross
16748
16749     cat > conftest.$ac_ext <<EOF
16750 #line 16751 "configure"
16751 #include "confdefs.h"
16752 #include <math.h>
16753 int main() {
16754  _tanhl(0);
16755 ; return 0; }
16756 EOF
16757 if { (eval echo configure:16758: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16758   rm -rf conftest*
16759   glibcpp_cv_func__tanhl_use=yes
16760 else
16761   echo "configure: failed program was:" >&5
16762   cat conftest.$ac_ext >&5
16763   rm -rf conftest*
16764   glibcpp_cv_func__tanhl_use=no
16765 fi
16766 rm -f conftest*
16767     ac_ext=c
16768 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16769 ac_cpp='$CPP $CPPFLAGS'
16770 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16771 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16772 cross_compiling=$ac_cv_prog_cc_cross
16773
16774
16775 fi
16776
16777   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
16778   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
16779     for ac_func in _tanhl
16780 do
16781 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16782 echo "configure:16783: checking for $ac_func" >&5
16783 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16784   echo $ac_n "(cached) $ac_c" 1>&6
16785 else
16786   cat > conftest.$ac_ext <<EOF
16787 #line 16788 "configure"
16788 #include "confdefs.h"
16789 /* System header to define __stub macros and hopefully few prototypes,
16790     which can conflict with char $ac_func(); below.  */
16791 #include <assert.h>
16792 /* Override any gcc2 internal prototype to avoid an error.  */
16793 /* We use char because int might match the return type of a gcc2
16794     builtin and then its argument prototype would still apply.  */
16795 char $ac_func();
16796
16797 int main() {
16798
16799 /* The GNU C library defines this for functions which it implements
16800     to always fail with ENOSYS.  Some functions are actually named
16801     something starting with __ and the normal name is an alias.  */
16802 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16803 choke me
16804 #else
16805 $ac_func();
16806 #endif
16807
16808 ; return 0; }
16809 EOF
16810 if { (eval echo configure:16811: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16811   rm -rf conftest*
16812   eval "ac_cv_func_$ac_func=yes"
16813 else
16814   echo "configure: failed program was:" >&5
16815   cat conftest.$ac_ext >&5
16816   rm -rf conftest*
16817   eval "ac_cv_func_$ac_func=no"
16818 fi
16819 rm -f conftest*
16820 fi
16821
16822 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16823   echo "$ac_t""yes" 1>&6
16824     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16825   cat >> confdefs.h <<EOF
16826 #define $ac_tr_func 1
16827 EOF
16828
16829 else
16830   echo "$ac_t""no" 1>&6
16831 fi
16832 done
16833
16834   fi
16835
16836
16837   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16838 echo "configure:16839: checking for _sincosl declaration" >&5
16839   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
16840   echo $ac_n "(cached) $ac_c" 1>&6
16841 else
16842
16843
16844     ac_ext=C
16845 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16846 ac_cpp='$CXXCPP $CPPFLAGS'
16847 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16848 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16849 cross_compiling=$ac_cv_prog_cxx_cross
16850
16851     cat > conftest.$ac_ext <<EOF
16852 #line 16853 "configure"
16853 #include "confdefs.h"
16854 #include <math.h>
16855 int main() {
16856  _sincosl(0, 0, 0);
16857 ; return 0; }
16858 EOF
16859 if { (eval echo configure:16860: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16860   rm -rf conftest*
16861   glibcpp_cv_func__sincosl_use=yes
16862 else
16863   echo "configure: failed program was:" >&5
16864   cat conftest.$ac_ext >&5
16865   rm -rf conftest*
16866   glibcpp_cv_func__sincosl_use=no
16867 fi
16868 rm -f conftest*
16869     ac_ext=c
16870 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16871 ac_cpp='$CPP $CPPFLAGS'
16872 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16873 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16874 cross_compiling=$ac_cv_prog_cc_cross
16875
16876
16877 fi
16878
16879   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
16880   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
16881     for ac_func in _sincosl
16882 do
16883 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16884 echo "configure:16885: checking for $ac_func" >&5
16885 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16886   echo $ac_n "(cached) $ac_c" 1>&6
16887 else
16888   cat > conftest.$ac_ext <<EOF
16889 #line 16890 "configure"
16890 #include "confdefs.h"
16891 /* System header to define __stub macros and hopefully few prototypes,
16892     which can conflict with char $ac_func(); below.  */
16893 #include <assert.h>
16894 /* Override any gcc2 internal prototype to avoid an error.  */
16895 /* We use char because int might match the return type of a gcc2
16896     builtin and then its argument prototype would still apply.  */
16897 char $ac_func();
16898
16899 int main() {
16900
16901 /* The GNU C library defines this for functions which it implements
16902     to always fail with ENOSYS.  Some functions are actually named
16903     something starting with __ and the normal name is an alias.  */
16904 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16905 choke me
16906 #else
16907 $ac_func();
16908 #endif
16909
16910 ; return 0; }
16911 EOF
16912 if { (eval echo configure:16913: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16913   rm -rf conftest*
16914   eval "ac_cv_func_$ac_func=yes"
16915 else
16916   echo "configure: failed program was:" >&5
16917   cat conftest.$ac_ext >&5
16918   rm -rf conftest*
16919   eval "ac_cv_func_$ac_func=no"
16920 fi
16921 rm -f conftest*
16922 fi
16923
16924 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16925   echo "$ac_t""yes" 1>&6
16926     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16927   cat >> confdefs.h <<EOF
16928 #define $ac_tr_func 1
16929 EOF
16930
16931 else
16932   echo "$ac_t""no" 1>&6
16933 fi
16934 done
16935
16936   fi
16937
16938
16939   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16940 echo "configure:16941: checking for _finitel declaration" >&5
16941   if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
16942   echo $ac_n "(cached) $ac_c" 1>&6
16943 else
16944
16945
16946     ac_ext=C
16947 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16948 ac_cpp='$CXXCPP $CPPFLAGS'
16949 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16950 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16951 cross_compiling=$ac_cv_prog_cxx_cross
16952
16953     cat > conftest.$ac_ext <<EOF
16954 #line 16955 "configure"
16955 #include "confdefs.h"
16956 #include <math.h>
16957 int main() {
16958  _finitel(0);
16959 ; return 0; }
16960 EOF
16961 if { (eval echo configure:16962: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16962   rm -rf conftest*
16963   glibcpp_cv_func__finitel_use=yes
16964 else
16965   echo "configure: failed program was:" >&5
16966   cat conftest.$ac_ext >&5
16967   rm -rf conftest*
16968   glibcpp_cv_func__finitel_use=no
16969 fi
16970 rm -f conftest*
16971     ac_ext=c
16972 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16973 ac_cpp='$CPP $CPPFLAGS'
16974 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16975 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16976 cross_compiling=$ac_cv_prog_cc_cross
16977
16978
16979 fi
16980
16981   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
16982   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
16983     for ac_func in _finitel
16984 do
16985 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16986 echo "configure:16987: checking for $ac_func" >&5
16987 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16988   echo $ac_n "(cached) $ac_c" 1>&6
16989 else
16990   cat > conftest.$ac_ext <<EOF
16991 #line 16992 "configure"
16992 #include "confdefs.h"
16993 /* System header to define __stub macros and hopefully few prototypes,
16994     which can conflict with char $ac_func(); below.  */
16995 #include <assert.h>
16996 /* Override any gcc2 internal prototype to avoid an error.  */
16997 /* We use char because int might match the return type of a gcc2
16998     builtin and then its argument prototype would still apply.  */
16999 char $ac_func();
17000
17001 int main() {
17002
17003 /* The GNU C library defines this for functions which it implements
17004     to always fail with ENOSYS.  Some functions are actually named
17005     something starting with __ and the normal name is an alias.  */
17006 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17007 choke me
17008 #else
17009 $ac_func();
17010 #endif
17011
17012 ; return 0; }
17013 EOF
17014 if { (eval echo configure:17015: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17015   rm -rf conftest*
17016   eval "ac_cv_func_$ac_func=yes"
17017 else
17018   echo "configure: failed program was:" >&5
17019   cat conftest.$ac_ext >&5
17020   rm -rf conftest*
17021   eval "ac_cv_func_$ac_func=no"
17022 fi
17023 rm -f conftest*
17024 fi
17025
17026 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17027   echo "$ac_t""yes" 1>&6
17028     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17029   cat >> confdefs.h <<EOF
17030 #define $ac_tr_func 1
17031 EOF
17032
17033 else
17034   echo "$ac_t""no" 1>&6
17035 fi
17036 done
17037
17038   fi
17039
17040
17041   LIBS="$ac_save_LIBS"
17042   CXXFLAGS="$ac_save_CXXFLAGS"
17043
17044
17045     for ac_hdr in complex.h
17046 do
17047 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
17048 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
17049 echo "configure:17050: checking for $ac_hdr" >&5
17050 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17051   echo $ac_n "(cached) $ac_c" 1>&6
17052 else
17053   cat > conftest.$ac_ext <<EOF
17054 #line 17055 "configure"
17055 #include "confdefs.h"
17056 #include <$ac_hdr>
17057 EOF
17058 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17059 { (eval echo configure:17060: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17060 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17061 if test -z "$ac_err"; then
17062   rm -rf conftest*
17063   eval "ac_cv_header_$ac_safe=yes"
17064 else
17065   echo "$ac_err" >&5
17066   echo "configure: failed program was:" >&5
17067   cat conftest.$ac_ext >&5
17068   rm -rf conftest*
17069   eval "ac_cv_header_$ac_safe=no"
17070 fi
17071 rm -f conftest*
17072 fi
17073 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17074   echo "$ac_t""yes" 1>&6
17075     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17076   cat >> confdefs.h <<EOF
17077 #define $ac_tr_hdr 1
17078 EOF
17079
17080 else
17081   echo "$ac_t""no" 1>&6
17082 fi
17083 done
17084
17085   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17086 echo "configure:17087: checking for main in -lm" >&5
17087 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17088 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17089   echo $ac_n "(cached) $ac_c" 1>&6
17090 else
17091   ac_save_LIBS="$LIBS"
17092 LIBS="-lm  $LIBS"
17093 cat > conftest.$ac_ext <<EOF
17094 #line 17095 "configure"
17095 #include "confdefs.h"
17096
17097 int main() {
17098 main()
17099 ; return 0; }
17100 EOF
17101 if { (eval echo configure:17102: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17102   rm -rf conftest*
17103   eval "ac_cv_lib_$ac_lib_var=yes"
17104 else
17105   echo "configure: failed program was:" >&5
17106   cat conftest.$ac_ext >&5
17107   rm -rf conftest*
17108   eval "ac_cv_lib_$ac_lib_var=no"
17109 fi
17110 rm -f conftest*
17111 LIBS="$ac_save_LIBS"
17112
17113 fi
17114 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17115   echo "$ac_t""yes" 1>&6
17116     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
17117     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
17118   cat >> confdefs.h <<EOF
17119 #define $ac_tr_lib 1
17120 EOF
17121
17122   LIBS="-lm $LIBS"
17123
17124 else
17125   echo "$ac_t""no" 1>&6
17126 fi
17127
17128   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf \
17129   csin csinf csinh csinhf csqrt \
17130   csqrtf ctan ctanf ctanh ctanhf nan hypot hypotf atan2f expf \
17131   copysignf
17132 do
17133 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17134 echo "configure:17135: checking for $ac_func" >&5
17135 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17136   echo $ac_n "(cached) $ac_c" 1>&6
17137 else
17138   cat > conftest.$ac_ext <<EOF
17139 #line 17140 "configure"
17140 #include "confdefs.h"
17141 /* System header to define __stub macros and hopefully few prototypes,
17142     which can conflict with char $ac_func(); below.  */
17143 #include <assert.h>
17144 /* Override any gcc2 internal prototype to avoid an error.  */
17145 /* We use char because int might match the return type of a gcc2
17146     builtin and then its argument prototype would still apply.  */
17147 char $ac_func();
17148
17149 int main() {
17150
17151 /* The GNU C library defines this for functions which it implements
17152     to always fail with ENOSYS.  Some functions are actually named
17153     something starting with __ and the normal name is an alias.  */
17154 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17155 choke me
17156 #else
17157 $ac_func();
17158 #endif
17159
17160 ; return 0; }
17161 EOF
17162 if { (eval echo configure:17163: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17163   rm -rf conftest*
17164   eval "ac_cv_func_$ac_func=yes"
17165 else
17166   echo "configure: failed program was:" >&5
17167   cat conftest.$ac_ext >&5
17168   rm -rf conftest*
17169   eval "ac_cv_func_$ac_func=no"
17170 fi
17171 rm -f conftest*
17172 fi
17173
17174 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17175   echo "$ac_t""yes" 1>&6
17176     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17177   cat >> confdefs.h <<EOF
17178 #define $ac_tr_func 1
17179 EOF
17180
17181 else
17182   echo "$ac_t""no" 1>&6
17183 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17184 fi
17185 done
17186
17187
17188
17189           USE_COMPLEX_LONG_DOUBLE=no
17190   if test x$ac_cv_func_atan2l = x"yes" \
17191      && test x$ac_cv_func_copysignl = x"yes"; then
17192     USE_COMPLEX_LONG_DOUBLE=yes
17193     for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
17194     csqrtl ctanhl ctanl hypotl signbitl clog10l
17195 do
17196 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17197 echo "configure:17198: checking for $ac_func" >&5
17198 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17199   echo $ac_n "(cached) $ac_c" 1>&6
17200 else
17201   cat > conftest.$ac_ext <<EOF
17202 #line 17203 "configure"
17203 #include "confdefs.h"
17204 /* System header to define __stub macros and hopefully few prototypes,
17205     which can conflict with char $ac_func(); below.  */
17206 #include <assert.h>
17207 /* Override any gcc2 internal prototype to avoid an error.  */
17208 /* We use char because int might match the return type of a gcc2
17209     builtin and then its argument prototype would still apply.  */
17210 char $ac_func();
17211
17212 int main() {
17213
17214 /* The GNU C library defines this for functions which it implements
17215     to always fail with ENOSYS.  Some functions are actually named
17216     something starting with __ and the normal name is an alias.  */
17217 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17218 choke me
17219 #else
17220 $ac_func();
17221 #endif
17222
17223 ; return 0; }
17224 EOF
17225 if { (eval echo configure:17226: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17226   rm -rf conftest*
17227   eval "ac_cv_func_$ac_func=yes"
17228 else
17229   echo "configure: failed program was:" >&5
17230   cat conftest.$ac_ext >&5
17231   rm -rf conftest*
17232   eval "ac_cv_func_$ac_func=no"
17233 fi
17234 rm -f conftest*
17235 fi
17236
17237 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17238   echo "$ac_t""yes" 1>&6
17239     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17240   cat >> confdefs.h <<EOF
17241 #define $ac_tr_func 1
17242 EOF
17243
17244 else
17245   echo "$ac_t""no" 1>&6
17246 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17247 fi
17248 done
17249
17250
17251   fi
17252
17253
17254
17255
17256
17257
17258   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
17259 echo "configure:17260: checking for GNU C++ __complex__ support" >&5
17260   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
17261   echo $ac_n "(cached) $ac_c" 1>&6
17262 else
17263
17264
17265     ac_ext=C
17266 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17267 ac_cpp='$CXXCPP $CPPFLAGS'
17268 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17269 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17270 cross_compiling=$ac_cv_prog_cxx_cross
17271
17272     cat > conftest.$ac_ext <<EOF
17273 #line 17274 "configure"
17274 #include "confdefs.h"
17275 struct dcomplex { __complex__ double x; }; \
17276                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
17277 int main() {
17278 \
17279                      dcomplex x; f(x);
17280 ; return 0; }
17281 EOF
17282 if { (eval echo configure:17283: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17283   rm -rf conftest*
17284   glibcpp_cv_complex=ok
17285 else
17286   echo "configure: failed program was:" >&5
17287   cat conftest.$ac_ext >&5
17288   rm -rf conftest*
17289   glibcpp_cv_complex=buggy
17290
17291 fi
17292 rm -f conftest*
17293     ac_ext=c
17294 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17295 ac_cpp='$CPP $CPPFLAGS'
17296 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17297 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17298 cross_compiling=$ac_cv_prog_cc_cross
17299
17300
17301 fi
17302
17303   echo "$ac_t""$glibcpp_cv_complex" 1>&6
17304   if test $glibcpp_cv_complex = buggy; then
17305     cat >> confdefs.h <<\EOF
17306 #define _GLIBCPP_BUGGY_COMPLEX 1
17307 EOF
17308
17309   fi
17310
17311   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
17312 echo "configure:17313: checking for GNU C++ __complex__ float support" >&5
17313   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
17314   echo $ac_n "(cached) $ac_c" 1>&6
17315 else
17316
17317
17318     ac_ext=C
17319 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17320 ac_cpp='$CXXCPP $CPPFLAGS'
17321 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17322 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17323 cross_compiling=$ac_cv_prog_cxx_cross
17324
17325     rm -f conftest.h
17326     cat > conftest.h <<EOB
17327       //
17328       // Check for buggy __complex__ that causes ICE in most versions of egcs
17329       // and gcc-2.95.x on certain platforms (eg., x86-win32).
17330       //
17331       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
17332       // more info on the bug itself.
17333       //
17334       struct
17335       float_complex
17336       {
17337        __complex__ float m_value;
17338        float_complex (float = 0.0f, float = 0.0f);
17339        float_complex (__complex__ float val) : m_value (val) {}
17340        float_complex foo (const float_complex &val)
17341          { return float_complex (~val.m_value); }
17342       };
17343 EOB
17344     cat > conftest.$ac_ext <<EOF
17345 #line 17346 "configure"
17346 #include "confdefs.h"
17347 #include "conftest.h"
17348 int main() {
17349
17350 ; return 0; }
17351 EOF
17352 if { (eval echo configure:17353: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17353   rm -rf conftest*
17354   glibcpp_cv_float_complex=ok
17355 else
17356   echo "configure: failed program was:" >&5
17357   cat conftest.$ac_ext >&5
17358   rm -rf conftest*
17359   glibcpp_cv_float_complex=buggy
17360
17361 fi
17362 rm -f conftest*
17363     ac_ext=c
17364 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17365 ac_cpp='$CPP $CPPFLAGS'
17366 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17367 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17368 cross_compiling=$ac_cv_prog_cc_cross
17369
17370
17371 fi
17372
17373   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
17374   if test $glibcpp_cv_float_complex = buggy; then
17375     cat >> confdefs.h <<\EOF
17376 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
17377 EOF
17378
17379   fi
17380
17381
17382   if test x$enable_c_mbchar != xno; then
17383
17384         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
17385 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
17386 echo "configure:17387: checking for wchar.h" >&5
17387 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17388   echo $ac_n "(cached) $ac_c" 1>&6
17389 else
17390   cat > conftest.$ac_ext <<EOF
17391 #line 17392 "configure"
17392 #include "confdefs.h"
17393 #include <wchar.h>
17394 EOF
17395 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17396 { (eval echo configure:17397: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17397 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17398 if test -z "$ac_err"; then
17399   rm -rf conftest*
17400   eval "ac_cv_header_$ac_safe=yes"
17401 else
17402   echo "$ac_err" >&5
17403   echo "configure: failed program was:" >&5
17404   cat conftest.$ac_ext >&5
17405   rm -rf conftest*
17406   eval "ac_cv_header_$ac_safe=no"
17407 fi
17408 rm -f conftest*
17409 fi
17410 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17411   echo "$ac_t""yes" 1>&6
17412   ac_has_wchar_h=yes
17413 else
17414   echo "$ac_t""no" 1>&6
17415 ac_has_wchar_h=no
17416 fi
17417
17418     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
17419 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
17420 echo "configure:17421: checking for wctype.h" >&5
17421 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17422   echo $ac_n "(cached) $ac_c" 1>&6
17423 else
17424   cat > conftest.$ac_ext <<EOF
17425 #line 17426 "configure"
17426 #include "confdefs.h"
17427 #include <wctype.h>
17428 EOF
17429 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17430 { (eval echo configure:17431: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17431 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17432 if test -z "$ac_err"; then
17433   rm -rf conftest*
17434   eval "ac_cv_header_$ac_safe=yes"
17435 else
17436   echo "$ac_err" >&5
17437   echo "configure: failed program was:" >&5
17438   cat conftest.$ac_ext >&5
17439   rm -rf conftest*
17440   eval "ac_cv_header_$ac_safe=no"
17441 fi
17442 rm -f conftest*
17443 fi
17444 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17445   echo "$ac_t""yes" 1>&6
17446   ac_has_wctype_h=yes
17447 else
17448   echo "$ac_t""no" 1>&6
17449 ac_has_wctype_h=no
17450 fi
17451
17452
17453         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
17454
17455                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
17456 echo "configure:17457: checking for mbstate_t" >&5
17457       cat > conftest.$ac_ext <<EOF
17458 #line 17459 "configure"
17459 #include "confdefs.h"
17460 #include <wchar.h>
17461 int main() {
17462 mbstate_t teststate;
17463 ; return 0; }
17464 EOF
17465 if { (eval echo configure:17466: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17466   rm -rf conftest*
17467   use_native_mbstatet=yes
17468 else
17469   echo "configure: failed program was:" >&5
17470   cat conftest.$ac_ext >&5
17471   rm -rf conftest*
17472   use_native_mbstatet=no
17473 fi
17474 rm -f conftest*
17475       echo "$ac_t""$use_native_mbstatet" 1>&6
17476       if test x"$use_native_mbstatet" = xno; then
17477         cat >> confdefs.h <<\EOF
17478 #define _GLIBCPP_NEED_MBSTATE_T 1
17479 EOF
17480
17481       fi
17482
17483                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
17484 echo "configure:17485: checking for WCHAR_MIN and WCHAR_MAX" >&5
17485       cat > conftest.$ac_ext <<EOF
17486 #line 17487 "configure"
17487 #include "confdefs.h"
17488 #include <wchar.h>
17489 int main() {
17490 int i = WCHAR_MIN; int j = WCHAR_MAX;
17491 ; return 0; }
17492 EOF
17493 if { (eval echo configure:17494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17494   rm -rf conftest*
17495   has_wchar_minmax=yes
17496 else
17497   echo "configure: failed program was:" >&5
17498   cat conftest.$ac_ext >&5
17499   rm -rf conftest*
17500   has_wchar_minmax=no
17501 fi
17502 rm -f conftest*
17503       echo "$ac_t""$has_wchar_minmax" 1>&6
17504
17505                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
17506 echo "configure:17507: checking for WEOF" >&5
17507       cat > conftest.$ac_ext <<EOF
17508 #line 17509 "configure"
17509 #include "confdefs.h"
17510
17511         #include <wchar.h>
17512         #include <stddef.h>
17513 int main() {
17514 wint_t i = WEOF;
17515 ; return 0; }
17516 EOF
17517 if { (eval echo configure:17518: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17518   rm -rf conftest*
17519   has_weof=yes
17520 else
17521   echo "configure: failed program was:" >&5
17522   cat conftest.$ac_ext >&5
17523   rm -rf conftest*
17524   has_weof=no
17525 fi
17526 rm -f conftest*
17527       echo "$ac_t""$has_weof" 1>&6
17528
17529             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
17530       wcsrtombs mbsrtowcs
17531 do
17532 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17533 echo "configure:17534: checking for $ac_func" >&5
17534 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17535   echo $ac_n "(cached) $ac_c" 1>&6
17536 else
17537   cat > conftest.$ac_ext <<EOF
17538 #line 17539 "configure"
17539 #include "confdefs.h"
17540 /* System header to define __stub macros and hopefully few prototypes,
17541     which can conflict with char $ac_func(); below.  */
17542 #include <assert.h>
17543 /* Override any gcc2 internal prototype to avoid an error.  */
17544 /* We use char because int might match the return type of a gcc2
17545     builtin and then its argument prototype would still apply.  */
17546 char $ac_func();
17547
17548 int main() {
17549
17550 /* The GNU C library defines this for functions which it implements
17551     to always fail with ENOSYS.  Some functions are actually named
17552     something starting with __ and the normal name is an alias.  */
17553 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17554 choke me
17555 #else
17556 $ac_func();
17557 #endif
17558
17559 ; return 0; }
17560 EOF
17561 if { (eval echo configure:17562: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17562   rm -rf conftest*
17563   eval "ac_cv_func_$ac_func=yes"
17564 else
17565   echo "configure: failed program was:" >&5
17566   cat conftest.$ac_ext >&5
17567   rm -rf conftest*
17568   eval "ac_cv_func_$ac_func=no"
17569 fi
17570 rm -f conftest*
17571 fi
17572
17573 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17574   echo "$ac_t""yes" 1>&6
17575     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17576   cat >> confdefs.h <<EOF
17577 #define $ac_tr_func 1
17578 EOF
17579  ac_wfuncs=yes
17580 else
17581   echo "$ac_t""no" 1>&6
17582 ac_wfuncs=no
17583 fi
17584 done
17585
17586
17587       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
17588 echo "configure:17589: checking for ISO C99 wchar_t support" >&5
17589       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
17590          && test x"$ac_wfuncs" = xyes; then
17591         ac_isoC99_wchar_t=yes
17592       else
17593         ac_isoC99_wchar_t=no
17594       fi
17595       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
17596
17597                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
17598 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
17599 echo "configure:17600: checking for iconv.h" >&5
17600 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17601   echo $ac_n "(cached) $ac_c" 1>&6
17602 else
17603   cat > conftest.$ac_ext <<EOF
17604 #line 17605 "configure"
17605 #include "confdefs.h"
17606 #include <iconv.h>
17607 EOF
17608 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17609 { (eval echo configure:17610: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17610 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17611 if test -z "$ac_err"; then
17612   rm -rf conftest*
17613   eval "ac_cv_header_$ac_safe=yes"
17614 else
17615   echo "$ac_err" >&5
17616   echo "configure: failed program was:" >&5
17617   cat conftest.$ac_ext >&5
17618   rm -rf conftest*
17619   eval "ac_cv_header_$ac_safe=no"
17620 fi
17621 rm -f conftest*
17622 fi
17623 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17624   echo "$ac_t""yes" 1>&6
17625   ac_has_iconv_h=yes
17626 else
17627   echo "$ac_t""no" 1>&6
17628 ac_has_iconv_h=no
17629 fi
17630
17631       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
17632 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
17633 echo "configure:17634: checking for langinfo.h" >&5
17634 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17635   echo $ac_n "(cached) $ac_c" 1>&6
17636 else
17637   cat > conftest.$ac_ext <<EOF
17638 #line 17639 "configure"
17639 #include "confdefs.h"
17640 #include <langinfo.h>
17641 EOF
17642 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17643 { (eval echo configure:17644: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17644 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17645 if test -z "$ac_err"; then
17646   rm -rf conftest*
17647   eval "ac_cv_header_$ac_safe=yes"
17648 else
17649   echo "$ac_err" >&5
17650   echo "configure: failed program was:" >&5
17651   cat conftest.$ac_ext >&5
17652   rm -rf conftest*
17653   eval "ac_cv_header_$ac_safe=no"
17654 fi
17655 rm -f conftest*
17656 fi
17657 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17658   echo "$ac_t""yes" 1>&6
17659   ac_has_langinfo_h=yes
17660 else
17661   echo "$ac_t""no" 1>&6
17662 ac_has_langinfo_h=no
17663 fi
17664
17665
17666             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
17667 echo "configure:17668: checking for iconv in -liconv" >&5
17668 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
17669 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17670   echo $ac_n "(cached) $ac_c" 1>&6
17671 else
17672   ac_save_LIBS="$LIBS"
17673 LIBS="-liconv  $LIBS"
17674 cat > conftest.$ac_ext <<EOF
17675 #line 17676 "configure"
17676 #include "confdefs.h"
17677 /* Override any gcc2 internal prototype to avoid an error.  */
17678 /* We use char because int might match the return type of a gcc2
17679     builtin and then its argument prototype would still apply.  */
17680 char iconv();
17681
17682 int main() {
17683 iconv()
17684 ; return 0; }
17685 EOF
17686 if { (eval echo configure:17687: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17687   rm -rf conftest*
17688   eval "ac_cv_lib_$ac_lib_var=yes"
17689 else
17690   echo "configure: failed program was:" >&5
17691   cat conftest.$ac_ext >&5
17692   rm -rf conftest*
17693   eval "ac_cv_lib_$ac_lib_var=no"
17694 fi
17695 rm -f conftest*
17696 LIBS="$ac_save_LIBS"
17697
17698 fi
17699 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17700   echo "$ac_t""yes" 1>&6
17701   libiconv="-liconv"
17702 else
17703   echo "$ac_t""no" 1>&6
17704 fi
17705
17706       ac_save_LIBS="$LIBS"
17707       LIBS="$LIBS $libiconv"
17708
17709       for ac_func in iconv_open iconv_close iconv nl_langinfo
17710 do
17711 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17712 echo "configure:17713: checking for $ac_func" >&5
17713 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17714   echo $ac_n "(cached) $ac_c" 1>&6
17715 else
17716   cat > conftest.$ac_ext <<EOF
17717 #line 17718 "configure"
17718 #include "confdefs.h"
17719 /* System header to define __stub macros and hopefully few prototypes,
17720     which can conflict with char $ac_func(); below.  */
17721 #include <assert.h>
17722 /* Override any gcc2 internal prototype to avoid an error.  */
17723 /* We use char because int might match the return type of a gcc2
17724     builtin and then its argument prototype would still apply.  */
17725 char $ac_func();
17726
17727 int main() {
17728
17729 /* The GNU C library defines this for functions which it implements
17730     to always fail with ENOSYS.  Some functions are actually named
17731     something starting with __ and the normal name is an alias.  */
17732 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17733 choke me
17734 #else
17735 $ac_func();
17736 #endif
17737
17738 ; return 0; }
17739 EOF
17740 if { (eval echo configure:17741: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17741   rm -rf conftest*
17742   eval "ac_cv_func_$ac_func=yes"
17743 else
17744   echo "configure: failed program was:" >&5
17745   cat conftest.$ac_ext >&5
17746   rm -rf conftest*
17747   eval "ac_cv_func_$ac_func=no"
17748 fi
17749 rm -f conftest*
17750 fi
17751
17752 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17753   echo "$ac_t""yes" 1>&6
17754     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17755   cat >> confdefs.h <<EOF
17756 #define $ac_tr_func 1
17757 EOF
17758  \
17759       ac_XPG2funcs=yes
17760 else
17761   echo "$ac_t""no" 1>&6
17762 ac_XPG2funcs=no
17763 fi
17764 done
17765
17766
17767       LIBS="$ac_save_LIBS"
17768
17769       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
17770 echo "configure:17771: checking for XPG2 wchar_t support" >&5
17771       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
17772          && test x"$ac_XPG2funcs" = xyes; then
17773         ac_XPG2_wchar_t=yes
17774       else
17775         ac_XPG2_wchar_t=no
17776       fi
17777       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
17778
17779                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
17780 echo "configure:17781: checking for enabled wchar_t specializations" >&5
17781       if test x"$ac_isoC99_wchar_t" = xyes \
17782          && test x"$ac_XPG2_wchar_t" = xyes; then
17783         libinst_wstring_la="libinst-wstring.la"
17784         cat >> confdefs.h <<\EOF
17785 #define _GLIBCPP_USE_WCHAR_T 1
17786 EOF
17787
17788         echo "$ac_t"""yes"" 1>&6
17789       else
17790         libinst_wstring_la=""
17791         echo "$ac_t"""no"" 1>&6
17792       fi
17793
17794
17795     else
17796       echo "configure: warning: <wchar.h> not found" 1>&2
17797       cat >> confdefs.h <<\EOF
17798 #define _GLIBCPP_NEED_MBSTATE_T 1
17799 EOF
17800
17801     fi
17802
17803   else
17804         :
17805   fi
17806
17807
17808   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
17809 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
17810 echo "configure:17811: checking for ctype.h" >&5
17811 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17812   echo $ac_n "(cached) $ac_c" 1>&6
17813 else
17814   cat > conftest.$ac_ext <<EOF
17815 #line 17816 "configure"
17816 #include "confdefs.h"
17817 #include <ctype.h>
17818 EOF
17819 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17820 { (eval echo configure:17821: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17821 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17822 if test -z "$ac_err"; then
17823   rm -rf conftest*
17824   eval "ac_cv_header_$ac_safe=yes"
17825 else
17826   echo "$ac_err" >&5
17827   echo "configure: failed program was:" >&5
17828   cat conftest.$ac_ext >&5
17829   rm -rf conftest*
17830   eval "ac_cv_header_$ac_safe=no"
17831 fi
17832 rm -f conftest*
17833 fi
17834 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17835   echo "$ac_t""yes" 1>&6
17836
17837
17838         ctype_default=yes
17839
17840         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
17841 echo "configure:17842: checking <ctype> for GNU/Linux" >&5
17842     cat > conftest.$ac_ext <<EOF
17843 #line 17844 "configure"
17844 #include "confdefs.h"
17845 #include <ctype.h>
17846 int main() {
17847 int
17848     foo (int a)
17849     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
17850         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
17851         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17852 ; return 0; }
17853 EOF
17854 if { (eval echo configure:17855: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17855   rm -rf conftest*
17856   \
17857     ctype_linux=yes
17858 else
17859   echo "configure: failed program was:" >&5
17860   cat conftest.$ac_ext >&5
17861   rm -rf conftest*
17862   ctype_linux=no
17863 fi
17864 rm -f conftest*
17865     echo "$ac_t""$ctype_linux" 1>&6
17866     if test $ctype_linux = "yes"; then
17867       ctype_include_dir="config/os/gnu-linux"
17868       ctype_default=no
17869     fi
17870
17871         if test $ctype_default = "yes"; then
17872     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
17873 echo "configure:17874: checking <ctype> for FreeBSD 4.0" >&5
17874     cat > conftest.$ac_ext <<EOF
17875 #line 17876 "configure"
17876 #include "confdefs.h"
17877 #include <ctype.h>
17878 int main() {
17879 int
17880     foo (int a)
17881     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17882         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17883 ; return 0; }
17884 EOF
17885 if { (eval echo configure:17886: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17886   rm -rf conftest*
17887   \
17888     ctype_bsd=yes
17889 else
17890   echo "configure: failed program was:" >&5
17891   cat conftest.$ac_ext >&5
17892   rm -rf conftest*
17893   ctype_bsd=no
17894 fi
17895 rm -f conftest*
17896     echo "$ac_t""$ctype_bsd" 1>&6
17897     if test $ctype_bsd = "yes"; then
17898       ctype_include_dir="config/os/bsd"
17899       ctype_default=no
17900     fi
17901     fi
17902
17903         if test $ctype_default = "yes"; then
17904     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
17905 echo "configure:17906: checking <ctype> for FreeBSD 3.4" >&5
17906     cat > conftest.$ac_ext <<EOF
17907 #line 17908 "configure"
17908 #include "confdefs.h"
17909 #include <ctype.h>
17910 int main() {
17911 int
17912     foo (int a)
17913     { return _S + _R + _C + _U + _L + _A \
17914       + _D + _P + _X + _G + __istype (a, 0);}
17915 ; return 0; }
17916 EOF
17917 if { (eval echo configure:17918: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17918   rm -rf conftest*
17919   \
17920     ctype_freebsd34=yes
17921 else
17922   echo "configure: failed program was:" >&5
17923   cat conftest.$ac_ext >&5
17924   rm -rf conftest*
17925   ctype_freebsd34=no
17926 fi
17927 rm -f conftest*
17928     echo "$ac_t""$ctype_freebsd34" 1>&6
17929     if test $ctype_freebsd34 = "yes"; then
17930       ctype_include_dir="config/os/bsd"
17931       ctype_default=no
17932     fi
17933     fi
17934
17935         if test $ctype_default = "yes"; then
17936     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
17937 echo "configure:17938: checking <ctype> for Solaris 2.6,7,8" >&5
17938     cat > conftest.$ac_ext <<EOF
17939 #line 17940 "configure"
17940 #include "confdefs.h"
17941 #include <ctype.h>
17942 int main() {
17943 int
17944     foo (int a)
17945     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17946         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17947         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17948 ; return 0; }
17949 EOF
17950 if { (eval echo configure:17951: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17951   rm -rf conftest*
17952   \
17953     ctype_solaris=yes
17954 else
17955   echo "configure: failed program was:" >&5
17956   cat conftest.$ac_ext >&5
17957   rm -rf conftest*
17958   ctype_solaris=no
17959 fi
17960 rm -f conftest*
17961     echo "$ac_t""$ctype_solaris" 1>&6
17962
17963     if test $ctype_solaris = "yes"; then
17964       echo $ac_n "checking   for version""... $ac_c" 1>&6
17965 echo "configure:17966: checking   for version" >&5
17966       ac_ext=C
17967 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17968 ac_cpp='$CXXCPP $CPPFLAGS'
17969 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17970 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17971 cross_compiling=$ac_cv_prog_cxx_cross
17972
17973       cat > conftest.$ac_ext <<EOF
17974 #line 17975 "configure"
17975 #include "confdefs.h"
17976 #include <ctype.h>
17977 int main() {
17978 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17979 ; return 0; }
17980 EOF
17981 if { (eval echo configure:17982: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17982   rm -rf conftest*
17983   \
17984       ctype_solaris26=yes
17985 else
17986   echo "configure: failed program was:" >&5
17987   cat conftest.$ac_ext >&5
17988   rm -rf conftest*
17989   ctype_solaris26=no
17990 fi
17991 rm -f conftest*
17992       ac_ext=c
17993 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17994 ac_cpp='$CPP $CPPFLAGS'
17995 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17996 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17997 cross_compiling=$ac_cv_prog_cc_cross
17998
17999       if test $ctype_solaris26 = "yes"; then
18000         ctype_include_dir="config/os/solaris/solaris2.6"
18001         echo "$ac_t""Solaris 2.6" 1>&6
18002         ctype_default=no
18003       else
18004         ctype_include_dir="config/os/solaris/solaris2.7"
18005         echo "$ac_t""Solaris 7,8" 1>&6
18006         ctype_default=no
18007       fi
18008     fi
18009     fi
18010
18011         if test $ctype_default = "yes"; then
18012     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
18013 echo "configure:18014: checking <ctype> for Solaris 2.5.1" >&5
18014     cat > conftest.$ac_ext <<EOF
18015 #line 18016 "configure"
18016 #include "confdefs.h"
18017 #include <ctype.h>
18018 int main() {
18019 int
18020     foo (int a)
18021     { return _U + _L + _N + _S + _P + _C + _X + _B \
18022         + __ctype[a];}
18023 ; return 0; }
18024 EOF
18025 if { (eval echo configure:18026: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18026   rm -rf conftest*
18027   \
18028     ctype_solaris25=yes
18029 else
18030   echo "configure: failed program was:" >&5
18031   cat conftest.$ac_ext >&5
18032   rm -rf conftest*
18033   ctype_solaris25=no
18034 fi
18035 rm -f conftest*
18036     echo "$ac_t""$ctype_solaris25" 1>&6
18037     if test $ctype_solaris25 = "yes"; then
18038       ctype_include_dir="config/os/solaris/solaris2.5"
18039       ctype_default=no
18040     fi
18041     fi
18042
18043         if test $ctype_default = "yes"; then
18044     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
18045 echo "configure:18046: checking <ctype> for AIX" >&5
18046     cat > conftest.$ac_ext <<EOF
18047 #line 18048 "configure"
18048 #include "confdefs.h"
18049 #include <ctype.h>
18050 int main() {
18051 int
18052     foo (int a)
18053     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18054         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18055         + _VALC('a') + _IS('c', 0);}
18056 ; return 0; }
18057 EOF
18058 if { (eval echo configure:18059: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18059   rm -rf conftest*
18060   \
18061     ctype_aix=yes
18062 else
18063   echo "configure: failed program was:" >&5
18064   cat conftest.$ac_ext >&5
18065   rm -rf conftest*
18066   ctype_aix=no
18067 fi
18068 rm -f conftest*
18069     echo "$ac_t""$ctype_aix" 1>&6
18070     if test $ctype_aix = "yes"; then
18071       ctype_include_dir="config/os/aix"
18072       ctype_default=no
18073     fi
18074     fi
18075
18076         if test $ctype_default = "yes"; then
18077     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18078 echo "configure:18079: checking <ctype> for IRIX" >&5
18079     cat > conftest.$ac_ext <<EOF
18080 #line 18081 "configure"
18081 #include "confdefs.h"
18082 #include <ctype.h>
18083 int main() {
18084 int
18085     foo (int a)
18086     { return _U + _L + _N + _S + _P + _C + _B + _X + \
18087              _A + _PR + _G + _BL;}
18088 ; return 0; }
18089 EOF
18090 if { (eval echo configure:18091: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18091   rm -rf conftest*
18092   \
18093     ctype_irix=yes
18094 else
18095   echo "configure: failed program was:" >&5
18096   cat conftest.$ac_ext >&5
18097   rm -rf conftest*
18098   ctype_irix=no
18099 fi
18100 rm -f conftest*
18101     echo "$ac_t""$ctype_irix" 1>&6
18102     if test $ctype_irix = "yes"; then
18103       ctype_include_dir="config/os/irix"
18104       ctype_default=no
18105     fi
18106     fi
18107
18108         if test $ctype_default = "yes"; then
18109     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
18110 echo "configure:18111: checking <ctype> for newlib" >&5
18111     cat > conftest.$ac_ext <<EOF
18112 #line 18113 "configure"
18113 #include "confdefs.h"
18114 #include <ctype.h>
18115 int main() {
18116 int
18117     foo (int a)
18118     { return _U + _L + _N + _S + _P + _C + _X + _B \
18119         + _ctype_[a];}
18120 ; return 0; }
18121 EOF
18122 if { (eval echo configure:18123: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18123   rm -rf conftest*
18124   \
18125     ctype_newlib=yes
18126 else
18127   echo "configure: failed program was:" >&5
18128   cat conftest.$ac_ext >&5
18129   rm -rf conftest*
18130   ctype_newlib=no
18131 fi
18132 rm -f conftest*
18133     echo "$ac_t""$ctype_newlib" 1>&6
18134     if test $ctype_newlib = "yes"; then
18135       ctype_include_dir="config/os/newlib"
18136       ctype_default=no
18137     fi
18138     fi
18139
18140     if test $ctype_default = "yes"; then
18141       ctype_include_dir="config/os/generic"
18142       echo "configure: warning: "Using default ctype headers."" 1>&2
18143     fi
18144
18145
18146
18147
18148
18149 else
18150   echo "$ac_t""no" 1>&6
18151 fi
18152
18153
18154
18155   ac_test_CXXFLAGS="${CXXFLAGS+set}"
18156   ac_save_CXXFLAGS="$CXXFLAGS"
18157   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
18158
18159   for ac_func in strtof
18160 do
18161 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18162 echo "configure:18163: checking for $ac_func" >&5
18163 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18164   echo $ac_n "(cached) $ac_c" 1>&6
18165 else
18166   cat > conftest.$ac_ext <<EOF
18167 #line 18168 "configure"
18168 #include "confdefs.h"
18169 /* System header to define __stub macros and hopefully few prototypes,
18170     which can conflict with char $ac_func(); below.  */
18171 #include <assert.h>
18172 /* Override any gcc2 internal prototype to avoid an error.  */
18173 /* We use char because int might match the return type of a gcc2
18174     builtin and then its argument prototype would still apply.  */
18175 char $ac_func();
18176
18177 int main() {
18178
18179 /* The GNU C library defines this for functions which it implements
18180     to always fail with ENOSYS.  Some functions are actually named
18181     something starting with __ and the normal name is an alias.  */
18182 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18183 choke me
18184 #else
18185 $ac_func();
18186 #endif
18187
18188 ; return 0; }
18189 EOF
18190 if { (eval echo configure:18191: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18191   rm -rf conftest*
18192   eval "ac_cv_func_$ac_func=yes"
18193 else
18194   echo "configure: failed program was:" >&5
18195   cat conftest.$ac_ext >&5
18196   rm -rf conftest*
18197   eval "ac_cv_func_$ac_func=no"
18198 fi
18199 rm -f conftest*
18200 fi
18201
18202 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18203   echo "$ac_t""yes" 1>&6
18204     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18205   cat >> confdefs.h <<EOF
18206 #define $ac_tr_func 1
18207 EOF
18208
18209 else
18210   echo "$ac_t""no" 1>&6
18211 fi
18212 done
18213
18214
18215   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
18216 echo "configure:18217: checking for strtold declaration" >&5
18217   if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
18218   echo $ac_n "(cached) $ac_c" 1>&6
18219 else
18220
18221
18222     ac_ext=C
18223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18224 ac_cpp='$CXXCPP $CPPFLAGS'
18225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18227 cross_compiling=$ac_cv_prog_cxx_cross
18228
18229     cat > conftest.$ac_ext <<EOF
18230 #line 18231 "configure"
18231 #include "confdefs.h"
18232 #include <stdlib.h>
18233 int main() {
18234  strtold(0, 0);
18235 ; return 0; }
18236 EOF
18237 if { (eval echo configure:18238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18238   rm -rf conftest*
18239   glibcpp_cv_func_strtold_use=yes
18240 else
18241   echo "configure: failed program was:" >&5
18242   cat conftest.$ac_ext >&5
18243   rm -rf conftest*
18244   glibcpp_cv_func_strtold_use=no
18245 fi
18246 rm -f conftest*
18247     ac_ext=c
18248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18249 ac_cpp='$CPP $CPPFLAGS'
18250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18252 cross_compiling=$ac_cv_prog_cc_cross
18253
18254
18255 fi
18256
18257   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
18258   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
18259     for ac_func in strtold
18260 do
18261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18262 echo "configure:18263: checking for $ac_func" >&5
18263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18264   echo $ac_n "(cached) $ac_c" 1>&6
18265 else
18266   cat > conftest.$ac_ext <<EOF
18267 #line 18268 "configure"
18268 #include "confdefs.h"
18269 /* System header to define __stub macros and hopefully few prototypes,
18270     which can conflict with char $ac_func(); below.  */
18271 #include <assert.h>
18272 /* Override any gcc2 internal prototype to avoid an error.  */
18273 /* We use char because int might match the return type of a gcc2
18274     builtin and then its argument prototype would still apply.  */
18275 char $ac_func();
18276
18277 int main() {
18278
18279 /* The GNU C library defines this for functions which it implements
18280     to always fail with ENOSYS.  Some functions are actually named
18281     something starting with __ and the normal name is an alias.  */
18282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18283 choke me
18284 #else
18285 $ac_func();
18286 #endif
18287
18288 ; return 0; }
18289 EOF
18290 if { (eval echo configure:18291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18291   rm -rf conftest*
18292   eval "ac_cv_func_$ac_func=yes"
18293 else
18294   echo "configure: failed program was:" >&5
18295   cat conftest.$ac_ext >&5
18296   rm -rf conftest*
18297   eval "ac_cv_func_$ac_func=no"
18298 fi
18299 rm -f conftest*
18300 fi
18301
18302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18303   echo "$ac_t""yes" 1>&6
18304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18305   cat >> confdefs.h <<EOF
18306 #define $ac_tr_func 1
18307 EOF
18308
18309 else
18310   echo "$ac_t""no" 1>&6
18311 fi
18312 done
18313
18314   fi
18315
18316
18317   CXXFLAGS="$ac_save_CXXFLAGS"
18318
18319
18320   for ac_hdr in unistd.h
18321 do
18322 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18323 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18324 echo "configure:18325: checking for $ac_hdr" >&5
18325 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18326   echo $ac_n "(cached) $ac_c" 1>&6
18327 else
18328   cat > conftest.$ac_ext <<EOF
18329 #line 18330 "configure"
18330 #include "confdefs.h"
18331 #include <$ac_hdr>
18332 EOF
18333 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18334 { (eval echo configure:18335: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18335 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18336 if test -z "$ac_err"; then
18337   rm -rf conftest*
18338   eval "ac_cv_header_$ac_safe=yes"
18339 else
18340   echo "$ac_err" >&5
18341   echo "configure: failed program was:" >&5
18342   cat conftest.$ac_ext >&5
18343   rm -rf conftest*
18344   eval "ac_cv_header_$ac_safe=no"
18345 fi
18346 rm -f conftest*
18347 fi
18348 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18349   echo "$ac_t""yes" 1>&6
18350     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18351   cat >> confdefs.h <<EOF
18352 #define $ac_tr_hdr 1
18353 EOF
18354
18355 else
18356   echo "$ac_t""no" 1>&6
18357 fi
18358 done
18359
18360 for ac_func in getpagesize
18361 do
18362 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18363 echo "configure:18364: checking for $ac_func" >&5
18364 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18365   echo $ac_n "(cached) $ac_c" 1>&6
18366 else
18367   cat > conftest.$ac_ext <<EOF
18368 #line 18369 "configure"
18369 #include "confdefs.h"
18370 /* System header to define __stub macros and hopefully few prototypes,
18371     which can conflict with char $ac_func(); below.  */
18372 #include <assert.h>
18373 /* Override any gcc2 internal prototype to avoid an error.  */
18374 /* We use char because int might match the return type of a gcc2
18375     builtin and then its argument prototype would still apply.  */
18376 char $ac_func();
18377
18378 int main() {
18379
18380 /* The GNU C library defines this for functions which it implements
18381     to always fail with ENOSYS.  Some functions are actually named
18382     something starting with __ and the normal name is an alias.  */
18383 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18384 choke me
18385 #else
18386 $ac_func();
18387 #endif
18388
18389 ; return 0; }
18390 EOF
18391 if { (eval echo configure:18392: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18392   rm -rf conftest*
18393   eval "ac_cv_func_$ac_func=yes"
18394 else
18395   echo "configure: failed program was:" >&5
18396   cat conftest.$ac_ext >&5
18397   rm -rf conftest*
18398   eval "ac_cv_func_$ac_func=no"
18399 fi
18400 rm -f conftest*
18401 fi
18402
18403 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18404   echo "$ac_t""yes" 1>&6
18405     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18406   cat >> confdefs.h <<EOF
18407 #define $ac_tr_func 1
18408 EOF
18409
18410 else
18411   echo "$ac_t""no" 1>&6
18412 fi
18413 done
18414
18415 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
18416 echo "configure:18417: checking for working mmap" >&5
18417 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
18418   echo $ac_n "(cached) $ac_c" 1>&6
18419 else
18420   if test "$cross_compiling" = yes; then
18421   ac_cv_func_mmap_fixed_mapped=no
18422 else
18423   cat > conftest.$ac_ext <<EOF
18424 #line 18425 "configure"
18425 #include "confdefs.h"
18426
18427 /* Thanks to Mike Haertel and Jim Avera for this test.
18428    Here is a matrix of mmap possibilities:
18429         mmap private not fixed
18430         mmap private fixed at somewhere currently unmapped
18431         mmap private fixed at somewhere already mapped
18432         mmap shared not fixed
18433         mmap shared fixed at somewhere currently unmapped
18434         mmap shared fixed at somewhere already mapped
18435    For private mappings, we should verify that changes cannot be read()
18436    back from the file, nor mmap's back from the file at a different
18437    address.  (There have been systems where private was not correctly
18438    implemented like the infamous i386 svr4.0, and systems where the
18439    VM page cache was not coherent with the filesystem buffer cache
18440    like early versions of FreeBSD and possibly contemporary NetBSD.)
18441    For shared mappings, we should conversely verify that changes get
18442    propogated back to all the places they're supposed to be.
18443
18444    Grep wants private fixed already mapped.
18445    The main things grep needs to know about mmap are:
18446    * does it exist and is it safe to write into the mmap'd area
18447    * how to use it (BSD variants)  */
18448 #include <sys/types.h>
18449 #include <fcntl.h>
18450 #include <sys/mman.h>
18451
18452 /* This mess was copied from the GNU getpagesize.h.  */
18453 #ifndef HAVE_GETPAGESIZE
18454 # ifdef HAVE_UNISTD_H
18455 #  include <unistd.h>
18456 # endif
18457
18458 /* Assume that all systems that can run configure have sys/param.h.  */
18459 # ifndef HAVE_SYS_PARAM_H
18460 #  define HAVE_SYS_PARAM_H 1
18461 # endif
18462
18463 # ifdef _SC_PAGESIZE
18464 #  define getpagesize() sysconf(_SC_PAGESIZE)
18465 # else /* no _SC_PAGESIZE */
18466 #  ifdef HAVE_SYS_PARAM_H
18467 #   include <sys/param.h>
18468 #   ifdef EXEC_PAGESIZE
18469 #    define getpagesize() EXEC_PAGESIZE
18470 #   else /* no EXEC_PAGESIZE */
18471 #    ifdef NBPG
18472 #     define getpagesize() NBPG * CLSIZE
18473 #     ifndef CLSIZE
18474 #      define CLSIZE 1
18475 #     endif /* no CLSIZE */
18476 #    else /* no NBPG */
18477 #     ifdef NBPC
18478 #      define getpagesize() NBPC
18479 #     else /* no NBPC */
18480 #      ifdef PAGESIZE
18481 #       define getpagesize() PAGESIZE
18482 #      endif /* PAGESIZE */
18483 #     endif /* no NBPC */
18484 #    endif /* no NBPG */
18485 #   endif /* no EXEC_PAGESIZE */
18486 #  else /* no HAVE_SYS_PARAM_H */
18487 #   define getpagesize() 8192   /* punt totally */
18488 #  endif /* no HAVE_SYS_PARAM_H */
18489 # endif /* no _SC_PAGESIZE */
18490
18491 #endif /* no HAVE_GETPAGESIZE */
18492
18493 #ifdef __cplusplus
18494 extern "C" { void *malloc(unsigned); }
18495 #else
18496 char *malloc();
18497 #endif
18498
18499 int
18500 main()
18501 {
18502         char *data, *data2, *data3;
18503         int i, pagesize;
18504         int fd;
18505
18506         pagesize = getpagesize();
18507
18508         /*
18509          * First, make a file with some known garbage in it.
18510          */
18511         data = malloc(pagesize);
18512         if (!data)
18513                 exit(1);
18514         for (i = 0; i < pagesize; ++i)
18515                 *(data + i) = rand();
18516         umask(0);
18517         fd = creat("conftestmmap", 0600);
18518         if (fd < 0)
18519                 exit(1);
18520         if (write(fd, data, pagesize) != pagesize)
18521                 exit(1);
18522         close(fd);
18523
18524         /*
18525          * Next, try to mmap the file at a fixed address which
18526          * already has something else allocated at it.  If we can,
18527          * also make sure that we see the same garbage.
18528          */
18529         fd = open("conftestmmap", O_RDWR);
18530         if (fd < 0)
18531                 exit(1);
18532         data2 = malloc(2 * pagesize);
18533         if (!data2)
18534                 exit(1);
18535         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
18536         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
18537             MAP_PRIVATE | MAP_FIXED, fd, 0L))
18538                 exit(1);
18539         for (i = 0; i < pagesize; ++i)
18540                 if (*(data + i) != *(data2 + i))
18541                         exit(1);
18542
18543         /*
18544          * Finally, make sure that changes to the mapped area
18545          * do not percolate back to the file as seen by read().
18546          * (This is a bug on some variants of i386 svr4.0.)
18547          */
18548         for (i = 0; i < pagesize; ++i)
18549                 *(data2 + i) = *(data2 + i) + 1;
18550         data3 = malloc(pagesize);
18551         if (!data3)
18552                 exit(1);
18553         if (read(fd, data3, pagesize) != pagesize)
18554                 exit(1);
18555         for (i = 0; i < pagesize; ++i)
18556                 if (*(data + i) != *(data3 + i))
18557                         exit(1);
18558         close(fd);
18559         unlink("conftestmmap");
18560         exit(0);
18561 }
18562
18563 EOF
18564 if { (eval echo configure:18565: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
18565 then
18566   ac_cv_func_mmap_fixed_mapped=yes
18567 else
18568   echo "configure: failed program was:" >&5
18569   cat conftest.$ac_ext >&5
18570   rm -fr conftest*
18571   ac_cv_func_mmap_fixed_mapped=no
18572 fi
18573 rm -fr conftest*
18574 fi
18575
18576 fi
18577
18578 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
18579 if test $ac_cv_func_mmap_fixed_mapped = yes; then
18580   cat >> confdefs.h <<\EOF
18581 #define HAVE_MMAP 1
18582 EOF
18583
18584 fi
18585
18586 fi
18587
18588
18589
18590 if test "$CANADIAN" = yes; then
18591   CANADIAN_TRUE=
18592   CANADIAN_FALSE='#'
18593 else
18594   CANADIAN_TRUE='#'
18595   CANADIAN_FALSE=
18596 fi
18597
18598
18599 if test "$NULL_TARGET" = yes; then
18600   NULL_TARGET_TRUE=
18601   NULL_TARGET_FALSE='#'
18602 else
18603   NULL_TARGET_TRUE='#'
18604   NULL_TARGET_FALSE=
18605 fi
18606
18607
18608 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
18609   NATIVE_TRUE=
18610   NATIVE_FALSE='#'
18611 else
18612   NATIVE_TRUE='#'
18613   NATIVE_FALSE=
18614 fi
18615
18616
18617 if test -z "$with_cross_host"; then
18618   USE_LIBDIR_TRUE=
18619   USE_LIBDIR_FALSE='#'
18620 else
18621   USE_LIBDIR_TRUE='#'
18622   USE_LIBDIR_FALSE=
18623 fi
18624
18625 cat > confcache <<\EOF
18626 # This file is a shell script that caches the results of configure
18627 # tests run on this system so they can be shared between configure
18628 # scripts and configure runs.  It is not useful on other systems.
18629 # If it contains results you don't want to keep, you may remove or edit it.
18630 #
18631 # By default, configure uses ./config.cache as the cache file,
18632 # creating it if it does not exist already.  You can give configure
18633 # the --cache-file=FILE option to use a different cache file; that is
18634 # what configure does when it calls configure scripts in
18635 # subdirectories, so they share the cache.
18636 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18637 # config.status only pays attention to the cache file if you give it the
18638 # --recheck option to rerun configure.
18639 #
18640 EOF
18641 # The following way of writing the cache mishandles newlines in values,
18642 # but we know of no workaround that is simple, portable, and efficient.
18643 # So, don't put newlines in cache variables' values.
18644 # Ultrix sh set writes to stderr and can't be redirected directly,
18645 # and sets the high bit in the cache file unless we assign to the vars.
18646 (set) 2>&1 |
18647   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18648   *ac_space=\ *)
18649     # `set' does not quote correctly, so add quotes (double-quote substitution
18650     # turns \\\\ into \\, and sed turns \\ into \).
18651     sed -n \
18652       -e "s/'/'\\\\''/g" \
18653       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18654     ;;
18655   *)
18656     # `set' quotes correctly as required by POSIX, so do not add quotes.
18657     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18658     ;;
18659   esac >> confcache
18660 if cmp -s $cache_file confcache; then
18661   :
18662 else
18663   if test -w $cache_file; then
18664     echo "updating cache $cache_file"
18665     cat confcache > $cache_file
18666   else
18667     echo "not updating unwritable cache $cache_file"
18668   fi
18669 fi
18670 rm -f confcache
18671
18672
18673   ac_safe=`echo "locale.h" | sed 'y%./+-%__p_%'`
18674 echo $ac_n "checking for locale.h""... $ac_c" 1>&6
18675 echo "configure:18676: checking for locale.h" >&5
18676 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18677   echo $ac_n "(cached) $ac_c" 1>&6
18678 else
18679   cat > conftest.$ac_ext <<EOF
18680 #line 18681 "configure"
18681 #include "confdefs.h"
18682 #include <locale.h>
18683 EOF
18684 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18685 { (eval echo configure:18686: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18686 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18687 if test -z "$ac_err"; then
18688   rm -rf conftest*
18689   eval "ac_cv_header_$ac_safe=yes"
18690 else
18691   echo "$ac_err" >&5
18692   echo "configure: failed program was:" >&5
18693   cat conftest.$ac_ext >&5
18694   rm -rf conftest*
18695   eval "ac_cv_header_$ac_safe=no"
18696 fi
18697 rm -f conftest*
18698 fi
18699 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18700   echo "$ac_t""yes" 1>&6
18701
18702     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
18703 echo "configure:18704: checking for LC_MESSAGES" >&5
18704 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
18705   echo $ac_n "(cached) $ac_c" 1>&6
18706 else
18707   cat > conftest.$ac_ext <<EOF
18708 #line 18709 "configure"
18709 #include "confdefs.h"
18710 #include <locale.h>
18711 int main() {
18712 return LC_MESSAGES
18713 ; return 0; }
18714 EOF
18715 if { (eval echo configure:18716: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18716   rm -rf conftest*
18717   ac_cv_val_LC_MESSAGES=yes
18718 else
18719   echo "configure: failed program was:" >&5
18720   cat conftest.$ac_ext >&5
18721   rm -rf conftest*
18722   ac_cv_val_LC_MESSAGES=no
18723 fi
18724 rm -f conftest*
18725 fi
18726
18727 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
18728     if test $ac_cv_val_LC_MESSAGES = yes; then
18729       cat >> confdefs.h <<\EOF
18730 #define HAVE_LC_MESSAGES 1
18731 EOF
18732
18733     fi
18734
18735 else
18736   echo "$ac_t""no" 1>&6
18737 fi
18738
18739
18740
18741 if test "${multilib}" = "yes"; then
18742   multilib_arg="--enable-multilib"
18743 else
18744   multilib_arg=
18745 fi
18746
18747
18748 # Generate the various Makefiles, include files, and scripts.
18749
18750 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
18751 # Needed so that g++ can find the correct include subdir automatically.
18752 INTERFACE=v3
18753
18754 # Check for the interface version number for specifying where header
18755 # files are installed, if a version number is provided.
18756 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
18757 echo "configure:18758: checking for interface version number" >&5
18758 libstdcxx_interface=$INTERFACE
18759 echo "$ac_t""$libstdcxx_interface" 1>&6
18760
18761
18762 # Process the option --with-gxx-include-dir=<path to include-files directory>
18763 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
18764 echo "configure:18765: checking for --with-gxx-include-dir" >&5
18765 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
18766 if test "${with_gxx_include_dir+set}" = set; then
18767   withval="$with_gxx_include_dir"
18768   case "${withval}" in
18769   yes)
18770     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
18771     gxx_include_dir=no
18772     ;;
18773   no)
18774     gxx_include_dir=no
18775     ;;
18776   *)
18777     gxx_include_dir=${withval}
18778     ;;
18779 esac
18780 else
18781   gxx_include_dir=no
18782 fi
18783
18784 echo "$ac_t""$gxx_include_dir" 1>&6
18785
18786
18787
18788 if test x${gxx_include_dir} != xno; then
18789   GXX_INCLUDE_DIR_TRUE=
18790   GXX_INCLUDE_DIR_FALSE='#'
18791 else
18792   GXX_INCLUDE_DIR_TRUE='#'
18793   GXX_INCLUDE_DIR_FALSE=
18794 fi
18795
18796 # Process the option "--enable-version-specific-runtime-libs"
18797 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
18798 echo "configure:18799: checking for --enable-version-specific-runtime-libs" >&5
18799 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
18800 if test "${enable_version_specific_runtime_libs+set}" = set; then
18801   enableval="$enable_version_specific_runtime_libs"
18802     version_specific_libs=yes
18803 # Need the gcc compiler version to know where to install libraries
18804 # and header files if --enable-version-specific-runtime-libs option
18805 # is selected.
18806 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
18807 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
18808 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
18809 #gcc_version=$gcc_num-$gcc_date
18810 gcc_version=$gcc_num
18811
18812
18813 else
18814   version_specific_libs=no
18815 fi
18816
18817 echo "$ac_t""$version_specific_libs" 1>&6
18818 if test x${version_specific_libs} = xyes; then
18819
18820
18821 if test x${version_specific_libs} = xyes; then
18822   VERSION_SPECIFIC_LIBS_TRUE=
18823   VERSION_SPECIFIC_LIBS_FALSE='#'
18824 else
18825   VERSION_SPECIFIC_LIBS_TRUE='#'
18826   VERSION_SPECIFIC_LIBS_FALSE=
18827 fi
18828   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
18829 fi
18830
18831
18832
18833 # Export all the include and flag information to makefiles.
18834
18835   # Root level of the include sources.
18836   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
18837
18838   # Can either use include/c or include/c_std to grab "C" headers. This
18839   # variable is set to the include directory currently in use.
18840   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
18841
18842   # Passed down for canadian crosses.
18843   if  test x"$CANADIAN" = xyes; then
18844     TOPLEVEL_INCLUDES='-I$(includedir)'
18845   fi
18846
18847   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
18848
18849   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
18850
18851   #if GLIBCPP_NEED_LIBIO
18852   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
18853   #else
18854   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
18855   #endif
18856
18857   #if GLIBCPP_USE_CSHADOW
18858   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
18859   #                   -I$(top_blddir)/cshadow'
18860   #else
18861   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
18862   #endif
18863
18864   # Now, export this to all the little Makefiles....
18865
18866
18867
18868
18869
18870
18871
18872
18873   # Optimization flags that are probably a good idea for thrill-seekers. Just
18874   # uncomment the lines below and make, everything else is ready to go...
18875   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
18876   OPTIMIZE_CXXFLAGS=
18877
18878
18879   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
18880
18881
18882
18883 # This should be done by mkincludedir, but hack around it now.
18884 blddir=`pwd`
18885 echo "checking for $blddir/include"
18886
18887 if test ! -d "$blddir/include"; then
18888   mkdir "$blddir/include"
18889 fi
18890
18891 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
18892 # so that multilib installs will end up installed in the correct
18893 # place. To work around this not being passed down from config-ml.in
18894 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
18895 # append it here.
18896 trap '' 1 2 15
18897 cat > confcache <<\EOF
18898 # This file is a shell script that caches the results of configure
18899 # tests run on this system so they can be shared between configure
18900 # scripts and configure runs.  It is not useful on other systems.
18901 # If it contains results you don't want to keep, you may remove or edit it.
18902 #
18903 # By default, configure uses ./config.cache as the cache file,
18904 # creating it if it does not exist already.  You can give configure
18905 # the --cache-file=FILE option to use a different cache file; that is
18906 # what configure does when it calls configure scripts in
18907 # subdirectories, so they share the cache.
18908 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18909 # config.status only pays attention to the cache file if you give it the
18910 # --recheck option to rerun configure.
18911 #
18912 EOF
18913 # The following way of writing the cache mishandles newlines in values,
18914 # but we know of no workaround that is simple, portable, and efficient.
18915 # So, don't put newlines in cache variables' values.
18916 # Ultrix sh set writes to stderr and can't be redirected directly,
18917 # and sets the high bit in the cache file unless we assign to the vars.
18918 (set) 2>&1 |
18919   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18920   *ac_space=\ *)
18921     # `set' does not quote correctly, so add quotes (double-quote substitution
18922     # turns \\\\ into \\, and sed turns \\ into \).
18923     sed -n \
18924       -e "s/'/'\\\\''/g" \
18925       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18926     ;;
18927   *)
18928     # `set' quotes correctly as required by POSIX, so do not add quotes.
18929     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18930     ;;
18931   esac >> confcache
18932 if cmp -s $cache_file confcache; then
18933   :
18934 else
18935   if test -w $cache_file; then
18936     echo "updating cache $cache_file"
18937     cat confcache > $cache_file
18938   else
18939     echo "not updating unwritable cache $cache_file"
18940   fi
18941 fi
18942 rm -f confcache
18943
18944 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
18945
18946 test "x$prefix" = xNONE && prefix=$ac_default_prefix
18947 # Let make expand exec_prefix.
18948 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
18949
18950 # Any assignment to VPATH causes Sun make to only execute
18951 # the first set of double-colon rules, so remove it if not needed.
18952 # If there is a colon in the path, we need to keep it.
18953 if test "x$srcdir" = x.; then
18954   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
18955 fi
18956
18957 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
18958
18959 DEFS=-DHAVE_CONFIG_H
18960
18961 # Without the "./", some shells look in PATH for config.status.
18962 : ${CONFIG_STATUS=./config.status}
18963
18964 echo creating $CONFIG_STATUS
18965 rm -f $CONFIG_STATUS
18966 cat > $CONFIG_STATUS <<EOF
18967 #! /bin/sh
18968 # Generated automatically by configure.
18969 # Run this file to recreate the current configuration.
18970 # This directory was configured as follows,
18971 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
18972 #
18973 # $0 $ac_configure_args
18974 #
18975 # Compiler output produced by configure, useful for debugging
18976 # configure, is in ./config.log if it exists.
18977
18978 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
18979 for ac_option
18980 do
18981   case "\$ac_option" in
18982   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
18983     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
18984     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
18985   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
18986     echo "$CONFIG_STATUS generated by autoconf version 2.13"
18987     exit 0 ;;
18988   -help | --help | --hel | --he | --h)
18989     echo "\$ac_cs_usage"; exit 0 ;;
18990   *) echo "\$ac_cs_usage"; exit 1 ;;
18991   esac
18992 done
18993
18994 ac_given_srcdir=$srcdir
18995 ac_given_INSTALL="$INSTALL"
18996
18997 trap 'rm -fr `echo "tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
18998 EOF
18999 cat >> $CONFIG_STATUS <<EOF
19000
19001 # Protect against being on the right side of a sed subst in config.status.
19002 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
19003  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
19004 $ac_vpsub
19005 $extrasub
19006 s%@SHELL@%$SHELL%g
19007 s%@CFLAGS@%$CFLAGS%g
19008 s%@CPPFLAGS@%$CPPFLAGS%g
19009 s%@CXXFLAGS@%$CXXFLAGS%g
19010 s%@FFLAGS@%$FFLAGS%g
19011 s%@DEFS@%$DEFS%g
19012 s%@LDFLAGS@%$LDFLAGS%g
19013 s%@LIBS@%$LIBS%g
19014 s%@exec_prefix@%$exec_prefix%g
19015 s%@prefix@%$prefix%g
19016 s%@program_transform_name@%$program_transform_name%g
19017 s%@bindir@%$bindir%g
19018 s%@sbindir@%$sbindir%g
19019 s%@libexecdir@%$libexecdir%g
19020 s%@datadir@%$datadir%g
19021 s%@sysconfdir@%$sysconfdir%g
19022 s%@sharedstatedir@%$sharedstatedir%g
19023 s%@localstatedir@%$localstatedir%g
19024 s%@libdir@%$libdir%g
19025 s%@includedir@%$includedir%g
19026 s%@oldincludedir@%$oldincludedir%g
19027 s%@infodir@%$infodir%g
19028 s%@mandir@%$mandir%g
19029 s%@host@%$host%g
19030 s%@host_alias@%$host_alias%g
19031 s%@host_cpu@%$host_cpu%g
19032 s%@host_vendor@%$host_vendor%g
19033 s%@host_os@%$host_os%g
19034 s%@target@%$target%g
19035 s%@target_alias@%$target_alias%g
19036 s%@target_cpu@%$target_cpu%g
19037 s%@target_vendor@%$target_vendor%g
19038 s%@target_os@%$target_os%g
19039 s%@build@%$build%g
19040 s%@build_alias@%$build_alias%g
19041 s%@build_cpu@%$build_cpu%g
19042 s%@build_vendor@%$build_vendor%g
19043 s%@build_os@%$build_os%g
19044 s%@glibcpp_basedir@%$glibcpp_basedir%g
19045 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
19046 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
19047 s%@INSTALL_DATA@%$INSTALL_DATA%g
19048 s%@PACKAGE@%$PACKAGE%g
19049 s%@VERSION@%$VERSION%g
19050 s%@ACLOCAL@%$ACLOCAL%g
19051 s%@AUTOCONF@%$AUTOCONF%g
19052 s%@AUTOMAKE@%$AUTOMAKE%g
19053 s%@AUTOHEADER@%$AUTOHEADER%g
19054 s%@MAKEINFO@%$MAKEINFO%g
19055 s%@SET_MAKE@%$SET_MAKE%g
19056 s%@CC@%$CC%g
19057 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
19058 s%@CXX@%$CXX%g
19059 s%@AS@%$AS%g
19060 s%@AR@%$AR%g
19061 s%@RANLIB@%$RANLIB%g
19062 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
19063 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
19064 s%@MAINT@%$MAINT%g
19065 s%@EXEEXT@%$EXEEXT%g
19066 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
19067 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
19068 s%@LN_S@%$LN_S%g
19069 s%@OBJEXT@%$OBJEXT%g
19070 s%@STRIP@%$STRIP%g
19071 s%@LIBTOOL@%$LIBTOOL%g
19072 s%@CXXCPP@%$CXXCPP%g
19073 s%@enable_shared@%$enable_shared%g
19074 s%@enable_static@%$enable_static%g
19075 s%@ifGNUmake@%$ifGNUmake%g
19076 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
19077 s%@CPP@%$CPP%g
19078 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
19079 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
19080 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
19081 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
19082 s%@libio_la@%$libio_la%g
19083 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
19084 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
19085 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
19086 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
19087 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
19088 s%@WERROR@%$WERROR%g
19089 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
19090 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
19091 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
19092 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
19093 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
19094 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
19095 s%@libinst_wstring_la@%$libinst_wstring_la%g
19096 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
19097 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
19098 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
19099 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
19100 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
19101 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
19102 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
19103 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
19104 s%@libstdcxx_interface@%$libstdcxx_interface%g
19105 s%@gxx_include_dir@%$gxx_include_dir%g
19106 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
19107 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
19108 s%@gcc_version@%$gcc_version%g
19109 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
19110 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
19111 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
19112 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
19113 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
19114 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
19115 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
19116 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
19117 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
19118 s%@WARN_FLAGS@%$WARN_FLAGS%g
19119
19120 CEOF
19121 EOF
19122
19123 cat >> $CONFIG_STATUS <<\EOF
19124
19125 # Split the substitutions into bite-sized pieces for seds with
19126 # small command number limits, like on Digital OSF/1 and HP-UX.
19127 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
19128 ac_file=1 # Number of current file.
19129 ac_beg=1 # First line for current file.
19130 ac_end=$ac_max_sed_cmds # Line after last line for current file.
19131 ac_more_lines=:
19132 ac_sed_cmds=""
19133 while $ac_more_lines; do
19134   if test $ac_beg -gt 1; then
19135     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
19136   else
19137     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
19138   fi
19139   if test ! -s conftest.s$ac_file; then
19140     ac_more_lines=false
19141     rm -f conftest.s$ac_file
19142   else
19143     if test -z "$ac_sed_cmds"; then
19144       ac_sed_cmds="sed -f conftest.s$ac_file"
19145     else
19146       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
19147     fi
19148     ac_file=`expr $ac_file + 1`
19149     ac_beg=$ac_end
19150     ac_end=`expr $ac_end + $ac_max_sed_cmds`
19151   fi
19152 done
19153 if test -z "$ac_sed_cmds"; then
19154   ac_sed_cmds=cat
19155 fi
19156 EOF
19157
19158 cat >> $CONFIG_STATUS <<EOF
19159
19160 CONFIG_FILES=\${CONFIG_FILES-"tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
19161 EOF
19162 cat >> $CONFIG_STATUS <<\EOF
19163 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
19164   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19165   case "$ac_file" in
19166   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19167        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19168   *) ac_file_in="${ac_file}.in" ;;
19169   esac
19170
19171   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
19172
19173   # Remove last slash and all that follows it.  Not all systems have dirname.
19174   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19175   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19176     # The file is in a subdirectory.
19177     test ! -d "$ac_dir" && mkdir "$ac_dir"
19178     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
19179     # A "../" for each directory in $ac_dir_suffix.
19180     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
19181   else
19182     ac_dir_suffix= ac_dots=
19183   fi
19184
19185   case "$ac_given_srcdir" in
19186   .)  srcdir=.
19187       if test -z "$ac_dots"; then top_srcdir=.
19188       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
19189   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
19190   *) # Relative path.
19191     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
19192     top_srcdir="$ac_dots$ac_given_srcdir" ;;
19193   esac
19194
19195   case "$ac_given_INSTALL" in
19196   [/$]*) INSTALL="$ac_given_INSTALL" ;;
19197   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
19198   esac
19199
19200   echo creating "$ac_file"
19201   rm -f "$ac_file"
19202   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
19203   case "$ac_file" in
19204   *Makefile*) ac_comsub="1i\\
19205 # $configure_input" ;;
19206   *) ac_comsub= ;;
19207   esac
19208
19209   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19210   sed -e "$ac_comsub
19211 s%@configure_input@%$configure_input%g
19212 s%@srcdir@%$srcdir%g
19213 s%@top_srcdir@%$top_srcdir%g
19214 s%@INSTALL@%$INSTALL%g
19215 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
19216 fi; done
19217 rm -f conftest.s*
19218
19219 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
19220 # NAME is the cpp macro being defined and VALUE is the value it is being given.
19221 #
19222 # ac_d sets the value in "#define NAME VALUE" lines.
19223 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
19224 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
19225 ac_dC='\3'
19226 ac_dD='%g'
19227 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
19228 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19229 ac_uB='\([      ]\)%\1#\2define\3'
19230 ac_uC=' '
19231 ac_uD='\4%g'
19232 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
19233 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19234 ac_eB='$%\1#\2define\3'
19235 ac_eC=' '
19236 ac_eD='%g'
19237
19238 if test "${CONFIG_HEADERS+set}" != set; then
19239 EOF
19240 cat >> $CONFIG_STATUS <<EOF
19241   CONFIG_HEADERS="config.h"
19242 EOF
19243 cat >> $CONFIG_STATUS <<\EOF
19244 fi
19245 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
19246   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19247   case "$ac_file" in
19248   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19249        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19250   *) ac_file_in="${ac_file}.in" ;;
19251   esac
19252
19253   echo creating $ac_file
19254
19255   rm -f conftest.frag conftest.in conftest.out
19256   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19257   cat $ac_file_inputs > conftest.in
19258
19259 EOF
19260
19261 # Transform confdefs.h into a sed script conftest.vals that substitutes
19262 # the proper values into config.h.in to produce config.h.  And first:
19263 # Protect against being on the right side of a sed subst in config.status.
19264 # Protect against being in an unquoted here document in config.status.
19265 rm -f conftest.vals
19266 cat > conftest.hdr <<\EOF
19267 s/[\\&%]/\\&/g
19268 s%[\\$`]%\\&%g
19269 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
19270 s%ac_d%ac_u%gp
19271 s%ac_u%ac_e%gp
19272 EOF
19273 sed -n -f conftest.hdr confdefs.h > conftest.vals
19274 rm -f conftest.hdr
19275
19276 # This sed command replaces #undef with comments.  This is necessary, for
19277 # example, in the case of _POSIX_SOURCE, which is predefined and required
19278 # on some systems where configure will not decide to define it.
19279 cat >> conftest.vals <<\EOF
19280 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
19281 EOF
19282
19283 # Break up conftest.vals because some shells have a limit on
19284 # the size of here documents, and old seds have small limits too.
19285
19286 rm -f conftest.tail
19287 while :
19288 do
19289   ac_lines=`grep -c . conftest.vals`
19290   # grep -c gives empty output for an empty file on some AIX systems.
19291   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
19292   # Write a limited-size here document to conftest.frag.
19293   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
19294   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
19295   echo 'CEOF
19296   sed -f conftest.frag conftest.in > conftest.out
19297   rm -f conftest.in
19298   mv conftest.out conftest.in
19299 ' >> $CONFIG_STATUS
19300   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
19301   rm -f conftest.vals
19302   mv conftest.tail conftest.vals
19303 done
19304 rm -f conftest.vals
19305
19306 cat >> $CONFIG_STATUS <<\EOF
19307   rm -f conftest.frag conftest.h
19308   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
19309   cat conftest.in >> conftest.h
19310   rm -f conftest.in
19311   if cmp -s $ac_file conftest.h 2>/dev/null; then
19312     echo "$ac_file is unchanged"
19313     rm -f conftest.h
19314   else
19315     # Remove last slash and all that follows it.  Not all systems have dirname.
19316       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19317       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19318       # The file is in a subdirectory.
19319       test ! -d "$ac_dir" && mkdir "$ac_dir"
19320     fi
19321     rm -f $ac_file
19322     mv conftest.h $ac_file
19323   fi
19324 fi; done
19325
19326 EOF
19327
19328 cat >> $CONFIG_STATUS <<EOF
19329 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"
19330 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 \
19331         include/bits/ctype_inline.h \
19332         include/bits/ctype_noninline.h include/bits/ctype_base.h \
19333         include/bits/ctype_inline.h \
19334         include/bits/ctype_noninline.h include/bits/ctype_base.h include/bits/ctype_inline.h \
19335     include/bits/ctype_noninline.h"
19336 EOF
19337
19338 cat >> $CONFIG_STATUS <<\EOF
19339 srcdir=$ac_given_srcdir
19340 while test -n "$ac_sources"; do
19341   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
19342   set $ac_sources; ac_source=$1; shift; ac_sources=$*
19343
19344   echo "linking $srcdir/$ac_source to $ac_dest"
19345
19346   if test ! -r $srcdir/$ac_source; then
19347     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
19348   fi
19349   rm -f $ac_dest
19350
19351   # Make relative symlinks.
19352   # Remove last slash and all that follows it.  Not all systems have dirname.
19353   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
19354   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
19355     # The dest file is in a subdirectory.
19356     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
19357     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
19358     # A "../" for each directory in $ac_dest_dir_suffix.
19359     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
19360   else
19361     ac_dest_dir_suffix= ac_dots=
19362   fi
19363
19364   case "$srcdir" in
19365   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
19366   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
19367   esac
19368
19369   # Make a symlink if possible; otherwise try a hard link.
19370   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
19371     ln $srcdir/$ac_source $ac_dest; then :
19372   else
19373     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
19374   fi
19375 done
19376 EOF
19377 cat >> $CONFIG_STATUS <<EOF
19378
19379 srcdir=${srcdir}
19380 host=${host}
19381 target=${target}
19382 with_multisubdir=${with_multisubdir}
19383 ac_configure_args="${multilib_arg} ${ac_configure_args}"
19384 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
19385 glibcpp_basedir=${glibcpp_basedir}
19386 CC="${CC}"
19387 CXX="${CXX}"
19388
19389 EOF
19390 cat >> $CONFIG_STATUS <<\EOF
19391 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
19392 if test -n "$CONFIG_FILES"; then
19393   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
19394   grep '^MULTISUBDIR =' Makefile >> src/Makefile
19395 fi
19396 chmod +x tests_flags
19397 chmod +x mkcheck
19398
19399 exit 0
19400 EOF
19401 chmod +x $CONFIG_STATUS
19402 rm -fr confdefs* $ac_clean_files
19403 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
19404
19405
19406
19407 # Generate bits/c++config.h
19408 # NB: This must be the first generated file as others include it. . .
19409 $srcdir/mkc++config $blddir $srcdir
19410
19411 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
19412 if test ! -f stamp-limits; then
19413   $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
19414   touch stamp-limits
19415 fi
19416
19417
19418 # Sanity checking & User-visible messages.
19419 # Checks down here, otherwise they get scrolled off before
19420 # the user will notice.
19421
19422 # Trying to get more people to read documentation.  Possibly remove
19423 # check and warn all the time. There is no "informational" AC_MSG_
19424 # macro, so these are going to be printed even when --quiet/--silent
19425 # is given.
19426 if test ! -f stamp-sanity-warned; then
19427   touch stamp-sanity-warned
19428   echo ""
19429   echo "Please make certain that you read the installation information here:"
19430   echo "  faster => ${srcdir}/docs/install.html"
19431   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
19432   echo ""
19433   echo "and the configuration information here:"
19434   echo "  faster => ${srcdir}/docs/configopts.html"
19435   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
19436   echo ""
19437   echo "before proceeding with ${_cv_gnu_make_command}."
19438   echo ""
19439 fi