libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --with-pic              try to use only PIC/non-PIC objects [default=use both]"
  36 ac_help="$ac_help
  37   --enable-debug          extra debugging, turn off optimization [default=no]"
  38 ac_help="$ac_help
  39   --enable-c-mbchar       enable multibyte (wide) characters [default=yes]"
  40 ac_help="$ac_help
  41   --enable-cstdio        enable GNU libio for target io package. (default)
  42      --enable-cstdio=LIB    use LIB target-speific io package."
  43 ac_help="$ac_help
  44   --enable-long-long      turns on 'long long' [default=yes]"
  45 ac_help="$ac_help
  46   --enable-cshadow-headers construct "shadowed" C header files for
  47                            g++ [default=no]"
  48 ac_help="$ac_help
  49   --enable-threads        enable thread usage for target GCC.
  50      --enable-threads=LIB    use LIB thread package for target GCC."
  51 ac_help="$ac_help
  52   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  53                                 [default=none]"
  54 ac_help="$ac_help
  55  --with-gxx-include-dir  the installation directory for include files"
  56 ac_help="$ac_help
  57   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory "
  58
  59 # Initialize some variables set by options.
  60 # The variables have the same names as the options, with
  61 # dashes changed to underlines.
  62 build=NONE
  63 cache_file=./config.cache
  64 exec_prefix=NONE
  65 host=NONE
  66 no_create=
  67 nonopt=NONE
  68 no_recursion=
  69 prefix=NONE
  70 program_prefix=NONE
  71 program_suffix=NONE
  72 program_transform_name=s,x,x,
  73 silent=
  74 site=
  75 srcdir=
  76 target=NONE
  77 verbose=
  78 x_includes=NONE
  79 x_libraries=NONE
  80 bindir='${exec_prefix}/bin'
  81 sbindir='${exec_prefix}/sbin'
  82 libexecdir='${exec_prefix}/libexec'
  83 datadir='${prefix}/share'
  84 sysconfdir='${prefix}/etc'
  85 sharedstatedir='${prefix}/com'
  86 localstatedir='${prefix}/var'
  87 libdir='${exec_prefix}/lib'
  88 includedir='${prefix}/include'
  89 oldincludedir='/usr/include'
  90 infodir='${prefix}/info'
  91 mandir='${prefix}/man'
  92
  93 # Initialize some other variables.
  94 subdirs=
  95 MFLAGS= MAKEFLAGS=
  96 SHELL=${CONFIG_SHELL-/bin/sh}
  97 # Maximum number of lines to put in a shell here document.
  98 ac_max_here_lines=12
  99
 100 ac_prev=
 101 for ac_option
 102 do
 103
 104   # If the previous option needs an argument, assign it.
 105   if test -n "$ac_prev"; then
 106     eval "$ac_prev=\$ac_option"
 107     ac_prev=
 108     continue
 109   fi
 110
 111   case "$ac_option" in
 112   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 113   *) ac_optarg= ;;
 114   esac
 115
 116   # Accept the important Cygnus configure options, so we can diagnose typos.
 117
 118   case "$ac_option" in
 119
 120   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 121     ac_prev=bindir ;;
 122   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 123     bindir="$ac_optarg" ;;
 124
 125   -build | --build | --buil | --bui | --bu)
 126     ac_prev=build ;;
 127   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 128     build="$ac_optarg" ;;
 129
 130   -cache-file | --cache-file | --cache-fil | --cache-fi \
 131   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 132     ac_prev=cache_file ;;
 133   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 134   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 135     cache_file="$ac_optarg" ;;
 136
 137   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 138     ac_prev=datadir ;;
 139   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 140   | --da=*)
 141     datadir="$ac_optarg" ;;
 142
 143   -disable-* | --disable-*)
 144     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 145     # Reject names that are not valid shell variable names.
 146     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 147       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 148     fi
 149     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 150     eval "enable_${ac_feature}=no" ;;
 151
 152   -enable-* | --enable-*)
 153     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 154     # Reject names that are not valid shell variable names.
 155     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 156       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 157     fi
 158     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 159     case "$ac_option" in
 160       *=*) ;;
 161       *) ac_optarg=yes ;;
 162     esac
 163     eval "enable_${ac_feature}='$ac_optarg'" ;;
 164
 165   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 166   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 167   | --exec | --exe | --ex)
 168     ac_prev=exec_prefix ;;
 169   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 170   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 171   | --exec=* | --exe=* | --ex=*)
 172     exec_prefix="$ac_optarg" ;;
 173
 174   -gas | --gas | --ga | --g)
 175     # Obsolete; use --with-gas.
 176     with_gas=yes ;;
 177
 178   -help | --help | --hel | --he)
 179     # Omit some internal or obsolete options to make the list less imposing.
 180     # This message is too long to be a string in the A/UX 3.1 sh.
 181     cat << EOF
 182 Usage: configure [options] [host]
 183 Options: [defaults in brackets after descriptions]
 184 Configuration:
 185   --cache-file=FILE       cache test results in FILE
 186   --help                  print this message
 187   --no-create             do not create output files
 188   --quiet, --silent       do not print \`checking...' messages
 189   --version               print the version of autoconf that created configure
 190 Directory and file names:
 191   --prefix=PREFIX         install architecture-independent files in PREFIX
 192                           [$ac_default_prefix]
 193   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 194                           [same as prefix]
 195   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 196   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 197   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 198   --datadir=DIR           read-only architecture-independent data in DIR
 199                           [PREFIX/share]
 200   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 201   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 202                           [PREFIX/com]
 203   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 204   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 205   --includedir=DIR        C header files in DIR [PREFIX/include]
 206   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 207   --infodir=DIR           info documentation in DIR [PREFIX/info]
 208   --mandir=DIR            man documentation in DIR [PREFIX/man]
 209   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 210   --program-prefix=PREFIX prepend PREFIX to installed program names
 211   --program-suffix=SUFFIX append SUFFIX to installed program names
 212   --program-transform-name=PROGRAM
 213                           run sed PROGRAM on installed program names
 214 EOF
 215     cat << EOF
 216 Host type:
 217   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 218   --host=HOST             configure for HOST [guessed]
 219   --target=TARGET         configure for TARGET [TARGET=HOST]
 220 Features and packages:
 221   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 222   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 223   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 224   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 225   --x-includes=DIR        X include files are in DIR
 226   --x-libraries=DIR       X library files are in DIR
 227 EOF
 228     if test -n "$ac_help"; then
 229       echo "--enable and --with options recognized:$ac_help"
 230     fi
 231     exit 0 ;;
 232
 233   -host | --host | --hos | --ho)
 234     ac_prev=host ;;
 235   -host=* | --host=* | --hos=* | --ho=*)
 236     host="$ac_optarg" ;;
 237
 238   -includedir | --includedir | --includedi | --included | --include \
 239   | --includ | --inclu | --incl | --inc)
 240     ac_prev=includedir ;;
 241   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 242   | --includ=* | --inclu=* | --incl=* | --inc=*)
 243     includedir="$ac_optarg" ;;
 244
 245   -infodir | --infodir | --infodi | --infod | --info | --inf)
 246     ac_prev=infodir ;;
 247   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 248     infodir="$ac_optarg" ;;
 249
 250   -libdir | --libdir | --libdi | --libd)
 251     ac_prev=libdir ;;
 252   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 253     libdir="$ac_optarg" ;;
 254
 255   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 256   | --libexe | --libex | --libe)
 257     ac_prev=libexecdir ;;
 258   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 259   | --libexe=* | --libex=* | --libe=*)
 260     libexecdir="$ac_optarg" ;;
 261
 262   -localstatedir | --localstatedir | --localstatedi | --localstated \
 263   | --localstate | --localstat | --localsta | --localst \
 264   | --locals | --local | --loca | --loc | --lo)
 265     ac_prev=localstatedir ;;
 266   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 267   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 268   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 269     localstatedir="$ac_optarg" ;;
 270
 271   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 272     ac_prev=mandir ;;
 273   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 274     mandir="$ac_optarg" ;;
 275
 276   -nfp | --nfp | --nf)
 277     # Obsolete; use --without-fp.
 278     with_fp=no ;;
 279
 280   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 281   | --no-cr | --no-c)
 282     no_create=yes ;;
 283
 284   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 285   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 286     no_recursion=yes ;;
 287
 288   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 289   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 290   | --oldin | --oldi | --old | --ol | --o)
 291     ac_prev=oldincludedir ;;
 292   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 293   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 294   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 295     oldincludedir="$ac_optarg" ;;
 296
 297   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 298     ac_prev=prefix ;;
 299   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 300     prefix="$ac_optarg" ;;
 301
 302   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 303   | --program-pre | --program-pr | --program-p)
 304     ac_prev=program_prefix ;;
 305   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 306   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 307     program_prefix="$ac_optarg" ;;
 308
 309   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 310   | --program-suf | --program-su | --program-s)
 311     ac_prev=program_suffix ;;
 312   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 313   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 314     program_suffix="$ac_optarg" ;;
 315
 316   -program-transform-name | --program-transform-name \
 317   | --program-transform-nam | --program-transform-na \
 318   | --program-transform-n | --program-transform- \
 319   | --program-transform | --program-transfor \
 320   | --program-transfo | --program-transf \
 321   | --program-trans | --program-tran \
 322   | --progr-tra | --program-tr | --program-t)
 323     ac_prev=program_transform_name ;;
 324   -program-transform-name=* | --program-transform-name=* \
 325   | --program-transform-nam=* | --program-transform-na=* \
 326   | --program-transform-n=* | --program-transform-=* \
 327   | --program-transform=* | --program-transfor=* \
 328   | --program-transfo=* | --program-transf=* \
 329   | --program-trans=* | --program-tran=* \
 330   | --progr-tra=* | --program-tr=* | --program-t=*)
 331     program_transform_name="$ac_optarg" ;;
 332
 333   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 334   | -silent | --silent | --silen | --sile | --sil)
 335     silent=yes ;;
 336
 337   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 338     ac_prev=sbindir ;;
 339   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 340   | --sbi=* | --sb=*)
 341     sbindir="$ac_optarg" ;;
 342
 343   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 344   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 345   | --sharedst | --shareds | --shared | --share | --shar \
 346   | --sha | --sh)
 347     ac_prev=sharedstatedir ;;
 348   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 349   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 350   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 351   | --sha=* | --sh=*)
 352     sharedstatedir="$ac_optarg" ;;
 353
 354   -site | --site | --sit)
 355     ac_prev=site ;;
 356   -site=* | --site=* | --sit=*)
 357     site="$ac_optarg" ;;
 358
 359   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 360     ac_prev=srcdir ;;
 361   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 362     srcdir="$ac_optarg" ;;
 363
 364   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 365   | --syscon | --sysco | --sysc | --sys | --sy)
 366     ac_prev=sysconfdir ;;
 367   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 368   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 369     sysconfdir="$ac_optarg" ;;
 370
 371   -target | --target | --targe | --targ | --tar | --ta | --t)
 372     ac_prev=target ;;
 373   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 374     target="$ac_optarg" ;;
 375
 376   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 377     verbose=yes ;;
 378
 379   -version | --version | --versio | --versi | --vers)
 380     echo "configure generated by autoconf version 2.13"
 381     exit 0 ;;
 382
 383   -with-* | --with-*)
 384     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 385     # Reject names that are not valid shell variable names.
 386     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 387       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 388     fi
 389     ac_package=`echo $ac_package| sed 's/-/_/g'`
 390     case "$ac_option" in
 391       *=*) ;;
 392       *) ac_optarg=yes ;;
 393     esac
 394     eval "with_${ac_package}='$ac_optarg'" ;;
 395
 396   -without-* | --without-*)
 397     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 398     # Reject names that are not valid shell variable names.
 399     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 400       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 401     fi
 402     ac_package=`echo $ac_package| sed 's/-/_/g'`
 403     eval "with_${ac_package}=no" ;;
 404
 405   --x)
 406     # Obsolete; use --with-x.
 407     with_x=yes ;;
 408
 409   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 410   | --x-incl | --x-inc | --x-in | --x-i)
 411     ac_prev=x_includes ;;
 412   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 413   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 414     x_includes="$ac_optarg" ;;
 415
 416   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 417   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 418     ac_prev=x_libraries ;;
 419   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 420   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 421     x_libraries="$ac_optarg" ;;
 422
 423   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 424     ;;
 425
 426   *)
 427     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 428       echo "configure: warning: $ac_option: invalid host type" 1>&2
 429     fi
 430     if test "x$nonopt" != xNONE; then
 431       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 432     fi
 433     nonopt="$ac_option"
 434     ;;
 435
 436   esac
 437 done
 438
 439 if test -n "$ac_prev"; then
 440   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 441 fi
 442
 443 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 444
 445 # File descriptor usage:
 446 # 0 standard input
 447 # 1 file creation
 448 # 2 errors and warnings
 449 # 3 some systems may open it to /dev/tty
 450 # 4 used on the Kubota Titan
 451 # 6 checking for... messages and results
 452 # 5 compiler messages saved in config.log
 453 if test "$silent" = yes; then
 454   exec 6>/dev/null
 455 else
 456   exec 6>&1
 457 fi
 458 exec 5>./config.log
 459
 460 echo "\
 461 This file contains any messages produced by compilers while
 462 running configure, to aid debugging if configure makes a mistake.
 463 " 1>&5
 464
 465 # Strip out --no-create and --no-recursion so they do not pile up.
 466 # Also quote any args containing shell metacharacters.
 467 ac_configure_args=
 468 for ac_arg
 469 do
 470   case "$ac_arg" in
 471   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 472   | --no-cr | --no-c) ;;
 473   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 474   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 475   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 476   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 477   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 478   esac
 479 done
 480
 481 # NLS nuisances.
 482 # Only set these to C if already set.  These must not be set unconditionally
 483 # because not all systems understand e.g. LANG=C (notably SCO).
 484 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 485 # Non-C LC_CTYPE values break the ctype check.
 486 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 487 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 488 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 489 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 490
 491 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 492 rm -rf conftest* confdefs.h
 493 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 494 echo > confdefs.h
 495
 496 # A filename unique to this package, relative to the directory that
 497 # configure is in, which we can look for to find out if srcdir is correct.
 498 ac_unique_file=src/complex.cc
 499
 500 # Find the source files, if location was not specified.
 501 if test -z "$srcdir"; then
 502   ac_srcdir_defaulted=yes
 503   # Try the directory containing this script, then its parent.
 504   ac_prog=$0
 505   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 506   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 507   srcdir=$ac_confdir
 508   if test ! -r $srcdir/$ac_unique_file; then
 509     srcdir=..
 510   fi
 511 else
 512   ac_srcdir_defaulted=no
 513 fi
 514 if test ! -r $srcdir/$ac_unique_file; then
 515   if test "$ac_srcdir_defaulted" = yes; then
 516     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 517   else
 518     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 519   fi
 520 fi
 521 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 522
 523 # Prefer explicitly selected file to automatically selected ones.
 524 if test -z "$CONFIG_SITE"; then
 525   if test "x$prefix" != xNONE; then
 526     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527   else
 528     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529   fi
 530 fi
 531 for ac_site_file in $CONFIG_SITE; do
 532   if test -r "$ac_site_file"; then
 533     echo "loading site script $ac_site_file"
 534     . "$ac_site_file"
 535   fi
 536 done
 537
 538 if test -r "$cache_file"; then
 539   echo "loading cache $cache_file"
 540   . $cache_file
 541 else
 542   echo "creating cache $cache_file"
 543   > $cache_file
 544 fi
 545
 546 ac_ext=c
 547 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 548 ac_cpp='$CPP $CPPFLAGS'
 549 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 550 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 551 cross_compiling=$ac_cv_prog_cc_cross
 552
 553 ac_exeext=
 554 ac_objext=o
 555 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 556   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 557   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 558     ac_n= ac_c='
 559 ' ac_t='        '
 560   else
 561     ac_n=-n ac_c= ac_t=
 562   fi
 563 else
 564   ac_n= ac_c='\c' ac_t=
 565 fi
 566
 567
 568 ac_aux_dir=
 569 for ac_dir in .. $srcdir/..; do
 570   if test -f $ac_dir/install-sh; then
 571     ac_aux_dir=$ac_dir
 572     ac_install_sh="$ac_aux_dir/install-sh -c"
 573     break
 574   elif test -f $ac_dir/install.sh; then
 575     ac_aux_dir=$ac_dir
 576     ac_install_sh="$ac_aux_dir/install.sh -c"
 577     break
 578   fi
 579 done
 580 if test -z "$ac_aux_dir"; then
 581   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 582 fi
 583 ac_config_guess=$ac_aux_dir/config.guess
 584 ac_config_sub=$ac_aux_dir/config.sub
 585 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 586
 587
 588 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 589
 590 # Do some error checking and defaulting for the host and target type.
 591 # The inputs are:
 592 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 593 #
 594 # The rules are:
 595 # 1. You are not allowed to specify --host, --target, and nonopt at the
 596 #    same time.
 597 # 2. Host defaults to nonopt.
 598 # 3. If nonopt is not specified, then host defaults to the current host,
 599 #    as determined by config.guess.
 600 # 4. Target and build default to nonopt.
 601 # 5. If nonopt is not specified, then target and build default to host.
 602
 603 # The aliases save the names the user supplied, while $host etc.
 604 # will get canonicalized.
 605 case $host---$target---$nonopt in
 606 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 607 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 608 esac
 609
 610
 611 # Make sure we can run config.sub.
 612 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 613 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 614 fi
 615
 616 echo $ac_n "checking host system type""... $ac_c" 1>&6
 617 echo "configure:618: checking host system type" >&5
 618
 619 host_alias=$host
 620 case "$host_alias" in
 621 NONE)
 622   case $nonopt in
 623   NONE)
 624     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 625     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 626     fi ;;
 627   *) host_alias=$nonopt ;;
 628   esac ;;
 629 esac
 630
 631 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 632 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 633 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 634 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 635 echo "$ac_t""$host" 1>&6
 636
 637 echo $ac_n "checking target system type""... $ac_c" 1>&6
 638 echo "configure:639: checking target system type" >&5
 639
 640 target_alias=$target
 641 case "$target_alias" in
 642 NONE)
 643   case $nonopt in
 644   NONE) target_alias=$host_alias ;;
 645   *) target_alias=$nonopt ;;
 646   esac ;;
 647 esac
 648
 649 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 650 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 651 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 652 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 653 echo "$ac_t""$target" 1>&6
 654
 655 echo $ac_n "checking build system type""... $ac_c" 1>&6
 656 echo "configure:657: checking build system type" >&5
 657
 658 build_alias=$build
 659 case "$build_alias" in
 660 NONE)
 661   case $nonopt in
 662   NONE) build_alias=$host_alias ;;
 663   *) build_alias=$nonopt ;;
 664   esac ;;
 665 esac
 666
 667 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 668 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 669 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 670 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 671 echo "$ac_t""$build" 1>&6
 672
 673 test "$host_alias" != "$target_alias" &&
 674   test "$program_prefix$program_suffix$program_transform_name" = \
 675     NONENONEs,x,x, &&
 676   program_prefix=${target_alias}-
 677
 678
 679 # We use these options to decide which functions to include.
 680 # Check whether --with-target-subdir or --without-target-subdir was given.
 681 if test "${with_target_subdir+set}" = set; then
 682   withval="$with_target_subdir"
 683   :
 684 fi
 685
 686 # Check whether --with-cross-host or --without-cross-host was given.
 687 if test "${with_cross_host+set}" = set; then
 688   withval="$with_cross_host"
 689   :
 690 fi
 691
 692
 693 # Find a good install program.  We prefer a C program (faster),
 694 # so one script is as good as another.  But avoid the broken or
 695 # incompatible versions:
 696 # SysV /etc/install, /usr/sbin/install
 697 # SunOS /usr/etc/install
 698 # IRIX /sbin/install
 699 # AIX /bin/install
 700 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 701 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 702 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 703 # ./install, which can be erroneously created by make from ./install.sh.
 704 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 705 echo "configure:706: checking for a BSD compatible install" >&5
 706 if test -z "$INSTALL"; then
 707 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 708   echo $ac_n "(cached) $ac_c" 1>&6
 709 else
 710     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 711   for ac_dir in $PATH; do
 712     # Account for people who put trailing slashes in PATH elements.
 713     case "$ac_dir/" in
 714     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 715     *)
 716       # OSF1 and SCO ODT 3.0 have their own names for install.
 717       # Don't use installbsd from OSF since it installs stuff as root
 718       # by default.
 719       for ac_prog in ginstall scoinst install; do
 720         if test -f $ac_dir/$ac_prog; then
 721           if test $ac_prog = install &&
 722             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 723             # AIX install.  It has an incompatible calling convention.
 724             :
 725           else
 726             ac_cv_path_install="$ac_dir/$ac_prog -c"
 727             break 2
 728           fi
 729         fi
 730       done
 731       ;;
 732     esac
 733   done
 734   IFS="$ac_save_IFS"
 735
 736 fi
 737   if test "${ac_cv_path_install+set}" = set; then
 738     INSTALL="$ac_cv_path_install"
 739   else
 740     # As a last resort, use the slow shell script.  We don't cache a
 741     # path for INSTALL within a source directory, because that will
 742     # break other packages using the cache if that directory is
 743     # removed, or if the path is relative.
 744     INSTALL="$ac_install_sh"
 745   fi
 746 fi
 747 echo "$ac_t""$INSTALL" 1>&6
 748
 749 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 750 # It thinks the first close brace ends the variable substitution.
 751 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 752
 753 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 754
 755 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 756
 757 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 758 echo "configure:759: checking whether build environment is sane" >&5
 759 # Just in case
 760 sleep 1
 761 echo timestamp > conftestfile
 762 # Do `set' in a subshell so we don't clobber the current shell's
 763 # arguments.  Must try -L first in case configure is actually a
 764 # symlink; some systems play weird games with the mod time of symlinks
 765 # (eg FreeBSD returns the mod time of the symlink's containing
 766 # directory).
 767 if (
 768    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 769    if test "$*" = "X"; then
 770       # -L didn't work.
 771       set X `ls -t $srcdir/configure conftestfile`
 772    fi
 773    if test "$*" != "X $srcdir/configure conftestfile" \
 774       && test "$*" != "X conftestfile $srcdir/configure"; then
 775
 776       # If neither matched, then we have a broken ls.  This can happen
 777       # if, for instance, CONFIG_SHELL is bash and it inherits a
 778       # broken ls alias from the environment.  This has actually
 779       # happened.  Such a system could not be considered "sane".
 780       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 781 alias in your environment" 1>&2; exit 1; }
 782    fi
 783
 784    test "$2" = conftestfile
 785    )
 786 then
 787    # Ok.
 788    :
 789 else
 790    { echo "configure: error: newly created file is older than distributed files!
 791 Check your system clock" 1>&2; exit 1; }
 792 fi
 793 rm -f conftest*
 794 echo "$ac_t""yes" 1>&6
 795 if test "$program_transform_name" = s,x,x,; then
 796   program_transform_name=
 797 else
 798   # Double any \ or $.  echo might interpret backslashes.
 799   cat <<\EOF_SED > conftestsed
 800 s,\\,\\\\,g; s,\$,$$,g
 801 EOF_SED
 802   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 803   rm -f conftestsed
 804 fi
 805 test "$program_prefix" != NONE &&
 806   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 807 # Use a double $ so make ignores it.
 808 test "$program_suffix" != NONE &&
 809   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 810
 811 # sed with no file args requires a program.
 812 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 813
 814 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 815 echo "configure:816: checking whether ${MAKE-make} sets \${MAKE}" >&5
 816 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 817 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 818   echo $ac_n "(cached) $ac_c" 1>&6
 819 else
 820   cat > conftestmake <<\EOF
 821 all:
 822         @echo 'ac_maketemp="${MAKE}"'
 823 EOF
 824 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 825 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 826 if test -n "$ac_maketemp"; then
 827   eval ac_cv_prog_make_${ac_make}_set=yes
 828 else
 829   eval ac_cv_prog_make_${ac_make}_set=no
 830 fi
 831 rm -f conftestmake
 832 fi
 833 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 834   echo "$ac_t""yes" 1>&6
 835   SET_MAKE=
 836 else
 837   echo "$ac_t""no" 1>&6
 838   SET_MAKE="MAKE=${MAKE-make}"
 839 fi
 840
 841 if test $host != $build; then
 842   ac_tool_prefix=${host_alias}-
 843 else
 844   ac_tool_prefix=
 845 fi
 846
 847 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 848 echo "configure:849: checking for Cygwin environment" >&5
 849 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 850   echo $ac_n "(cached) $ac_c" 1>&6
 851 else
 852   cat > conftest.$ac_ext <<EOF
 853 #line 854 "configure"
 854 #include "confdefs.h"
 855
 856 int main() {
 857
 858 #ifndef __CYGWIN__
 859 #define __CYGWIN__ __CYGWIN32__
 860 #endif
 861 return __CYGWIN__;
 862 ; return 0; }
 863 EOF
 864 if { (eval echo configure:865: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 865   rm -rf conftest*
 866   ac_cv_cygwin=yes
 867 else
 868   echo "configure: failed program was:" >&5
 869   cat conftest.$ac_ext >&5
 870   rm -rf conftest*
 871   ac_cv_cygwin=no
 872 fi
 873 rm -f conftest*
 874 rm -f conftest*
 875 fi
 876
 877 echo "$ac_t""$ac_cv_cygwin" 1>&6
 878 CYGWIN=
 879 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 880 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 881 echo "configure:882: checking for mingw32 environment" >&5
 882 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 883   echo $ac_n "(cached) $ac_c" 1>&6
 884 else
 885   cat > conftest.$ac_ext <<EOF
 886 #line 887 "configure"
 887 #include "confdefs.h"
 888
 889 int main() {
 890 return __MINGW32__;
 891 ; return 0; }
 892 EOF
 893 if { (eval echo configure:894: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 894   rm -rf conftest*
 895   ac_cv_mingw32=yes
 896 else
 897   echo "configure: failed program was:" >&5
 898   cat conftest.$ac_ext >&5
 899   rm -rf conftest*
 900   ac_cv_mingw32=no
 901 fi
 902 rm -f conftest*
 903 rm -f conftest*
 904 fi
 905
 906 echo "$ac_t""$ac_cv_mingw32" 1>&6
 907 MINGW32=
 908 test "$ac_cv_mingw32" = yes && MINGW32=yes
 909
 910     # Check whether --enable-multilib or --disable-multilib was given.
 911 if test "${enable_multilib+set}" = set; then
 912   enableval="$enable_multilib"
 913   case "${enableval}" in
 914     yes) multilib=yes ;;
 915     no)  multilib=no ;;
 916     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 917    esac
 918 else
 919   multilib=yes
 920 fi
 921
 922       if test "${srcdir}" = "."; then
 923     if test "${with_target_subdir}" != "."; then
 924       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 925     else
 926       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 927     fi
 928   else
 929     glibcpp_basedir="${srcdir}/."
 930   fi
 931
 932
 933
 934 PACKAGE=libstdc++
 935
 936 VERSION=2.90.8
 937
 938 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 939   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 940 fi
 941 cat >> confdefs.h <<EOF
 942 #define PACKAGE "$PACKAGE"
 943 EOF
 944
 945 cat >> confdefs.h <<EOF
 946 #define VERSION "$VERSION"
 947 EOF
 948
 949
 950
 951 missing_dir=`cd $ac_aux_dir && pwd`
 952 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 953 echo "configure:954: checking for working aclocal" >&5
 954 # Run test in a subshell; some versions of sh will print an error if
 955 # an executable is not found, even if stderr is redirected.
 956 # Redirect stdin to placate older versions of autoconf.  Sigh.
 957 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 958    ACLOCAL=aclocal
 959    echo "$ac_t""found" 1>&6
 960 else
 961    ACLOCAL="$missing_dir/missing aclocal"
 962    echo "$ac_t""missing" 1>&6
 963 fi
 964
 965 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 966 echo "configure:967: checking for working autoconf" >&5
 967 # Run test in a subshell; some versions of sh will print an error if
 968 # an executable is not found, even if stderr is redirected.
 969 # Redirect stdin to placate older versions of autoconf.  Sigh.
 970 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 971    AUTOCONF=autoconf
 972    echo "$ac_t""found" 1>&6
 973 else
 974    AUTOCONF="$missing_dir/missing autoconf"
 975    echo "$ac_t""missing" 1>&6
 976 fi
 977
 978 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 979 echo "configure:980: checking for working automake" >&5
 980 # Run test in a subshell; some versions of sh will print an error if
 981 # an executable is not found, even if stderr is redirected.
 982 # Redirect stdin to placate older versions of autoconf.  Sigh.
 983 if (automake --version) < /dev/null > /dev/null 2>&1; then
 984    AUTOMAKE=automake
 985    echo "$ac_t""found" 1>&6
 986 else
 987    AUTOMAKE="$missing_dir/missing automake"
 988    echo "$ac_t""missing" 1>&6
 989 fi
 990
 991 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
 992 echo "configure:993: checking for working autoheader" >&5
 993 # Run test in a subshell; some versions of sh will print an error if
 994 # an executable is not found, even if stderr is redirected.
 995 # Redirect stdin to placate older versions of autoconf.  Sigh.
 996 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
 997    AUTOHEADER=autoheader
 998    echo "$ac_t""found" 1>&6
 999 else
1000    AUTOHEADER="$missing_dir/missing autoheader"
1001    echo "$ac_t""missing" 1>&6
1002 fi
1003
1004 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1005 echo "configure:1006: checking for working makeinfo" >&5
1006 # Run test in a subshell; some versions of sh will print an error if
1007 # an executable is not found, even if stderr is redirected.
1008 # Redirect stdin to placate older versions of autoconf.  Sigh.
1009 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1010    MAKEINFO=makeinfo
1011    echo "$ac_t""found" 1>&6
1012 else
1013    MAKEINFO="$missing_dir/missing makeinfo"
1014    echo "$ac_t""missing" 1>&6
1015 fi
1016
1017
1018
1019   # Never versions of autoconf add an underscore to these functions.
1020   # Prevent future problems ...
1021
1022
1023
1024
1025
1026 #  AC_PROG_CC
1027
1028 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1029 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1030 # are probably using a cross compiler, which will not be able to fully
1031 # link an executable.  This should really be fixed in autoconf
1032 # itself.
1033
1034
1035
1036
1037 # Extract the first word of "gcc", so it can be a program name with args.
1038 set dummy gcc; ac_word=$2
1039 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1040 echo "configure:1041: checking for $ac_word" >&5
1041 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1042   echo $ac_n "(cached) $ac_c" 1>&6
1043 else
1044   if test -n "$CC"; then
1045   ac_cv_prog_CC="$CC" # Let the user override the test.
1046 else
1047   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1048   ac_dummy="$PATH"
1049   for ac_dir in $ac_dummy; do
1050     test -z "$ac_dir" && ac_dir=.
1051     if test -f $ac_dir/$ac_word; then
1052       ac_cv_prog_CC="gcc"
1053       break
1054     fi
1055   done
1056   IFS="$ac_save_ifs"
1057 fi
1058 fi
1059 CC="$ac_cv_prog_CC"
1060 if test -n "$CC"; then
1061   echo "$ac_t""$CC" 1>&6
1062 else
1063   echo "$ac_t""no" 1>&6
1064 fi
1065
1066 if test -z "$CC"; then
1067   # Extract the first word of "cc", so it can be a program name with args.
1068 set dummy cc; ac_word=$2
1069 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1070 echo "configure:1071: checking for $ac_word" >&5
1071 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1072   echo $ac_n "(cached) $ac_c" 1>&6
1073 else
1074   if test -n "$CC"; then
1075   ac_cv_prog_CC="$CC" # Let the user override the test.
1076 else
1077   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1078   ac_prog_rejected=no
1079   ac_dummy="$PATH"
1080   for ac_dir in $ac_dummy; do
1081     test -z "$ac_dir" && ac_dir=.
1082     if test -f $ac_dir/$ac_word; then
1083       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1084         ac_prog_rejected=yes
1085         continue
1086       fi
1087       ac_cv_prog_CC="cc"
1088       break
1089     fi
1090   done
1091   IFS="$ac_save_ifs"
1092 if test $ac_prog_rejected = yes; then
1093   # We found a bogon in the path, so make sure we never use it.
1094   set dummy $ac_cv_prog_CC
1095   shift
1096   if test $# -gt 0; then
1097     # We chose a different compiler from the bogus one.
1098     # However, it has the same basename, so the bogon will be chosen
1099     # first if we set CC to just the basename; use the full file name.
1100     shift
1101     set dummy "$ac_dir/$ac_word" "$@"
1102     shift
1103     ac_cv_prog_CC="$@"
1104   fi
1105 fi
1106 fi
1107 fi
1108 CC="$ac_cv_prog_CC"
1109 if test -n "$CC"; then
1110   echo "$ac_t""$CC" 1>&6
1111 else
1112   echo "$ac_t""no" 1>&6
1113 fi
1114
1115   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1116 fi
1117
1118 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1119 echo "configure:1120: checking whether we are using GNU C" >&5
1120 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1121   echo $ac_n "(cached) $ac_c" 1>&6
1122 else
1123   cat > conftest.c <<EOF
1124 #ifdef __GNUC__
1125   yes;
1126 #endif
1127 EOF
1128 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1129: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1129   ac_cv_prog_gcc=yes
1130 else
1131   ac_cv_prog_gcc=no
1132 fi
1133 fi
1134
1135 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1136
1137 if test $ac_cv_prog_gcc = yes; then
1138   GCC=yes
1139   ac_test_CFLAGS="${CFLAGS+set}"
1140   ac_save_CFLAGS="$CFLAGS"
1141   CFLAGS=
1142   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1143 echo "configure:1144: checking whether ${CC-cc} accepts -g" >&5
1144 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1145   echo $ac_n "(cached) $ac_c" 1>&6
1146 else
1147   echo 'void f(){}' > conftest.c
1148 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1149   ac_cv_prog_cc_g=yes
1150 else
1151   ac_cv_prog_cc_g=no
1152 fi
1153 rm -f conftest*
1154
1155 fi
1156
1157 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1158   if test "$ac_test_CFLAGS" = set; then
1159     CFLAGS="$ac_save_CFLAGS"
1160   elif test $ac_cv_prog_cc_g = yes; then
1161     CFLAGS="-g -O2"
1162   else
1163     CFLAGS="-O2"
1164   fi
1165 else
1166   GCC=
1167   test "${CFLAGS+set}" = set || CFLAGS="-g"
1168 fi
1169
1170
1171 # Can't just call these here as g++ requires libstc++ to be built....
1172 #  AC_PROG_CXX
1173
1174 # Likewise for AC_PROG_CXX.
1175
1176
1177
1178 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1179 # flags that come in CXX while configuring libstdc++.  They're different
1180 # from those used for all other target libraries.  If CXX is set in
1181 # the environment, respect that here.
1182 CXX_libstdcxx=$CXX
1183 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1184 do
1185 # Extract the first word of "$ac_prog", so it can be a program name with args.
1186 set dummy $ac_prog; ac_word=$2
1187 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1188 echo "configure:1189: checking for $ac_word" >&5
1189 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1190   echo $ac_n "(cached) $ac_c" 1>&6
1191 else
1192   if test -n "$CXX_libstdcxx"; then
1193   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1194 else
1195   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1196   ac_dummy="$PATH"
1197   for ac_dir in $ac_dummy; do
1198     test -z "$ac_dir" && ac_dir=.
1199     if test -f $ac_dir/$ac_word; then
1200       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1201       break
1202     fi
1203   done
1204   IFS="$ac_save_ifs"
1205 fi
1206 fi
1207 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1208 if test -n "$CXX_libstdcxx"; then
1209   echo "$ac_t""$CXX_libstdcxx" 1>&6
1210 else
1211   echo "$ac_t""no" 1>&6
1212 fi
1213
1214 test -n "$CXX_libstdcxx" && break
1215 done
1216 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1217
1218 CXX=$CXX_libstdcxx
1219
1220 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1221
1222 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1223 echo "configure:1224: checking whether we are using GNU C++" >&5
1224 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1225   echo $ac_n "(cached) $ac_c" 1>&6
1226 else
1227   cat > conftest.C <<EOF
1228 #ifdef __GNUC__
1229   yes;
1230 #endif
1231 EOF
1232 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1233: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1233   ac_cv_prog_gxx=yes
1234 else
1235   ac_cv_prog_gxx=no
1236 fi
1237 fi
1238
1239 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1240
1241 if test $ac_cv_prog_gxx = yes; then
1242   GXX=yes
1243   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1244   ac_save_CXXFLAGS="$CXXFLAGS"
1245   CXXFLAGS=
1246   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1247 echo "configure:1248: checking whether ${CXX-g++} accepts -g" >&5
1248 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1249   echo $ac_n "(cached) $ac_c" 1>&6
1250 else
1251   echo 'void f(){}' > conftest.cc
1252 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1253   ac_cv_prog_cxx_g=yes
1254 else
1255   ac_cv_prog_cxx_g=no
1256 fi
1257 rm -f conftest*
1258
1259 fi
1260
1261 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1262   if test "$ac_test_CXXFLAGS" = set; then
1263     CXXFLAGS="$ac_save_CXXFLAGS"
1264   elif test $ac_cv_prog_cxx_g = yes; then
1265     CXXFLAGS="-g -O2"
1266   else
1267     CXXFLAGS="-O2"
1268   fi
1269 else
1270   GXX=
1271   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1272 fi
1273
1274
1275   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1276 set dummy ${ac_tool_prefix}as; ac_word=$2
1277 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1278 echo "configure:1279: checking for $ac_word" >&5
1279 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1280   echo $ac_n "(cached) $ac_c" 1>&6
1281 else
1282   if test -n "$AS"; then
1283   ac_cv_prog_AS="$AS" # Let the user override the test.
1284 else
1285   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1286   ac_dummy="$PATH"
1287   for ac_dir in $ac_dummy; do
1288     test -z "$ac_dir" && ac_dir=.
1289     if test -f $ac_dir/$ac_word; then
1290       ac_cv_prog_AS="${ac_tool_prefix}as"
1291       break
1292     fi
1293   done
1294   IFS="$ac_save_ifs"
1295   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1296 fi
1297 fi
1298 AS="$ac_cv_prog_AS"
1299 if test -n "$AS"; then
1300   echo "$ac_t""$AS" 1>&6
1301 else
1302   echo "$ac_t""no" 1>&6
1303 fi
1304
1305
1306
1307   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1308 set dummy ${ac_tool_prefix}ar; ac_word=$2
1309 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1310 echo "configure:1311: checking for $ac_word" >&5
1311 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1312   echo $ac_n "(cached) $ac_c" 1>&6
1313 else
1314   if test -n "$AR"; then
1315   ac_cv_prog_AR="$AR" # Let the user override the test.
1316 else
1317   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1318   ac_dummy="$PATH"
1319   for ac_dir in $ac_dummy; do
1320     test -z "$ac_dir" && ac_dir=.
1321     if test -f $ac_dir/$ac_word; then
1322       ac_cv_prog_AR="${ac_tool_prefix}ar"
1323       break
1324     fi
1325   done
1326   IFS="$ac_save_ifs"
1327   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1328 fi
1329 fi
1330 AR="$ac_cv_prog_AR"
1331 if test -n "$AR"; then
1332   echo "$ac_t""$AR" 1>&6
1333 else
1334   echo "$ac_t""no" 1>&6
1335 fi
1336
1337
1338
1339   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1340 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1341 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1342 echo "configure:1343: checking for $ac_word" >&5
1343 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1344   echo $ac_n "(cached) $ac_c" 1>&6
1345 else
1346   if test -n "$RANLIB"; then
1347   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1348 else
1349   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1350   ac_dummy="$PATH"
1351   for ac_dir in $ac_dummy; do
1352     test -z "$ac_dir" && ac_dir=.
1353     if test -f $ac_dir/$ac_word; then
1354       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1355       break
1356     fi
1357   done
1358   IFS="$ac_save_ifs"
1359 fi
1360 fi
1361 RANLIB="$ac_cv_prog_RANLIB"
1362 if test -n "$RANLIB"; then
1363   echo "$ac_t""$RANLIB" 1>&6
1364 else
1365   echo "$ac_t""no" 1>&6
1366 fi
1367
1368
1369 if test -z "$ac_cv_prog_RANLIB"; then
1370 if test -n "$ac_tool_prefix"; then
1371   # Extract the first word of "ranlib", so it can be a program name with args.
1372 set dummy ranlib; ac_word=$2
1373 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1374 echo "configure:1375: checking for $ac_word" >&5
1375 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1376   echo $ac_n "(cached) $ac_c" 1>&6
1377 else
1378   if test -n "$RANLIB"; then
1379   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1380 else
1381   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1382   ac_dummy="$PATH"
1383   for ac_dir in $ac_dummy; do
1384     test -z "$ac_dir" && ac_dir=.
1385     if test -f $ac_dir/$ac_word; then
1386       ac_cv_prog_RANLIB="ranlib"
1387       break
1388     fi
1389   done
1390   IFS="$ac_save_ifs"
1391   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1392 fi
1393 fi
1394 RANLIB="$ac_cv_prog_RANLIB"
1395 if test -n "$RANLIB"; then
1396   echo "$ac_t""$RANLIB" 1>&6
1397 else
1398   echo "$ac_t""no" 1>&6
1399 fi
1400
1401 else
1402   RANLIB=":"
1403 fi
1404 fi
1405
1406
1407   # Find a good install program.  We prefer a C program (faster),
1408 # so one script is as good as another.  But avoid the broken or
1409 # incompatible versions:
1410 # SysV /etc/install, /usr/sbin/install
1411 # SunOS /usr/etc/install
1412 # IRIX /sbin/install
1413 # AIX /bin/install
1414 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1415 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1416 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1417 # ./install, which can be erroneously created by make from ./install.sh.
1418 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1419 echo "configure:1420: checking for a BSD compatible install" >&5
1420 if test -z "$INSTALL"; then
1421 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1422   echo $ac_n "(cached) $ac_c" 1>&6
1423 else
1424     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1425   for ac_dir in $PATH; do
1426     # Account for people who put trailing slashes in PATH elements.
1427     case "$ac_dir/" in
1428     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1429     *)
1430       # OSF1 and SCO ODT 3.0 have their own names for install.
1431       # Don't use installbsd from OSF since it installs stuff as root
1432       # by default.
1433       for ac_prog in ginstall scoinst install; do
1434         if test -f $ac_dir/$ac_prog; then
1435           if test $ac_prog = install &&
1436             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1437             # AIX install.  It has an incompatible calling convention.
1438             :
1439           else
1440             ac_cv_path_install="$ac_dir/$ac_prog -c"
1441             break 2
1442           fi
1443         fi
1444       done
1445       ;;
1446     esac
1447   done
1448   IFS="$ac_save_IFS"
1449
1450 fi
1451   if test "${ac_cv_path_install+set}" = set; then
1452     INSTALL="$ac_cv_path_install"
1453   else
1454     # As a last resort, use the slow shell script.  We don't cache a
1455     # path for INSTALL within a source directory, because that will
1456     # break other packages using the cache if that directory is
1457     # removed, or if the path is relative.
1458     INSTALL="$ac_install_sh"
1459   fi
1460 fi
1461 echo "$ac_t""$INSTALL" 1>&6
1462
1463 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1464 # It thinks the first close brace ends the variable substitution.
1465 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1466
1467 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1468
1469 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1470
1471
1472   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1473 echo "configure:1474: checking whether to enable maintainer-specific portions of Makefiles" >&5
1474     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1475 if test "${enable_maintainer_mode+set}" = set; then
1476   enableval="$enable_maintainer_mode"
1477   USE_MAINTAINER_MODE=$enableval
1478 else
1479   USE_MAINTAINER_MODE=no
1480 fi
1481
1482   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1483
1484
1485 if test $USE_MAINTAINER_MODE = yes; then
1486   MAINTAINER_MODE_TRUE=
1487   MAINTAINER_MODE_FALSE='#'
1488 else
1489   MAINTAINER_MODE_TRUE='#'
1490   MAINTAINER_MODE_FALSE=
1491 fi
1492   MAINT=$MAINTAINER_MODE_TRUE
1493
1494
1495
1496   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1497   # at least currently, we never actually build a program, so we never
1498   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1499   # fails, because we are probably configuring with a cross compiler
1500   # which cant create executables.  So we include AC_EXEEXT to keep
1501   # automake happy, but we dont execute it, since we dont care about
1502   # the result.
1503   if false; then
1504
1505
1506 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1507 echo "configure:1508: checking for executable suffix" >&5
1508 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1509   echo $ac_n "(cached) $ac_c" 1>&6
1510 else
1511   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1512   ac_cv_exeext=.exe
1513 else
1514   rm -f conftest*
1515   echo 'int main () { return 0; }' > conftest.$ac_ext
1516   ac_cv_exeext=
1517   if { (eval echo configure:1518: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1518     for file in conftest.*; do
1519       case $file in
1520       *.c | *.o | *.obj) ;;
1521       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1522       esac
1523     done
1524   else
1525     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1526   fi
1527   rm -f conftest*
1528   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1529 fi
1530 fi
1531
1532 EXEEXT=""
1533 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1534 echo "$ac_t""${ac_cv_exeext}" 1>&6
1535 ac_exeext=$EXEEXT
1536
1537   fi
1538
1539   # configure.host sets the following important variables
1540   #        glibcpp_cflags    - host specific C compiler flags
1541   #        glibcpp_cxxflags  - host specific C++ compiler flags
1542   glibcpp_cflags=
1543   glibcpp_cxxflags=
1544
1545   . ${glibcpp_basedir}/configure.host
1546
1547   case ${glibcpp_basedir} in
1548     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1549     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1550   esac
1551
1552   GLIBCPP_CFLAGS="${glibcpp_cflags}"
1553   GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1554
1555
1556
1557
1558 # Check whether --enable-shared or --disable-shared was given.
1559 if test "${enable_shared+set}" = set; then
1560   enableval="$enable_shared"
1561   p=${PACKAGE-default}
1562 case "$enableval" in
1563 yes) enable_shared=yes ;;
1564 no) enable_shared=no ;;
1565 *)
1566   enable_shared=no
1567   # Look at the argument we got.  We use all the common list separators.
1568   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1569   for pkg in $enableval; do
1570     if test "X$pkg" = "X$p"; then
1571       enable_shared=yes
1572     fi
1573   done
1574   IFS="$ac_save_ifs"
1575   ;;
1576 esac
1577 else
1578   enable_shared=yes
1579 fi
1580
1581 # Check whether --enable-static or --disable-static was given.
1582 if test "${enable_static+set}" = set; then
1583   enableval="$enable_static"
1584   p=${PACKAGE-default}
1585 case "$enableval" in
1586 yes) enable_static=yes ;;
1587 no) enable_static=no ;;
1588 *)
1589   enable_static=no
1590   # Look at the argument we got.  We use all the common list separators.
1591   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1592   for pkg in $enableval; do
1593     if test "X$pkg" = "X$p"; then
1594       enable_static=yes
1595     fi
1596   done
1597   IFS="$ac_save_ifs"
1598   ;;
1599 esac
1600 else
1601   enable_static=yes
1602 fi
1603
1604 # Check whether --enable-fast-install or --disable-fast-install was given.
1605 if test "${enable_fast_install+set}" = set; then
1606   enableval="$enable_fast_install"
1607   p=${PACKAGE-default}
1608 case "$enableval" in
1609 yes) enable_fast_install=yes ;;
1610 no) enable_fast_install=no ;;
1611 *)
1612   enable_fast_install=no
1613   # Look at the argument we got.  We use all the common list separators.
1614   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1615   for pkg in $enableval; do
1616     if test "X$pkg" = "X$p"; then
1617       enable_fast_install=yes
1618     fi
1619   done
1620   IFS="$ac_save_ifs"
1621   ;;
1622 esac
1623 else
1624   enable_fast_install=yes
1625 fi
1626
1627 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1628 if test "${with_gnu_ld+set}" = set; then
1629   withval="$with_gnu_ld"
1630   test "$withval" = no || with_gnu_ld=yes
1631 else
1632   with_gnu_ld=no
1633 fi
1634
1635 ac_prog=ld
1636 if test "$ac_cv_prog_gcc" = yes; then
1637   # Check if gcc -print-prog-name=ld gives a path.
1638   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1639 echo "configure:1640: checking for ld used by GCC" >&5
1640   case $host in
1641   *-*-mingw*)
1642     # gcc leaves a trailing carriage return which upsets mingw
1643     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
1644   *)
1645     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
1646   esac
1647   case "$ac_prog" in
1648     # Accept absolute paths.
1649     [\\/]* | [A-Za-z]:[\\/]*)
1650       re_direlt='/[^/][^/]*/\.\./'
1651       # Canonicalize the path of ld
1652       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1653       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1654         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1655       done
1656       test -z "$LD" && LD="$ac_prog"
1657       ;;
1658   "")
1659     # If it fails, then pretend we aren't using GCC.
1660     ac_prog=ld
1661     ;;
1662   *)
1663     # If it is relative, then search for the first ld in PATH.
1664     with_gnu_ld=unknown
1665     ;;
1666   esac
1667 elif test "$with_gnu_ld" = yes; then
1668   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1669 echo "configure:1670: checking for GNU ld" >&5
1670 else
1671   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1672 echo "configure:1673: checking for non-GNU ld" >&5
1673 fi
1674 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1675   echo $ac_n "(cached) $ac_c" 1>&6
1676 else
1677   if test -z "$LD"; then
1678   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1679   for ac_dir in $PATH; do
1680     test -z "$ac_dir" && ac_dir=.
1681     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1682       ac_cv_path_LD="$ac_dir/$ac_prog"
1683       # Check to see if the program is GNU ld.  I'd rather use --version,
1684       # but apparently some GNU ld's only accept -v.
1685       # Break only if it was the GNU/non-GNU ld that we prefer.
1686       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1687         test "$with_gnu_ld" != no && break
1688       else
1689         test "$with_gnu_ld" != yes && break
1690       fi
1691     fi
1692   done
1693   IFS="$ac_save_ifs"
1694 else
1695   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1696 fi
1697 fi
1698
1699 LD="$ac_cv_path_LD"
1700 if test -n "$LD"; then
1701   echo "$ac_t""$LD" 1>&6
1702 else
1703   echo "$ac_t""no" 1>&6
1704 fi
1705 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1706 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1707 echo "configure:1708: checking if the linker ($LD) is GNU ld" >&5
1708 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1709   echo $ac_n "(cached) $ac_c" 1>&6
1710 else
1711   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1712 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1713   ac_cv_prog_gnu_ld=yes
1714 else
1715   ac_cv_prog_gnu_ld=no
1716 fi
1717 fi
1718
1719 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1720 with_gnu_ld=$ac_cv_prog_gnu_ld
1721
1722
1723 echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6
1724 echo "configure:1725: checking for $LD option to reload object files" >&5
1725 if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then
1726   echo $ac_n "(cached) $ac_c" 1>&6
1727 else
1728   lt_cv_ld_reload_flag='-r'
1729 fi
1730
1731 echo "$ac_t""$lt_cv_ld_reload_flag" 1>&6
1732 reload_flag=$lt_cv_ld_reload_flag
1733 test -n "$reload_flag" && reload_flag=" $reload_flag"
1734
1735 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1736 echo "configure:1737: checking for BSD-compatible nm" >&5
1737 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1738   echo $ac_n "(cached) $ac_c" 1>&6
1739 else
1740   if test -n "$NM"; then
1741   # Let the user override the test.
1742   ac_cv_path_NM="$NM"
1743 else
1744   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1745   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1746     test -z "$ac_dir" && ac_dir=.
1747     tmp_nm=$ac_dir/${ac_tool_prefix}nm
1748     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
1749       # Check to see if the nm accepts a BSD-compat flag.
1750       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1751       #   nm: unknown option "B" ignored
1752       # Tru64's nm complains that /dev/null is an invalid object file
1753       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
1754         ac_cv_path_NM="$tmp_nm -B"
1755         break
1756       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1757         ac_cv_path_NM="$tmp_nm -p"
1758         break
1759       else
1760         ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
1761         continue # so that we can try to find one that supports BSD flags
1762       fi
1763     fi
1764   done
1765   IFS="$ac_save_ifs"
1766   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1767 fi
1768 fi
1769
1770 NM="$ac_cv_path_NM"
1771 echo "$ac_t""$NM" 1>&6
1772
1773 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1774 echo "configure:1775: checking whether ln -s works" >&5
1775 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1776   echo $ac_n "(cached) $ac_c" 1>&6
1777 else
1778   rm -f conftestdata
1779 if ln -s X conftestdata 2>/dev/null
1780 then
1781   rm -f conftestdata
1782   ac_cv_prog_LN_S="ln -s"
1783 else
1784   ac_cv_prog_LN_S=ln
1785 fi
1786 fi
1787 LN_S="$ac_cv_prog_LN_S"
1788 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1789   echo "$ac_t""yes" 1>&6
1790 else
1791   echo "$ac_t""no" 1>&6
1792 fi
1793
1794 echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6
1795 echo "configure:1796: checking how to recognise dependant libraries" >&5
1796 if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then
1797   echo $ac_n "(cached) $ac_c" 1>&6
1798 else
1799   lt_cv_file_magic_cmd='$MAGIC_CMD'
1800 lt_cv_file_magic_test_file=
1801 lt_cv_deplibs_check_method='unknown'
1802 # Need to set the preceding variable on all platforms that support
1803 # interlibrary dependencies.
1804 # 'none' -- dependencies not supported.
1805 # `unknown' -- same as none, but documents that we really don't know.
1806 # 'pass_all' -- all dependencies passed with no checks.
1807 # 'test_compile' -- check by making test program.
1808 # 'file_magic [regex]' -- check by looking for files in library path
1809 # which responds to the $file_magic_cmd with a given egrep regex.
1810 # If you have `file' or equivalent on your system and you're not sure
1811 # whether `pass_all' will *always* work, you probably want this one.
1812
1813 case "$host_os" in
1814 aix4*)
1815   lt_cv_deplibs_check_method=pass_all
1816   ;;
1817
1818 beos*)
1819   lt_cv_deplibs_check_method=pass_all
1820   ;;
1821
1822 bsdi4*)
1823     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
1824     lt_cv_file_magic_cmd='/usr/bin/file -L'
1825   lt_cv_file_magic_test_file=/shlib/libc.so
1826   ;;
1827
1828 cygwin* | mingw* |pw32*)
1829   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
1830   lt_cv_file_magic_cmd='$OBJDUMP -f'
1831   ;;
1832
1833 freebsd* )
1834   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
1835     case "$host_cpu" in
1836     i*86 )
1837       # Not sure whether the presence of OpenBSD here was a mistake.
1838       # Let's accept both of them until this is cleared up.
1839             lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
1840             lt_cv_file_magic_cmd=/usr/bin/file
1841       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
1842       ;;
1843     esac
1844   else
1845     lt_cv_deplibs_check_method=pass_all
1846   fi
1847   ;;
1848
1849 gnu*)
1850   lt_cv_deplibs_check_method=pass_all
1851   ;;
1852
1853 hpux10.20*)
1854   # TODO:  Does this work for hpux-11 too?
1855   lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9.0-9) shared library'
1856   lt_cv_file_magic_cmd=/usr/bin/file
1857   lt_cv_file_magic_test_file=/usr/lib/libc.sl
1858   ;;
1859
1860 irix5* | irix6*)
1861   case "$host_os" in
1862   irix5*)
1863     # this will be overridden with pass_all, but let us keep it just in case
1864     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
1865     ;;
1866   *)
1867     case "$LD" in
1868     *-32|*"-32 ") libmagic=32-bit;;
1869     *-n32|*"-n32 ") libmagic=N32;;
1870     *-64|*"-64 ") libmagic=64-bit;;
1871     *) libmagic=never-match;;
1872     esac
1873     # this will be overridden with pass_all, but let us keep it just in case
1874         lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
1875         ;;
1876   esac
1877   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
1878   lt_cv_deplibs_check_method=pass_all
1879   ;;
1880
1881 # This must be Linux ELF.
1882 linux-gnu*)
1883   case "$host_cpu" in
1884   alpha* | i*86 | powerpc* | sparc* | ia64* )
1885     lt_cv_deplibs_check_method=pass_all ;;
1886   *)
1887     # glibc up to 2.1.1 does not perform some relocations on ARM
1888         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
1889       esac
1890   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
1891   ;;
1892
1893 netbsd*)
1894   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
1895   else
1896         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
1897         lt_cv_file_magic_cmd='/usr/bin/file -L'
1898     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1899   fi
1900   ;;
1901
1902 osf3* | osf4* | osf5*)
1903   # this will be overridden with pass_all, but let us keep it just in case
1904   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
1905   lt_cv_file_magic_test_file=/shlib/libc.so
1906   lt_cv_deplibs_check_method=pass_all
1907   ;;
1908
1909 sco3.2v5*)
1910   lt_cv_deplibs_check_method=pass_all
1911   ;;
1912
1913 solaris*)
1914   lt_cv_deplibs_check_method=pass_all
1915   lt_cv_file_magic_test_file=/lib/libc.so
1916   ;;
1917
1918 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
1919   case "$host_vendor" in
1920   ncr)
1921     lt_cv_deplibs_check_method=pass_all
1922     ;;
1923   motorola)
1924         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]'
1925         lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1926     ;;
1927   esac
1928   ;;
1929 esac
1930
1931 fi
1932
1933 echo "$ac_t""$lt_cv_deplibs_check_method" 1>&6
1934 file_magic_cmd=$lt_cv_file_magic_cmd
1935 deplibs_check_method=$lt_cv_deplibs_check_method
1936
1937 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
1938 echo "configure:1939: checking for object suffix" >&5
1939 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
1940   echo $ac_n "(cached) $ac_c" 1>&6
1941 else
1942   rm -f conftest*
1943 echo 'int i = 1;' > conftest.$ac_ext
1944 if { (eval echo configure:1945: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1945   for ac_file in conftest.*; do
1946     case $ac_file in
1947     *.c) ;;
1948     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
1949     esac
1950   done
1951 else
1952   { echo "configure: error: installation or configuration problem; compiler does not work" 1>&2; exit 1; }
1953 fi
1954 rm -f conftest*
1955 fi
1956
1957 echo "$ac_t""$ac_cv_objext" 1>&6
1958 OBJEXT=$ac_cv_objext
1959 ac_objext=$ac_cv_objext
1960
1961 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
1962
1963 # Only perform the check for file, if the check method requires it
1964 case "$deplibs_check_method" in
1965 file_magic*)
1966   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
1967     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
1968 echo "configure:1969: checking for ${ac_tool_prefix}file" >&5
1969 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
1970   echo $ac_n "(cached) $ac_c" 1>&6
1971 else
1972   case "$MAGIC_CMD" in
1973   /*)
1974   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
1975   ;;
1976   ?:/*)
1977   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
1978   ;;
1979   *)
1980   ac_save_MAGIC_CMD="$MAGIC_CMD"
1981   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1982   ac_dummy="/usr/bin:$PATH"
1983   for ac_dir in $ac_dummy; do
1984     test -z "$ac_dir" && ac_dir=.
1985     if test -f $ac_dir/${ac_tool_prefix}file; then
1986       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
1987       if test -n "$file_magic_test_file"; then
1988         case "$deplibs_check_method" in
1989         "file_magic "*)
1990           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
1991           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
1992           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
1993             egrep "$file_magic_regex" > /dev/null; then
1994             :
1995           else
1996             cat <<EOF 1>&2
1997
1998 *** Warning: the command libtool uses to detect shared libraries,
1999 *** $file_magic_cmd, produces output that libtool cannot recognize.
2000 *** The result is that libtool may fail to recognize shared libraries
2001 *** as such.  This will affect the creation of libtool libraries that
2002 *** depend on shared libraries, but programs linked with such libtool
2003 *** libraries will work regardless of this problem.  Nevertheless, you
2004 *** may want to report the problem to your system manager and/or to
2005 *** bug-libtool@gnu.org
2006
2007 EOF
2008           fi ;;
2009         esac
2010       fi
2011       break
2012     fi
2013   done
2014   IFS="$ac_save_ifs"
2015   MAGIC_CMD="$ac_save_MAGIC_CMD"
2016   ;;
2017 esac
2018 fi
2019
2020 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2021 if test -n "$MAGIC_CMD"; then
2022   echo "$ac_t""$MAGIC_CMD" 1>&6
2023 else
2024   echo "$ac_t""no" 1>&6
2025 fi
2026
2027 if test -z "$lt_cv_path_MAGIC_CMD"; then
2028   if test -n "$ac_tool_prefix"; then
2029     echo $ac_n "checking for file""... $ac_c" 1>&6
2030 echo "configure:2031: checking for file" >&5
2031 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
2032   echo $ac_n "(cached) $ac_c" 1>&6
2033 else
2034   case "$MAGIC_CMD" in
2035   /*)
2036   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2037   ;;
2038   ?:/*)
2039   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
2040   ;;
2041   *)
2042   ac_save_MAGIC_CMD="$MAGIC_CMD"
2043   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2044   ac_dummy="/usr/bin:$PATH"
2045   for ac_dir in $ac_dummy; do
2046     test -z "$ac_dir" && ac_dir=.
2047     if test -f $ac_dir/file; then
2048       lt_cv_path_MAGIC_CMD="$ac_dir/file"
2049       if test -n "$file_magic_test_file"; then
2050         case "$deplibs_check_method" in
2051         "file_magic "*)
2052           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2053           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2054           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2055             egrep "$file_magic_regex" > /dev/null; then
2056             :
2057           else
2058             cat <<EOF 1>&2
2059
2060 *** Warning: the command libtool uses to detect shared libraries,
2061 *** $file_magic_cmd, produces output that libtool cannot recognize.
2062 *** The result is that libtool may fail to recognize shared libraries
2063 *** as such.  This will affect the creation of libtool libraries that
2064 *** depend on shared libraries, but programs linked with such libtool
2065 *** libraries will work regardless of this problem.  Nevertheless, you
2066 *** may want to report the problem to your system manager and/or to
2067 *** bug-libtool@gnu.org
2068
2069 EOF
2070           fi ;;
2071         esac
2072       fi
2073       break
2074     fi
2075   done
2076   IFS="$ac_save_ifs"
2077   MAGIC_CMD="$ac_save_MAGIC_CMD"
2078   ;;
2079 esac
2080 fi
2081
2082 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2083 if test -n "$MAGIC_CMD"; then
2084   echo "$ac_t""$MAGIC_CMD" 1>&6
2085 else
2086   echo "$ac_t""no" 1>&6
2087 fi
2088
2089   else
2090     MAGIC_CMD=:
2091   fi
2092 fi
2093
2094   fi
2095   ;;
2096 esac
2097
2098 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
2099 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
2100 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2101 echo "configure:2102: checking for $ac_word" >&5
2102 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2103   echo $ac_n "(cached) $ac_c" 1>&6
2104 else
2105   if test -n "$RANLIB"; then
2106   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2107 else
2108   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2109   ac_dummy="$PATH"
2110   for ac_dir in $ac_dummy; do
2111     test -z "$ac_dir" && ac_dir=.
2112     if test -f $ac_dir/$ac_word; then
2113       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
2114       break
2115     fi
2116   done
2117   IFS="$ac_save_ifs"
2118 fi
2119 fi
2120 RANLIB="$ac_cv_prog_RANLIB"
2121 if test -n "$RANLIB"; then
2122   echo "$ac_t""$RANLIB" 1>&6
2123 else
2124   echo "$ac_t""no" 1>&6
2125 fi
2126
2127
2128 if test -z "$ac_cv_prog_RANLIB"; then
2129 if test -n "$ac_tool_prefix"; then
2130   # Extract the first word of "ranlib", so it can be a program name with args.
2131 set dummy ranlib; ac_word=$2
2132 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2133 echo "configure:2134: checking for $ac_word" >&5
2134 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2135   echo $ac_n "(cached) $ac_c" 1>&6
2136 else
2137   if test -n "$RANLIB"; then
2138   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2139 else
2140   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2141   ac_dummy="$PATH"
2142   for ac_dir in $ac_dummy; do
2143     test -z "$ac_dir" && ac_dir=.
2144     if test -f $ac_dir/$ac_word; then
2145       ac_cv_prog_RANLIB="ranlib"
2146       break
2147     fi
2148   done
2149   IFS="$ac_save_ifs"
2150   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
2151 fi
2152 fi
2153 RANLIB="$ac_cv_prog_RANLIB"
2154 if test -n "$RANLIB"; then
2155   echo "$ac_t""$RANLIB" 1>&6
2156 else
2157   echo "$ac_t""no" 1>&6
2158 fi
2159
2160 else
2161   RANLIB=":"
2162 fi
2163 fi
2164
2165 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
2166 set dummy ${ac_tool_prefix}strip; ac_word=$2
2167 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2168 echo "configure:2169: checking for $ac_word" >&5
2169 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2170   echo $ac_n "(cached) $ac_c" 1>&6
2171 else
2172   if test -n "$STRIP"; then
2173   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2174 else
2175   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2176   ac_dummy="$PATH"
2177   for ac_dir in $ac_dummy; do
2178     test -z "$ac_dir" && ac_dir=.
2179     if test -f $ac_dir/$ac_word; then
2180       ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2181       break
2182     fi
2183   done
2184   IFS="$ac_save_ifs"
2185 fi
2186 fi
2187 STRIP="$ac_cv_prog_STRIP"
2188 if test -n "$STRIP"; then
2189   echo "$ac_t""$STRIP" 1>&6
2190 else
2191   echo "$ac_t""no" 1>&6
2192 fi
2193
2194
2195 if test -z "$ac_cv_prog_STRIP"; then
2196 if test -n "$ac_tool_prefix"; then
2197   # Extract the first word of "strip", so it can be a program name with args.
2198 set dummy strip; ac_word=$2
2199 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2200 echo "configure:2201: checking for $ac_word" >&5
2201 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2202   echo $ac_n "(cached) $ac_c" 1>&6
2203 else
2204   if test -n "$STRIP"; then
2205   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2206 else
2207   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2208   ac_dummy="$PATH"
2209   for ac_dir in $ac_dummy; do
2210     test -z "$ac_dir" && ac_dir=.
2211     if test -f $ac_dir/$ac_word; then
2212       ac_cv_prog_STRIP="strip"
2213       break
2214     fi
2215   done
2216   IFS="$ac_save_ifs"
2217   test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP=":"
2218 fi
2219 fi
2220 STRIP="$ac_cv_prog_STRIP"
2221 if test -n "$STRIP"; then
2222   echo "$ac_t""$STRIP" 1>&6
2223 else
2224   echo "$ac_t""no" 1>&6
2225 fi
2226
2227 else
2228   STRIP=":"
2229 fi
2230 fi
2231
2232
2233 # Check for any special flags to pass to ltconfig.
2234 libtool_flags="--cache-file=$cache_file"
2235 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
2236 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
2237 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
2238 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
2239 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
2240 libtool_flags="$libtool_flags --enable-dlopen"
2241
2242 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
2243 if test "${enable_libtool_lock+set}" = set; then
2244   enableval="$enable_libtool_lock"
2245   :
2246 fi
2247
2248 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
2249 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
2250
2251 # Check whether --with-pic or --without-pic was given.
2252 if test "${with_pic+set}" = set; then
2253   withval="$with_pic"
2254   pic_mode="$withval"
2255 else
2256   pic_mode=default
2257 fi
2258
2259 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
2260 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
2261
2262 # Some flags need to be propagated to the compiler or linker for good
2263 # libtool support.
2264 case "$host" in
2265 *-*-irix6*)
2266   # Find out which ABI we are using.
2267   echo '#line 2268 "configure"' > conftest.$ac_ext
2268   if { (eval echo configure:2269: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2269     case "`/usr/bin/file conftest.o`" in
2270     *32-bit*)
2271       LD="${LD-ld} -32"
2272       ;;
2273     *N32*)
2274       LD="${LD-ld} -n32"
2275       ;;
2276     *64-bit*)
2277       LD="${LD-ld} -64"
2278       ;;
2279     esac
2280   fi
2281   rm -rf conftest*
2282   ;;
2283
2284 *-*-sco3.2v5*)
2285   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
2286   SAVE_CFLAGS="$CFLAGS"
2287   CFLAGS="$CFLAGS -belf"
2288   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
2289 echo "configure:2290: checking whether the C compiler needs -belf" >&5
2290 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
2291   echo $ac_n "(cached) $ac_c" 1>&6
2292 else
2293
2294      ac_ext=c
2295 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2296 ac_cpp='$CPP $CPPFLAGS'
2297 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2298 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2299 cross_compiling=$ac_cv_prog_cc_cross
2300
2301      cat > conftest.$ac_ext <<EOF
2302 #line 2303 "configure"
2303 #include "confdefs.h"
2304
2305 int main() {
2306
2307 ; return 0; }
2308 EOF
2309 if { (eval echo configure:2310: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2310   rm -rf conftest*
2311   lt_cv_cc_needs_belf=yes
2312 else
2313   echo "configure: failed program was:" >&5
2314   cat conftest.$ac_ext >&5
2315   rm -rf conftest*
2316   lt_cv_cc_needs_belf=no
2317 fi
2318 rm -f conftest*
2319      ac_ext=c
2320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2321 ac_cpp='$CPP $CPPFLAGS'
2322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2324 cross_compiling=$ac_cv_prog_cc_cross
2325
2326 fi
2327
2328 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
2329   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
2330     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
2331     CFLAGS="$SAVE_CFLAGS"
2332   fi
2333   ;;
2334
2335
2336 esac
2337
2338 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
2339 echo "configure:2340: checking how to run the C++ preprocessor" >&5
2340 if test -z "$CXXCPP"; then
2341 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
2342   echo $ac_n "(cached) $ac_c" 1>&6
2343 else
2344   ac_ext=C
2345 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2346 ac_cpp='$CXXCPP $CPPFLAGS'
2347 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2348 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2349 cross_compiling=$ac_cv_prog_cxx_cross
2350   CXXCPP="${CXX-g++} -E"
2351   cat > conftest.$ac_ext <<EOF
2352 #line 2353 "configure"
2353 #include "confdefs.h"
2354 #include <stdlib.h>
2355 EOF
2356 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2357 { (eval echo configure:2358: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2358 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2359 if test -z "$ac_err"; then
2360   :
2361 else
2362   echo "$ac_err" >&5
2363   echo "configure: failed program was:" >&5
2364   cat conftest.$ac_ext >&5
2365   rm -rf conftest*
2366   CXXCPP=/lib/cpp
2367 fi
2368 rm -f conftest*
2369   ac_cv_prog_CXXCPP="$CXXCPP"
2370 ac_ext=c
2371 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2372 ac_cpp='$CPP $CPPFLAGS'
2373 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2374 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2375 cross_compiling=$ac_cv_prog_cc_cross
2376 fi
2377 fi
2378 CXXCPP="$ac_cv_prog_CXXCPP"
2379 echo "$ac_t""$CXXCPP" 1>&6
2380
2381
2382 # Save cache, so that ltconfig can load it
2383 cat > confcache <<\EOF
2384 # This file is a shell script that caches the results of configure
2385 # tests run on this system so they can be shared between configure
2386 # scripts and configure runs.  It is not useful on other systems.
2387 # If it contains results you don't want to keep, you may remove or edit it.
2388 #
2389 # By default, configure uses ./config.cache as the cache file,
2390 # creating it if it does not exist already.  You can give configure
2391 # the --cache-file=FILE option to use a different cache file; that is
2392 # what configure does when it calls configure scripts in
2393 # subdirectories, so they share the cache.
2394 # Giving --cache-file=/dev/null disables caching, for debugging configure.
2395 # config.status only pays attention to the cache file if you give it the
2396 # --recheck option to rerun configure.
2397 #
2398 EOF
2399 # The following way of writing the cache mishandles newlines in values,
2400 # but we know of no workaround that is simple, portable, and efficient.
2401 # So, don't put newlines in cache variables' values.
2402 # Ultrix sh set writes to stderr and can't be redirected directly,
2403 # and sets the high bit in the cache file unless we assign to the vars.
2404 (set) 2>&1 |
2405   case `(ac_space=' '; set | grep ac_space) 2>&1` in
2406   *ac_space=\ *)
2407     # `set' does not quote correctly, so add quotes (double-quote substitution
2408     # turns \\\\ into \\, and sed turns \\ into \).
2409     sed -n \
2410       -e "s/'/'\\\\''/g" \
2411       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
2412     ;;
2413   *)
2414     # `set' quotes correctly as required by POSIX, so do not add quotes.
2415     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
2416     ;;
2417   esac >> confcache
2418 if cmp -s $cache_file confcache; then
2419   :
2420 else
2421   if test -w $cache_file; then
2422     echo "updating cache $cache_file"
2423     cat confcache > $cache_file
2424   else
2425     echo "not updating unwritable cache $cache_file"
2426   fi
2427 fi
2428 rm -f confcache
2429
2430
2431 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
2432 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
2433 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2434 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2435 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2436 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2437 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
2438 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2439 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
2440 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2441
2442 # Reload cache, that may have been modified by ltconfig
2443 if test -r "$cache_file"; then
2444   echo "loading cache $cache_file"
2445   . $cache_file
2446 else
2447   echo "creating cache $cache_file"
2448   > $cache_file
2449 fi
2450
2451
2452 # This can be used to rebuild libtool when needed
2453 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
2454
2455 # Always use our own libtool.
2456 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2457
2458 # Redirect the config.log output again, so that the ltconfig log is not
2459 # clobbered by the next message.
2460 exec 5>>./config.log
2461
2462
2463
2464
2465 LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh"
2466 lt_save_CC="$CC"
2467 lt_save_CFLAGS="$CFLAGS"
2468 AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \
2469 MAGIC_CMD="$MAGIC_CMD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2470 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2471 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2472 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2473 deplibs_check_method="$deplibs_check_method" \
2474 file_magic_cmd="$file_magic_cmd" \
2475 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \
2476 --build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \
2477 || { echo "configure: error: libtool tag configuration failed" 1>&2; exit 1; }
2478 CC="$lt_save_CC"
2479 CFLAGS="$lt_save_CFLAGS"
2480
2481 # Redirect the config.log output again, so that the ltconfig log is not
2482 # clobbered by the next message.
2483 exec 5>>./config.log
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
2494 echo "configure:2495: checking for GNU make" >&5
2495 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
2496   echo $ac_n "(cached) $ac_c" 1>&6
2497 else
2498   _cv_gnu_make_command='' ;
2499           for a in "${MAKE:-make}" make gmake gnumake ; do
2500                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2501                   then
2502                           _cv_gnu_make_command=$a ;
2503                           break;
2504                   fi
2505           done ;
2506
2507 fi
2508
2509 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
2510   if test  "x$_cv_gnu_make_command" != "x"  ; then
2511           ifGNUmake='' ;
2512   else
2513           ifGNUmake='#' ;
2514   fi
2515
2516
2517   if test "x$_cv_gnu_make_command" = "x"; then
2518     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
2519   fi
2520
2521
2522
2523
2524 # Check for c++ or library specific bits that don't require linking.
2525 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2526 echo "configure:2527: checking how to run the C preprocessor" >&5
2527 # On Suns, sometimes $CPP names a directory.
2528 if test -n "$CPP" && test -d "$CPP"; then
2529   CPP=
2530 fi
2531 if test -z "$CPP"; then
2532 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2533   echo $ac_n "(cached) $ac_c" 1>&6
2534 else
2535     # This must be in double quotes, not single quotes, because CPP may get
2536   # substituted into the Makefile and "${CC-cc}" will confuse make.
2537   CPP="${CC-cc} -E"
2538   # On the NeXT, cc -E runs the code through the compiler's parser,
2539   # not just through cpp.
2540   cat > conftest.$ac_ext <<EOF
2541 #line 2542 "configure"
2542 #include "confdefs.h"
2543 #include <assert.h>
2544 Syntax Error
2545 EOF
2546 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2547 { (eval echo configure:2548: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2548 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2549 if test -z "$ac_err"; then
2550   :
2551 else
2552   echo "$ac_err" >&5
2553   echo "configure: failed program was:" >&5
2554   cat conftest.$ac_ext >&5
2555   rm -rf conftest*
2556   CPP="${CC-cc} -E -traditional-cpp"
2557   cat > conftest.$ac_ext <<EOF
2558 #line 2559 "configure"
2559 #include "confdefs.h"
2560 #include <assert.h>
2561 Syntax Error
2562 EOF
2563 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2564 { (eval echo configure:2565: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2565 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2566 if test -z "$ac_err"; then
2567   :
2568 else
2569   echo "$ac_err" >&5
2570   echo "configure: failed program was:" >&5
2571   cat conftest.$ac_ext >&5
2572   rm -rf conftest*
2573   CPP="${CC-cc} -nologo -E"
2574   cat > conftest.$ac_ext <<EOF
2575 #line 2576 "configure"
2576 #include "confdefs.h"
2577 #include <assert.h>
2578 Syntax Error
2579 EOF
2580 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2581 { (eval echo configure:2582: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2582 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2583 if test -z "$ac_err"; then
2584   :
2585 else
2586   echo "$ac_err" >&5
2587   echo "configure: failed program was:" >&5
2588   cat conftest.$ac_ext >&5
2589   rm -rf conftest*
2590   CPP=/lib/cpp
2591 fi
2592 rm -f conftest*
2593 fi
2594 rm -f conftest*
2595 fi
2596 rm -f conftest*
2597   ac_cv_prog_CPP="$CPP"
2598 fi
2599   CPP="$ac_cv_prog_CPP"
2600 else
2601   ac_cv_prog_CPP="$CPP"
2602 fi
2603 echo "$ac_t""$CPP" 1>&6
2604
2605
2606   # Sanity check that g++ is capable of dealing with v-3.
2607   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2608 echo "configure:2609: checking for g++ that will successfully compile this code" >&5
2609   cat > conftest.$ac_ext <<EOF
2610 #line 2611 "configure"
2611 #include "confdefs.h"
2612
2613   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2614     ok
2615   #endif
2616
2617 EOF
2618 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2619   egrep "ok" >/dev/null 2>&1; then
2620   rm -rf conftest*
2621   gpp_satisfactory=yes
2622 else
2623   rm -rf conftest*
2624   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2625 fi
2626 rm -f conftest*
2627
2628   echo "$ac_t""$gpp_satisfactory" 1>&6
2629
2630
2631     echo $ac_n "checking for cpu config directory""... $ac_c" 1>&6
2632 echo "configure:2633: checking for cpu config directory" >&5
2633 # Currently unused, but could be useful.
2634 #    CPU_FLAGS=
2635     case "${target_cpu}" in
2636       alpha*)
2637         cpu_include_dir="config/cpu/alpha"
2638         ;;
2639       arm*)
2640         cpu_include_dir="config/cpu/arm"
2641         ;;
2642       ia64)
2643         cpu_include_dir="config/cpu/ia64"
2644         ;;
2645       i386)
2646         cpu_include_dir="config/cpu/i386"
2647         ;;
2648       i486 | i586 | i686 | i786)
2649         cpu_include_dir="config/cpu/i486"
2650         ;;
2651       powerpc | rs6000)
2652         cpu_include_dir="config/cpu/powerpc"
2653         ;;
2654       sparc64 | ultrasparc)
2655         cpu_include_dir="config/cpu/sparc/sparc64"
2656         ;;
2657       sparc*)
2658         cpu_include_dir="config/cpu/sparc/sparc32"
2659         ;;
2660       *)
2661         cpu_include_dir="config/cpu/generic"
2662         ;;
2663     esac
2664     echo "$ac_t""$cpu_include_dir" 1>&6
2665
2666
2667     echo $ac_n "checking for OS config directory""... $ac_c" 1>&6
2668 echo "configure:2669: checking for OS config directory" >&5
2669 # Currently unused, but could be useful.
2670 #    OS_FLAGS=
2671     case "${target_os}" in
2672       aix4.[3456789]* | aix[56789]*)
2673         os_include_dir="config/os/aix"
2674         case "$CXX" in
2675           *pthread*)
2676             enable_threads='posix'
2677             ;;
2678           *)
2679             enable_threads='no'
2680             ;;
2681         esac
2682         ;;
2683       aix*)
2684         os_include_dir="config/os/aix"
2685         ;;
2686       bsd* | freebsd*)
2687         os_include_dir="config/os/bsd"
2688         ;;
2689       linux*)
2690         os_include_dir="config/os/gnu-linux"
2691         ;;
2692       irix*)
2693         os_include_dir="config/os/irix"
2694         ;;
2695       solaris2.5*)
2696         os_include_dir="config/os/solaris/solaris2.5"
2697         ;;
2698       solaris2.6*)
2699         os_include_dir="config/os/solaris/solaris2.6"
2700         ;;
2701       solaris2.7* | solaris2.8*)
2702         os_include_dir="config/os/solaris/solaris2.7"
2703         ;;
2704       *)
2705         os_include_dir="config/os/generic"
2706         ;;
2707     esac
2708     echo "$ac_t""$os_include_dir" 1>&6
2709
2710
2711
2712 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2713 # Check whether --enable-debug or --disable-debug was given.
2714 if test "${enable_debug+set}" = set; then
2715   enableval="$enable_debug"
2716   case "${enableval}" in
2717  yes) enable_debug=yes ;;
2718  no)  enable_debug=no ;;
2719  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2720  esac
2721 else
2722   enable_debug=no
2723 fi
2724
2725 case "${enable_debug}" in
2726     yes)
2727         DEBUG_FLAGS='-O0 -ggdb3'
2728         ;;
2729     no)
2730         DEBUG_FLAGS='-g'
2731         ;;
2732 esac
2733
2734
2735 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2736 if test "${enable_c_mbchar+set}" = set; then
2737   enableval="$enable_c_mbchar"
2738   case "$enableval" in
2739  yes) enable_c_mbchar=yes ;;
2740  no)  enable_c_mbchar=no ;;
2741  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2742  esac
2743 else
2744   enable_c_mbchar=yes
2745 fi
2746
2747
2748   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2749 echo "configure:2750: checking for cstdio to use" >&5
2750   # Check whether --enable-cstdio or --disable-cstdio was given.
2751 if test "${enable_cstdio+set}" = set; then
2752   enableval="$enable_cstdio"
2753   if test x$enable_cstdio = xno; then
2754      enable_cstdio=libio
2755   fi
2756 else
2757   enable_cstdio=libio
2758 fi
2759
2760
2761   enable_cstdio_flag=$enable_cstdio
2762
2763     case x${enable_cstdio_flag} in
2764     xlibio | x | xno | xnone | xyes)
2765       # default
2766       CSTDIO_H=config/c_io_libio.h
2767       CSTDIO_CC=config/c_io_libio.cc
2768       echo "$ac_t""libio" 1>&6
2769
2770       # see if we are on a system with libio native (ie, linux)
2771       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2772 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2773 echo "configure:2774: checking for libio.h" >&5
2774 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2775   echo $ac_n "(cached) $ac_c" 1>&6
2776 else
2777   cat > conftest.$ac_ext <<EOF
2778 #line 2779 "configure"
2779 #include "confdefs.h"
2780 #include <libio.h>
2781 EOF
2782 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2783 { (eval echo configure:2784: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2784 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2785 if test -z "$ac_err"; then
2786   rm -rf conftest*
2787   eval "ac_cv_header_$ac_safe=yes"
2788 else
2789   echo "$ac_err" >&5
2790   echo "configure: failed program was:" >&5
2791   cat conftest.$ac_ext >&5
2792   rm -rf conftest*
2793   eval "ac_cv_header_$ac_safe=no"
2794 fi
2795 rm -f conftest*
2796 fi
2797 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2798   echo "$ac_t""yes" 1>&6
2799   has_libio=yes
2800 else
2801   echo "$ac_t""no" 1>&6
2802 has_libio=no
2803 fi
2804
2805
2806       # Need to check and see what version of glibc is being used. If
2807       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2808       # compile most of libio for linux systems.
2809       if test x$has_libio = x"yes"; then
2810         case "$target" in
2811           *-*-linux*)
2812               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2813 echo "configure:2814: checking for glibc version >= 2.2" >&5
2814               cat > conftest.$ac_ext <<EOF
2815 #line 2816 "configure"
2816 #include "confdefs.h"
2817
2818             #include <features.h>
2819               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2820                     ok
2821               #endif
2822
2823 EOF
2824 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2825   egrep "ok" >/dev/null 2>&1; then
2826   rm -rf conftest*
2827   glibc_satisfactory=yes
2828 else
2829   rm -rf conftest*
2830   glibc_satisfactory=no
2831 fi
2832 rm -f conftest*
2833
2834               echo "$ac_t""$glibc_satisfactory" 1>&6
2835             ;;
2836         esac
2837
2838         # XXX at the moment, admit defeat and force the recompilation
2839         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2840         glibc_satisfactory=no
2841
2842         if test x$glibc_satisfactory = x"yes"; then
2843            need_libio=no
2844            need_wlibio=no
2845         else
2846            need_libio=yes
2847            # bkoz XXX need to add checks to enable this
2848            # pme XXX here's a first pass at such a check
2849            if test x$enable_c_mbchar != xno; then
2850               need_wlibio=yes
2851            else
2852               need_wlibio=no
2853            fi
2854         fi
2855
2856       else
2857          # Using libio, but <libio.h> doesn't exist on the target system. . .
2858          need_libio=yes
2859          # bkoz XXX need to add checks to enable this
2860          # pme XXX here's a first pass at such a check
2861          if test x$enable_c_mbchar != xno; then
2862              need_wlibio=yes
2863          else
2864              need_wlibio=no
2865          fi
2866       fi
2867       ;;
2868     xstdio)
2869       CSTDIO_H=config/c_io_stdio.h
2870       CSTDIO_CC=config/c_io_stdio.cc
2871       echo "$ac_t""stdio" 1>&6
2872
2873       need_libio=no
2874       ;;
2875     *)
2876       echo "$enable_cstdio is an unknown io package" 1>&2
2877       exit 1
2878       ;;
2879   esac
2880
2881
2882
2883   # 2000-08-04 bkoz hack
2884   CCODECVT_C=config/c_io_libio_codecvt.c
2885
2886   # 2000-08-04 bkoz hack
2887
2888
2889
2890 if test "$need_libio" = yes; then
2891   GLIBCPP_NEED_LIBIO_TRUE=
2892   GLIBCPP_NEED_LIBIO_FALSE='#'
2893 else
2894   GLIBCPP_NEED_LIBIO_TRUE='#'
2895   GLIBCPP_NEED_LIBIO_FALSE=
2896 fi
2897
2898
2899 if test "$need_wlibio" = yes; then
2900   GLIBCPP_NEED_WLIBIO_TRUE=
2901   GLIBCPP_NEED_WLIBIO_FALSE='#'
2902 else
2903   GLIBCPP_NEED_WLIBIO_TRUE='#'
2904   GLIBCPP_NEED_WLIBIO_FALSE=
2905 fi
2906
2907
2908   # Check whether --enable-long-long or --disable-long-long was given.
2909 if test "${enable_long_long+set}" = set; then
2910   enableval="$enable_long_long"
2911     case "$enableval" in
2912    yes) enable_long_long=yes ;;
2913    no)  enable_long_long=no ;;
2914    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2915    esac
2916 else
2917   enable_long_long=yes
2918 fi
2919
2920   # Check for the existance of functions used if long long is enabled.
2921   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2922 echo "configure:2923: checking for strtoll" >&5
2923 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2924   echo $ac_n "(cached) $ac_c" 1>&6
2925 else
2926   cat > conftest.$ac_ext <<EOF
2927 #line 2928 "configure"
2928 #include "confdefs.h"
2929 /* System header to define __stub macros and hopefully few prototypes,
2930     which can conflict with char strtoll(); below.  */
2931 #include <assert.h>
2932 /* Override any gcc2 internal prototype to avoid an error.  */
2933 /* We use char because int might match the return type of a gcc2
2934     builtin and then its argument prototype would still apply.  */
2935 char strtoll();
2936
2937 int main() {
2938
2939 /* The GNU C library defines this for functions which it implements
2940     to always fail with ENOSYS.  Some functions are actually named
2941     something starting with __ and the normal name is an alias.  */
2942 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2943 choke me
2944 #else
2945 strtoll();
2946 #endif
2947
2948 ; return 0; }
2949 EOF
2950 if { (eval echo configure:2951: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2951   rm -rf conftest*
2952   eval "ac_cv_func_strtoll=yes"
2953 else
2954   echo "configure: failed program was:" >&5
2955   cat conftest.$ac_ext >&5
2956   rm -rf conftest*
2957   eval "ac_cv_func_strtoll=no"
2958 fi
2959 rm -f conftest*
2960 fi
2961
2962 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2963   echo "$ac_t""yes" 1>&6
2964   :
2965 else
2966   echo "$ac_t""no" 1>&6
2967 ac_strtoll=no
2968 fi
2969
2970   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2971 echo "configure:2972: checking for strtoull" >&5
2972 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2973   echo $ac_n "(cached) $ac_c" 1>&6
2974 else
2975   cat > conftest.$ac_ext <<EOF
2976 #line 2977 "configure"
2977 #include "confdefs.h"
2978 /* System header to define __stub macros and hopefully few prototypes,
2979     which can conflict with char strtoull(); below.  */
2980 #include <assert.h>
2981 /* Override any gcc2 internal prototype to avoid an error.  */
2982 /* We use char because int might match the return type of a gcc2
2983     builtin and then its argument prototype would still apply.  */
2984 char strtoull();
2985
2986 int main() {
2987
2988 /* The GNU C library defines this for functions which it implements
2989     to always fail with ENOSYS.  Some functions are actually named
2990     something starting with __ and the normal name is an alias.  */
2991 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2992 choke me
2993 #else
2994 strtoull();
2995 #endif
2996
2997 ; return 0; }
2998 EOF
2999 if { (eval echo configure:3000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3000   rm -rf conftest*
3001   eval "ac_cv_func_strtoull=yes"
3002 else
3003   echo "configure: failed program was:" >&5
3004   cat conftest.$ac_ext >&5
3005   rm -rf conftest*
3006   eval "ac_cv_func_strtoull=no"
3007 fi
3008 rm -f conftest*
3009 fi
3010
3011 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
3012   echo "$ac_t""yes" 1>&6
3013   :
3014 else
3015   echo "$ac_t""no" 1>&6
3016 ac_strtoull=no
3017 fi
3018
3019
3020   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
3021 echo "configure:3022: checking for enabled long long" >&5
3022   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
3023     enable_long_long=no;
3024   fi;
3025   echo "$ac_t""$enable_long_long" 1>&6
3026
3027     if test x"$enable_long_long" = xyes; then
3028     cat >> confdefs.h <<\EOF
3029 #define _GLIBCPP_USE_LONG_LONG 1
3030 EOF
3031
3032   fi
3033
3034 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
3035 echo "configure:3036: checking for enabled cshadow headers" >&5
3036 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
3037 if test "${enable_cshadow_headers+set}" = set; then
3038   enableval="$enable_cshadow_headers"
3039
3040   case "$enableval" in
3041    yes) enable_cshadow_headers=yes
3042         ;;
3043    no)  enable_cshadow_headers=no
3044         ;;
3045    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3046         ;;
3047   esac
3048 else
3049   enable_cshadow_headers=no
3050 fi
3051
3052   echo "$ac_t""$enable_cshadow_headers" 1>&6
3053
3054       case "$enable_cshadow_headers" in
3055     yes)
3056         CSHADOW_FLAGS="-fno-builtin"
3057         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3058         cat >> confdefs.h <<\EOF
3059 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3060 EOF
3061
3062         ;;
3063     no)
3064         CSHADOW_FLAGS=""
3065         C_INCLUDE_DIR='${top_srcdir}/include/c'
3066         ;;
3067   esac
3068
3069
3070
3071
3072
3073 if test "$enable_cshadow_headers" = yes; then
3074   GLIBCPP_USE_CSHADOW_TRUE=
3075   GLIBCPP_USE_CSHADOW_FALSE='#'
3076 else
3077   GLIBCPP_USE_CSHADOW_TRUE='#'
3078   GLIBCPP_USE_CSHADOW_FALSE=
3079 fi
3080
3081
3082       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3083 echo "configure:3084: checking for threads package to use" >&5
3084   # Check whether --enable-threads or --disable-threads was given.
3085 if test "${enable_threads+set}" = set; then
3086   enableval="$enable_threads"
3087   if test x$enable_threads = xno; then
3088     enable_threads=''
3089   fi
3090 else
3091   enable_threads=''
3092 fi
3093
3094
3095   enable_threads_flag=$enable_threads
3096
3097     case x${enable_threads_flag} in
3098         x | xno | xnone)
3099                 # No threads
3100                 target_thread_file='single'
3101                 ;;
3102         xyes)
3103                 # default
3104                 target_thread_file=''
3105                 ;;
3106         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3107         xsolaris | xwin32 | xdce | xvxworks)
3108                 target_thread_file=$enable_threads_flag
3109                 ;;
3110         *)
3111                 echo "$enable_threads is an unknown thread package" 1>&2
3112                 exit 1
3113                 ;;
3114   esac
3115
3116     THREADH=
3117   case "$target_thread_file" in
3118     no | none | single)
3119       THREADH=threads-no.h
3120       ;;
3121     posix | pthreads)
3122       THREADH=threads-posix.h
3123       ;;
3124     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3125       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3126       ;;
3127     *)
3128       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
3129       ;;
3130   esac
3131   echo "$ac_t""$THREADH" 1>&6
3132
3133
3134   if test $THREADH != threads-no.h; then
3135     cat >> confdefs.h <<\EOF
3136 #define _GLIBCPP_USE_THREADS 1
3137 EOF
3138
3139   fi
3140
3141
3142     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3143 echo "configure:3144: checking for atomicity.h" >&5
3144     case "$target" in
3145       *-*-linux* | sparc*-*-*)
3146         ATOMICITYH=$cpu_include_dir
3147         ;;
3148       *-*-aix* | *-*-irix*)
3149         ATOMICITYH=$os_include_dir
3150         ;;
3151       *)
3152         # bit of overkill on this text...
3153         { echo "configure: error: Atomic locking requested, but $enable_threads is an unknown thread package and atomic operations are not present in the CPU" 1>&2; exit 1; }
3154         ;;
3155     esac
3156     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3157
3158
3159 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3160 if test "${enable_cxx_flags+set}" = set; then
3161   enableval="$enable_cxx_flags"
3162   case "x$enableval" in
3163  xyes)
3164         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3165  xno|x)
3166         enable_cxx_flags='' ;;
3167  *)
3168         enable_cxx_flags="$enableval" ;;
3169  esac
3170 else
3171   enable_cxx_flags='none'
3172 fi
3173
3174
3175 if test "$enable_cxx_flags" = "none"; then
3176   enable_cxx_flags='';
3177 fi
3178
3179 if test -n "$enable_cxx_flags"; then
3180     for f in $enable_cxx_flags; do
3181         case "$f" in
3182             -fhonor-std)  ;;
3183             -*)  ;;
3184             *)   # and we're trying to pass /what/ exactly?
3185                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3186         esac
3187     done
3188 fi
3189 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3190
3191
3192
3193
3194 if test -n "$with_cross_host"; then
3195
3196   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3197   # may not work correctly, because the compiler may not be able to
3198   # link executables.
3199
3200   xcompiling=1
3201   NATIVE=no
3202   # If Canadian cross, then don't pick up tools from the build
3203   # directory.
3204   if test "$build" != "$with_cross_host"; then
3205     CANADIAN=yes
3206     NULL_TARGET=yes
3207   else
3208     CANADIAN=no
3209     NULL_TARGET=no
3210   fi
3211
3212   case "$target_alias" in
3213     *-wince-*)
3214         # Configure for Microsoft Windows CE, or whatever they are
3215         # currently calling it.
3216         cat >> confdefs.h <<\EOF
3217 #define HAVE_FLOAT_H 1
3218 EOF
3219
3220
3221         cat >> confdefs.h <<\EOF
3222 #define HAVE__FINITE 1
3223 EOF
3224
3225         cat >> confdefs.h <<\EOF
3226 #define HAVE__ISNAN 1
3227 EOF
3228
3229         cat >> confdefs.h <<\EOF
3230 #define HAVE__COPYSIGN 1
3231 EOF
3232
3233         cat >> confdefs.h <<\EOF
3234 #define HAVE__FPCLASS 1
3235 EOF
3236
3237         cat >> confdefs.h <<\EOF
3238 #define HAVE_MODF 1
3239 EOF
3240
3241
3242         ctype_include_dir="config/os/wince"
3243
3244
3245
3246
3247
3248         cat >> confdefs.h <<\EOF
3249 #define _GLIBCPP_NEED_MBSTATE_T 1
3250 EOF
3251
3252
3253         cat >> confdefs.h <<\EOF
3254 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3255 EOF
3256
3257         cat >> confdefs.h <<\EOF
3258 #define _GLIBCPP_BUGGY_COMPLEX 1
3259 EOF
3260
3261         ;;
3262     *)
3263         # We assume newlib.  This lets us hard-code the functions we know
3264         # we'll have.
3265         cat >> confdefs.h <<\EOF
3266 #define HAVE_FINITE 1
3267 EOF
3268
3269         cat >> confdefs.h <<\EOF
3270 #define HAVE_ISNAN 1
3271 EOF
3272
3273         cat >> confdefs.h <<\EOF
3274 #define HAVE_ISNANF 1
3275 EOF
3276
3277         cat >> confdefs.h <<\EOF
3278 #define HAVE_ISINF 1
3279 EOF
3280
3281         cat >> confdefs.h <<\EOF
3282 #define HAVE_ISINFF 1
3283 EOF
3284
3285
3286         ctype_include_dir="config/os/newlib"
3287
3288
3289
3290
3291         cat >> confdefs.h <<\EOF
3292 #define _GLIBCPP_NEED_MBSTATE_T 1
3293 EOF
3294
3295
3296         cat >> confdefs.h <<\EOF
3297 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3298 EOF
3299
3300         cat >> confdefs.h <<\EOF
3301 #define _GLIBCPP_BUGGY_COMPLEX 1
3302 EOF
3303
3304         # need to check for faster f versions of math functions, ie sinf?
3305         ;;
3306   esac
3307 else
3308
3309   # We are being configured natively. We can do more elaborate tests
3310   # that include AC_TRY_COMPILE now, as the linker is assumed to be
3311   # working.
3312
3313   xcompiling=0
3314   NATIVE=yes
3315   CANADIAN=no
3316   NULL_TARGET=no
3317
3318   # Check for available headers.
3319   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
3320   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
3321 do
3322 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3323 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3324 echo "configure:3325: checking for $ac_hdr" >&5
3325 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3326   echo $ac_n "(cached) $ac_c" 1>&6
3327 else
3328   cat > conftest.$ac_ext <<EOF
3329 #line 3330 "configure"
3330 #include "confdefs.h"
3331 #include <$ac_hdr>
3332 EOF
3333 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3334 { (eval echo configure:3335: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3335 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3336 if test -z "$ac_err"; then
3337   rm -rf conftest*
3338   eval "ac_cv_header_$ac_safe=yes"
3339 else
3340   echo "$ac_err" >&5
3341   echo "configure: failed program was:" >&5
3342   cat conftest.$ac_ext >&5
3343   rm -rf conftest*
3344   eval "ac_cv_header_$ac_safe=no"
3345 fi
3346 rm -f conftest*
3347 fi
3348 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3349   echo "$ac_t""yes" 1>&6
3350     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3351   cat >> confdefs.h <<EOF
3352 #define $ac_tr_hdr 1
3353 EOF
3354
3355 else
3356   echo "$ac_t""no" 1>&6
3357 fi
3358 done
3359
3360
3361
3362   # All these tests are for C++; save the language and the compiler flags.
3363   # The CXXFLAGS thing is suspicious, but based on similar bits
3364   # found in GLIBCPP_CONFIGURE.
3365
3366   ac_ext=C
3367 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3368 ac_cpp='$CXXCPP $CPPFLAGS'
3369 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3370 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3371 cross_compiling=$ac_cv_prog_cxx_cross
3372
3373   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3374   ac_save_CXXFLAGS="$CXXFLAGS"
3375
3376   # Check for maintainer-mode bits.
3377   if test x"$USE_MAINTAINER_MODE" = xno; then
3378     WERROR=''
3379   else
3380     WERROR='-Werror'
3381   fi
3382
3383   # Check for more sophisticated diagnostic control.
3384   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
3385 echo "configure:3386: checking for g++ that supports -fdiagnostics-show-location=once" >&5
3386   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
3387   cat > conftest.$ac_ext <<EOF
3388 #line 3389 "configure"
3389 #include "confdefs.h"
3390
3391 int main() {
3392 int foo;
3393
3394 ; return 0; }
3395 EOF
3396 if { (eval echo configure:3397: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3397   rm -rf conftest*
3398   ac_gabydiags=yes
3399 else
3400   echo "configure: failed program was:" >&5
3401   cat conftest.$ac_ext >&5
3402   rm -rf conftest*
3403   ac_gabydiags=no
3404 fi
3405 rm -f conftest*
3406   if test "$ac_test_CXXFLAGS" = set; then
3407     CXXFLAGS="$ac_save_CXXFLAGS"
3408   else
3409     # this is the suspicious part
3410     CXXFLAGS=''
3411   fi
3412   if test "$ac_gabydiags" = "yes"; then
3413     WFMT_FLAGS='-fdiagnostics-show-location=once'
3414   fi
3415   echo "$ac_t""$ac_gabydiags" 1>&6
3416
3417   # Check for -ffunction-sections -fdata-sections
3418   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
3419 echo "configure:3420: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
3420   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
3421   cat > conftest.$ac_ext <<EOF
3422 #line 3423 "configure"
3423 #include "confdefs.h"
3424
3425 int main() {
3426 int foo;
3427
3428 ; return 0; }
3429 EOF
3430 if { (eval echo configure:3431: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3431   rm -rf conftest*
3432   ac_fdsections=yes
3433 else
3434   echo "configure: failed program was:" >&5
3435   cat conftest.$ac_ext >&5
3436   rm -rf conftest*
3437   ac_fdsections=no
3438 fi
3439 rm -f conftest*
3440   if test "$ac_test_CXXFLAGS" = set; then
3441     CXXFLAGS="$ac_save_CXXFLAGS"
3442   else
3443     # this is the suspicious part
3444     CXXFLAGS=''
3445   fi
3446   if test "$ac_fdsections" = "yes"; then
3447     SECTION_FLAGS='-ffunction-sections -fdata-sections'
3448   fi
3449   echo "$ac_t""$ac_fdsections" 1>&6
3450
3451   ac_ext=c
3452 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3453 ac_cpp='$CPP $CPPFLAGS'
3454 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3455 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3456 cross_compiling=$ac_cv_prog_cc_cross
3457
3458
3459
3460
3461
3462
3463   # If we're not using GNU ld, then there's no point in even trying these
3464   # tests.  Check for that first.  We should have already tested for gld
3465   # by now (in libtool), but require it now just to be safe...
3466   SECTION_LDFLAGS=''
3467   OPT_LDFLAGS=''
3468
3469
3470   # Set --gc-sections.
3471   if test "$ac_cv_prog_gnu_ld" = "broken"; then
3472     # GNU ld it is!  Joy and bunny rabbits!
3473
3474     # All these tests are for C++; save the language and the compiler flags.
3475     # Need to do this so that g++ won't try to link in libstdc++
3476     ac_test_CFLAGS="${CFLAGS+set}"
3477     ac_save_CFLAGS="$CFLAGS"
3478     CFLAGS='-x c++  -Wl,--gc-sections'
3479
3480     # Check for -Wl,--gc-sections
3481     # XXX This test is broken at the moment, as symbols required for
3482     # linking are now in libsupc++ (not built yet.....). In addition,
3483     # this test has cored on solaris in the past. In addition,
3484     # --gc-sections doesn't really work at the moment (keeps on discarding
3485     # used sections, first .eh_frame and now some of the glibc sections for
3486     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3487     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3488 echo "configure:3489: checking for ld that supports -Wl,--gc-sections" >&5
3489     if test "$cross_compiling" = yes; then
3490   ac_sectionLDflags=yes
3491 else
3492   cat > conftest.$ac_ext <<EOF
3493 #line 3494 "configure"
3494 #include "confdefs.h"
3495
3496      int main(void)
3497      {
3498        try { throw 1; }
3499        catch (...) { };
3500        return 0;
3501      }
3502
3503 EOF
3504 if { (eval echo configure:3505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3505 then
3506   ac_sectionLDflags=yes
3507 else
3508   echo "configure: failed program was:" >&5
3509   cat conftest.$ac_ext >&5
3510   rm -fr conftest*
3511   ac_sectionLFflags=no
3512 fi
3513 rm -fr conftest*
3514 fi
3515
3516     if test "$ac_test_CFLAGS" = set; then
3517       CFLAGS="$ac_save_CFLAGS"
3518     else
3519       # this is the suspicious part
3520       CFLAGS=''
3521     fi
3522     if test "$ac_sectionLDflags" = "yes"; then
3523       SECTION_LDFLAGS='-Wl,--gc-sections'
3524     fi
3525     echo "$ac_t""$ac_sectionLDflags" 1>&6
3526   fi
3527
3528   # Set linker optimization flags.
3529   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3530     OPT_LDFLAGS='-Wl,-O1'
3531   fi
3532
3533
3534
3535
3536
3537
3538   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
3539 echo "configure:3540: checking for __builtin_abs declaration" >&5
3540   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
3541   echo $ac_n "(cached) $ac_c" 1>&6
3542 else
3543
3544
3545     ac_ext=C
3546 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3547 ac_cpp='$CXXCPP $CPPFLAGS'
3548 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3549 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3550 cross_compiling=$ac_cv_prog_cxx_cross
3551
3552     cat > conftest.$ac_ext <<EOF
3553 #line 3554 "configure"
3554 #include "confdefs.h"
3555 #include <math.h>
3556 int main() {
3557  __builtin_abs(0);
3558 ; return 0; }
3559 EOF
3560 if { (eval echo configure:3561: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3561   rm -rf conftest*
3562   glibcpp_cv_func___builtin_abs_use=yes
3563 else
3564   echo "configure: failed program was:" >&5
3565   cat conftest.$ac_ext >&5
3566   rm -rf conftest*
3567   glibcpp_cv_func___builtin_abs_use=no
3568 fi
3569 rm -f conftest*
3570     ac_ext=c
3571 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3572 ac_cpp='$CPP $CPPFLAGS'
3573 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3574 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3575 cross_compiling=$ac_cv_prog_cc_cross
3576
3577
3578 fi
3579
3580   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
3581   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
3582     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
3583 echo "configure:3584: checking for __builtin_abs linkage" >&5
3584     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
3585   echo $ac_n "(cached) $ac_c" 1>&6
3586 else
3587
3588       cat > conftest.$ac_ext <<EOF
3589 #line 3590 "configure"
3590 #include "confdefs.h"
3591 #include <math.h>
3592 int main() {
3593  __builtin_abs(0);
3594 ; return 0; }
3595 EOF
3596 if { (eval echo configure:3597: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3597   rm -rf conftest*
3598   glibcpp_cv_func___builtin_abs_link=yes
3599 else
3600   echo "configure: failed program was:" >&5
3601   cat conftest.$ac_ext >&5
3602   rm -rf conftest*
3603   glibcpp_cv_func___builtin_abs_link=no
3604 fi
3605 rm -f conftest*
3606
3607 fi
3608
3609     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
3610     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
3611       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3612       cat >> confdefs.h <<EOF
3613 #define ${ac_tr_func} 1
3614 EOF
3615
3616     fi
3617   fi
3618
3619
3620   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3621 echo "configure:3622: checking for __builtin_fabsf declaration" >&5
3622   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
3623   echo $ac_n "(cached) $ac_c" 1>&6
3624 else
3625
3626
3627     ac_ext=C
3628 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3629 ac_cpp='$CXXCPP $CPPFLAGS'
3630 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3631 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3632 cross_compiling=$ac_cv_prog_cxx_cross
3633
3634     cat > conftest.$ac_ext <<EOF
3635 #line 3636 "configure"
3636 #include "confdefs.h"
3637 #include <math.h>
3638 int main() {
3639  __builtin_fabsf(0);
3640 ; return 0; }
3641 EOF
3642 if { (eval echo configure:3643: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3643   rm -rf conftest*
3644   glibcpp_cv_func___builtin_fabsf_use=yes
3645 else
3646   echo "configure: failed program was:" >&5
3647   cat conftest.$ac_ext >&5
3648   rm -rf conftest*
3649   glibcpp_cv_func___builtin_fabsf_use=no
3650 fi
3651 rm -f conftest*
3652     ac_ext=c
3653 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3654 ac_cpp='$CPP $CPPFLAGS'
3655 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3656 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3657 cross_compiling=$ac_cv_prog_cc_cross
3658
3659
3660 fi
3661
3662   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
3663   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
3664     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3665 echo "configure:3666: checking for __builtin_fabsf linkage" >&5
3666     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
3667   echo $ac_n "(cached) $ac_c" 1>&6
3668 else
3669
3670       cat > conftest.$ac_ext <<EOF
3671 #line 3672 "configure"
3672 #include "confdefs.h"
3673 #include <math.h>
3674 int main() {
3675  __builtin_fabsf(0);
3676 ; return 0; }
3677 EOF
3678 if { (eval echo configure:3679: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3679   rm -rf conftest*
3680   glibcpp_cv_func___builtin_fabsf_link=yes
3681 else
3682   echo "configure: failed program was:" >&5
3683   cat conftest.$ac_ext >&5
3684   rm -rf conftest*
3685   glibcpp_cv_func___builtin_fabsf_link=no
3686 fi
3687 rm -f conftest*
3688
3689 fi
3690
3691     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
3692     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
3693       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3694       cat >> confdefs.h <<EOF
3695 #define ${ac_tr_func} 1
3696 EOF
3697
3698     fi
3699   fi
3700
3701
3702   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3703 echo "configure:3704: checking for __builtin_fabs declaration" >&5
3704   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
3705   echo $ac_n "(cached) $ac_c" 1>&6
3706 else
3707
3708
3709     ac_ext=C
3710 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3711 ac_cpp='$CXXCPP $CPPFLAGS'
3712 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3713 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3714 cross_compiling=$ac_cv_prog_cxx_cross
3715
3716     cat > conftest.$ac_ext <<EOF
3717 #line 3718 "configure"
3718 #include "confdefs.h"
3719 #include <math.h>
3720 int main() {
3721  __builtin_fabs(0);
3722 ; return 0; }
3723 EOF
3724 if { (eval echo configure:3725: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3725   rm -rf conftest*
3726   glibcpp_cv_func___builtin_fabs_use=yes
3727 else
3728   echo "configure: failed program was:" >&5
3729   cat conftest.$ac_ext >&5
3730   rm -rf conftest*
3731   glibcpp_cv_func___builtin_fabs_use=no
3732 fi
3733 rm -f conftest*
3734     ac_ext=c
3735 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3736 ac_cpp='$CPP $CPPFLAGS'
3737 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3738 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3739 cross_compiling=$ac_cv_prog_cc_cross
3740
3741
3742 fi
3743
3744   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
3745   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
3746     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3747 echo "configure:3748: checking for __builtin_fabs linkage" >&5
3748     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
3749   echo $ac_n "(cached) $ac_c" 1>&6
3750 else
3751
3752       cat > conftest.$ac_ext <<EOF
3753 #line 3754 "configure"
3754 #include "confdefs.h"
3755 #include <math.h>
3756 int main() {
3757  __builtin_fabs(0);
3758 ; return 0; }
3759 EOF
3760 if { (eval echo configure:3761: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3761   rm -rf conftest*
3762   glibcpp_cv_func___builtin_fabs_link=yes
3763 else
3764   echo "configure: failed program was:" >&5
3765   cat conftest.$ac_ext >&5
3766   rm -rf conftest*
3767   glibcpp_cv_func___builtin_fabs_link=no
3768 fi
3769 rm -f conftest*
3770
3771 fi
3772
3773     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
3774     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
3775       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3776       cat >> confdefs.h <<EOF
3777 #define ${ac_tr_func} 1
3778 EOF
3779
3780     fi
3781   fi
3782
3783
3784   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3785 echo "configure:3786: checking for __builtin_fabsl declaration" >&5
3786   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
3787   echo $ac_n "(cached) $ac_c" 1>&6
3788 else
3789
3790
3791     ac_ext=C
3792 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3793 ac_cpp='$CXXCPP $CPPFLAGS'
3794 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3795 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3796 cross_compiling=$ac_cv_prog_cxx_cross
3797
3798     cat > conftest.$ac_ext <<EOF
3799 #line 3800 "configure"
3800 #include "confdefs.h"
3801 #include <math.h>
3802 int main() {
3803  __builtin_fabsl(0);
3804 ; return 0; }
3805 EOF
3806 if { (eval echo configure:3807: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3807   rm -rf conftest*
3808   glibcpp_cv_func___builtin_fabsl_use=yes
3809 else
3810   echo "configure: failed program was:" >&5
3811   cat conftest.$ac_ext >&5
3812   rm -rf conftest*
3813   glibcpp_cv_func___builtin_fabsl_use=no
3814 fi
3815 rm -f conftest*
3816     ac_ext=c
3817 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3818 ac_cpp='$CPP $CPPFLAGS'
3819 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3820 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3821 cross_compiling=$ac_cv_prog_cc_cross
3822
3823
3824 fi
3825
3826   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
3827   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
3828     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3829 echo "configure:3830: checking for __builtin_fabsl linkage" >&5
3830     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
3831   echo $ac_n "(cached) $ac_c" 1>&6
3832 else
3833
3834       cat > conftest.$ac_ext <<EOF
3835 #line 3836 "configure"
3836 #include "confdefs.h"
3837 #include <math.h>
3838 int main() {
3839  __builtin_fabsl(0);
3840 ; return 0; }
3841 EOF
3842 if { (eval echo configure:3843: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3843   rm -rf conftest*
3844   glibcpp_cv_func___builtin_fabsl_link=yes
3845 else
3846   echo "configure: failed program was:" >&5
3847   cat conftest.$ac_ext >&5
3848   rm -rf conftest*
3849   glibcpp_cv_func___builtin_fabsl_link=no
3850 fi
3851 rm -f conftest*
3852
3853 fi
3854
3855     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
3856     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
3857       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3858       cat >> confdefs.h <<EOF
3859 #define ${ac_tr_func} 1
3860 EOF
3861
3862     fi
3863   fi
3864
3865
3866   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3867 echo "configure:3868: checking for __builtin_labs declaration" >&5
3868   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
3869   echo $ac_n "(cached) $ac_c" 1>&6
3870 else
3871
3872
3873     ac_ext=C
3874 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3875 ac_cpp='$CXXCPP $CPPFLAGS'
3876 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3877 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3878 cross_compiling=$ac_cv_prog_cxx_cross
3879
3880     cat > conftest.$ac_ext <<EOF
3881 #line 3882 "configure"
3882 #include "confdefs.h"
3883 #include <math.h>
3884 int main() {
3885  __builtin_labs(0);
3886 ; return 0; }
3887 EOF
3888 if { (eval echo configure:3889: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3889   rm -rf conftest*
3890   glibcpp_cv_func___builtin_labs_use=yes
3891 else
3892   echo "configure: failed program was:" >&5
3893   cat conftest.$ac_ext >&5
3894   rm -rf conftest*
3895   glibcpp_cv_func___builtin_labs_use=no
3896 fi
3897 rm -f conftest*
3898     ac_ext=c
3899 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3900 ac_cpp='$CPP $CPPFLAGS'
3901 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3902 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3903 cross_compiling=$ac_cv_prog_cc_cross
3904
3905
3906 fi
3907
3908   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
3909   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
3910     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3911 echo "configure:3912: checking for __builtin_labs linkage" >&5
3912     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
3913   echo $ac_n "(cached) $ac_c" 1>&6
3914 else
3915
3916       cat > conftest.$ac_ext <<EOF
3917 #line 3918 "configure"
3918 #include "confdefs.h"
3919 #include <math.h>
3920 int main() {
3921  __builtin_labs(0);
3922 ; return 0; }
3923 EOF
3924 if { (eval echo configure:3925: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3925   rm -rf conftest*
3926   glibcpp_cv_func___builtin_labs_link=yes
3927 else
3928   echo "configure: failed program was:" >&5
3929   cat conftest.$ac_ext >&5
3930   rm -rf conftest*
3931   glibcpp_cv_func___builtin_labs_link=no
3932 fi
3933 rm -f conftest*
3934
3935 fi
3936
3937     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
3938     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
3939       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3940       cat >> confdefs.h <<EOF
3941 #define ${ac_tr_func} 1
3942 EOF
3943
3944     fi
3945   fi
3946
3947
3948
3949   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3950 echo "configure:3951: checking for __builtin_sqrtf declaration" >&5
3951   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
3952   echo $ac_n "(cached) $ac_c" 1>&6
3953 else
3954
3955
3956     ac_ext=C
3957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3958 ac_cpp='$CXXCPP $CPPFLAGS'
3959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3961 cross_compiling=$ac_cv_prog_cxx_cross
3962
3963     cat > conftest.$ac_ext <<EOF
3964 #line 3965 "configure"
3965 #include "confdefs.h"
3966 #include <math.h>
3967 int main() {
3968  __builtin_sqrtf(0);
3969 ; return 0; }
3970 EOF
3971 if { (eval echo configure:3972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3972   rm -rf conftest*
3973   glibcpp_cv_func___builtin_sqrtf_use=yes
3974 else
3975   echo "configure: failed program was:" >&5
3976   cat conftest.$ac_ext >&5
3977   rm -rf conftest*
3978   glibcpp_cv_func___builtin_sqrtf_use=no
3979 fi
3980 rm -f conftest*
3981     ac_ext=c
3982 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3983 ac_cpp='$CPP $CPPFLAGS'
3984 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3985 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3986 cross_compiling=$ac_cv_prog_cc_cross
3987
3988
3989 fi
3990
3991   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
3992   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
3993     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3994 echo "configure:3995: checking for __builtin_sqrtf linkage" >&5
3995     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
3996   echo $ac_n "(cached) $ac_c" 1>&6
3997 else
3998
3999       cat > conftest.$ac_ext <<EOF
4000 #line 4001 "configure"
4001 #include "confdefs.h"
4002 #include <math.h>
4003 int main() {
4004  __builtin_sqrtf(0);
4005 ; return 0; }
4006 EOF
4007 if { (eval echo configure:4008: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4008   rm -rf conftest*
4009   glibcpp_cv_func___builtin_sqrtf_link=yes
4010 else
4011   echo "configure: failed program was:" >&5
4012   cat conftest.$ac_ext >&5
4013   rm -rf conftest*
4014   glibcpp_cv_func___builtin_sqrtf_link=no
4015 fi
4016 rm -f conftest*
4017
4018 fi
4019
4020     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
4021     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
4022       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4023       cat >> confdefs.h <<EOF
4024 #define ${ac_tr_func} 1
4025 EOF
4026
4027     fi
4028   fi
4029
4030
4031   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
4032 echo "configure:4033: checking for __builtin_fsqrt declaration" >&5
4033   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
4034   echo $ac_n "(cached) $ac_c" 1>&6
4035 else
4036
4037
4038     ac_ext=C
4039 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4040 ac_cpp='$CXXCPP $CPPFLAGS'
4041 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4042 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4043 cross_compiling=$ac_cv_prog_cxx_cross
4044
4045     cat > conftest.$ac_ext <<EOF
4046 #line 4047 "configure"
4047 #include "confdefs.h"
4048 #include <math.h>
4049 int main() {
4050  __builtin_fsqrt(0);
4051 ; return 0; }
4052 EOF
4053 if { (eval echo configure:4054: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4054   rm -rf conftest*
4055   glibcpp_cv_func___builtin_fsqrt_use=yes
4056 else
4057   echo "configure: failed program was:" >&5
4058   cat conftest.$ac_ext >&5
4059   rm -rf conftest*
4060   glibcpp_cv_func___builtin_fsqrt_use=no
4061 fi
4062 rm -f conftest*
4063     ac_ext=c
4064 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4065 ac_cpp='$CPP $CPPFLAGS'
4066 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4067 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4068 cross_compiling=$ac_cv_prog_cc_cross
4069
4070
4071 fi
4072
4073   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
4074   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
4075     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
4076 echo "configure:4077: checking for __builtin_fsqrt linkage" >&5
4077     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
4078   echo $ac_n "(cached) $ac_c" 1>&6
4079 else
4080
4081       cat > conftest.$ac_ext <<EOF
4082 #line 4083 "configure"
4083 #include "confdefs.h"
4084 #include <math.h>
4085 int main() {
4086  __builtin_fsqrt(0);
4087 ; return 0; }
4088 EOF
4089 if { (eval echo configure:4090: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4090   rm -rf conftest*
4091   glibcpp_cv_func___builtin_fsqrt_link=yes
4092 else
4093   echo "configure: failed program was:" >&5
4094   cat conftest.$ac_ext >&5
4095   rm -rf conftest*
4096   glibcpp_cv_func___builtin_fsqrt_link=no
4097 fi
4098 rm -f conftest*
4099
4100 fi
4101
4102     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
4103     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
4104       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4105       cat >> confdefs.h <<EOF
4106 #define ${ac_tr_func} 1
4107 EOF
4108
4109     fi
4110   fi
4111
4112
4113   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
4114 echo "configure:4115: checking for __builtin_sqrtl declaration" >&5
4115   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
4116   echo $ac_n "(cached) $ac_c" 1>&6
4117 else
4118
4119
4120     ac_ext=C
4121 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4122 ac_cpp='$CXXCPP $CPPFLAGS'
4123 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4124 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4125 cross_compiling=$ac_cv_prog_cxx_cross
4126
4127     cat > conftest.$ac_ext <<EOF
4128 #line 4129 "configure"
4129 #include "confdefs.h"
4130 #include <math.h>
4131 int main() {
4132  __builtin_sqrtl(0);
4133 ; return 0; }
4134 EOF
4135 if { (eval echo configure:4136: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4136   rm -rf conftest*
4137   glibcpp_cv_func___builtin_sqrtl_use=yes
4138 else
4139   echo "configure: failed program was:" >&5
4140   cat conftest.$ac_ext >&5
4141   rm -rf conftest*
4142   glibcpp_cv_func___builtin_sqrtl_use=no
4143 fi
4144 rm -f conftest*
4145     ac_ext=c
4146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4147 ac_cpp='$CPP $CPPFLAGS'
4148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4150 cross_compiling=$ac_cv_prog_cc_cross
4151
4152
4153 fi
4154
4155   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
4156   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
4157     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
4158 echo "configure:4159: checking for __builtin_sqrtl linkage" >&5
4159     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
4160   echo $ac_n "(cached) $ac_c" 1>&6
4161 else
4162
4163       cat > conftest.$ac_ext <<EOF
4164 #line 4165 "configure"
4165 #include "confdefs.h"
4166 #include <math.h>
4167 int main() {
4168  __builtin_sqrtl(0);
4169 ; return 0; }
4170 EOF
4171 if { (eval echo configure:4172: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4172   rm -rf conftest*
4173   glibcpp_cv_func___builtin_sqrtl_link=yes
4174 else
4175   echo "configure: failed program was:" >&5
4176   cat conftest.$ac_ext >&5
4177   rm -rf conftest*
4178   glibcpp_cv_func___builtin_sqrtl_link=no
4179 fi
4180 rm -f conftest*
4181
4182 fi
4183
4184     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
4185     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
4186       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4187       cat >> confdefs.h <<EOF
4188 #define ${ac_tr_func} 1
4189 EOF
4190
4191     fi
4192   fi
4193
4194
4195
4196   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
4197 echo "configure:4198: checking for __builtin_sinf declaration" >&5
4198   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
4199   echo $ac_n "(cached) $ac_c" 1>&6
4200 else
4201
4202
4203     ac_ext=C
4204 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4205 ac_cpp='$CXXCPP $CPPFLAGS'
4206 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4207 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4208 cross_compiling=$ac_cv_prog_cxx_cross
4209
4210     cat > conftest.$ac_ext <<EOF
4211 #line 4212 "configure"
4212 #include "confdefs.h"
4213 #include <math.h>
4214 int main() {
4215  __builtin_sinf(0);
4216 ; return 0; }
4217 EOF
4218 if { (eval echo configure:4219: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4219   rm -rf conftest*
4220   glibcpp_cv_func___builtin_sinf_use=yes
4221 else
4222   echo "configure: failed program was:" >&5
4223   cat conftest.$ac_ext >&5
4224   rm -rf conftest*
4225   glibcpp_cv_func___builtin_sinf_use=no
4226 fi
4227 rm -f conftest*
4228     ac_ext=c
4229 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4230 ac_cpp='$CPP $CPPFLAGS'
4231 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4232 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4233 cross_compiling=$ac_cv_prog_cc_cross
4234
4235
4236 fi
4237
4238   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
4239   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
4240     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
4241 echo "configure:4242: checking for __builtin_sinf linkage" >&5
4242     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
4243   echo $ac_n "(cached) $ac_c" 1>&6
4244 else
4245
4246       cat > conftest.$ac_ext <<EOF
4247 #line 4248 "configure"
4248 #include "confdefs.h"
4249 #include <math.h>
4250 int main() {
4251  __builtin_sinf(0);
4252 ; return 0; }
4253 EOF
4254 if { (eval echo configure:4255: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4255   rm -rf conftest*
4256   glibcpp_cv_func___builtin_sinf_link=yes
4257 else
4258   echo "configure: failed program was:" >&5
4259   cat conftest.$ac_ext >&5
4260   rm -rf conftest*
4261   glibcpp_cv_func___builtin_sinf_link=no
4262 fi
4263 rm -f conftest*
4264
4265 fi
4266
4267     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
4268     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
4269       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4270       cat >> confdefs.h <<EOF
4271 #define ${ac_tr_func} 1
4272 EOF
4273
4274     fi
4275   fi
4276
4277
4278   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
4279 echo "configure:4280: checking for __builtin_sin declaration" >&5
4280   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
4281   echo $ac_n "(cached) $ac_c" 1>&6
4282 else
4283
4284
4285     ac_ext=C
4286 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4287 ac_cpp='$CXXCPP $CPPFLAGS'
4288 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4289 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4290 cross_compiling=$ac_cv_prog_cxx_cross
4291
4292     cat > conftest.$ac_ext <<EOF
4293 #line 4294 "configure"
4294 #include "confdefs.h"
4295 #include <math.h>
4296 int main() {
4297  __builtin_sin(0);
4298 ; return 0; }
4299 EOF
4300 if { (eval echo configure:4301: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4301   rm -rf conftest*
4302   glibcpp_cv_func___builtin_sin_use=yes
4303 else
4304   echo "configure: failed program was:" >&5
4305   cat conftest.$ac_ext >&5
4306   rm -rf conftest*
4307   glibcpp_cv_func___builtin_sin_use=no
4308 fi
4309 rm -f conftest*
4310     ac_ext=c
4311 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4312 ac_cpp='$CPP $CPPFLAGS'
4313 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4314 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4315 cross_compiling=$ac_cv_prog_cc_cross
4316
4317
4318 fi
4319
4320   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
4321   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
4322     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
4323 echo "configure:4324: checking for __builtin_sin linkage" >&5
4324     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
4325   echo $ac_n "(cached) $ac_c" 1>&6
4326 else
4327
4328       cat > conftest.$ac_ext <<EOF
4329 #line 4330 "configure"
4330 #include "confdefs.h"
4331 #include <math.h>
4332 int main() {
4333  __builtin_sin(0);
4334 ; return 0; }
4335 EOF
4336 if { (eval echo configure:4337: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4337   rm -rf conftest*
4338   glibcpp_cv_func___builtin_sin_link=yes
4339 else
4340   echo "configure: failed program was:" >&5
4341   cat conftest.$ac_ext >&5
4342   rm -rf conftest*
4343   glibcpp_cv_func___builtin_sin_link=no
4344 fi
4345 rm -f conftest*
4346
4347 fi
4348
4349     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
4350     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
4351       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4352       cat >> confdefs.h <<EOF
4353 #define ${ac_tr_func} 1
4354 EOF
4355
4356     fi
4357   fi
4358
4359
4360   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
4361 echo "configure:4362: checking for __builtin_sinl declaration" >&5
4362   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
4363   echo $ac_n "(cached) $ac_c" 1>&6
4364 else
4365
4366
4367     ac_ext=C
4368 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4369 ac_cpp='$CXXCPP $CPPFLAGS'
4370 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4371 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4372 cross_compiling=$ac_cv_prog_cxx_cross
4373
4374     cat > conftest.$ac_ext <<EOF
4375 #line 4376 "configure"
4376 #include "confdefs.h"
4377 #include <math.h>
4378 int main() {
4379  __builtin_sinl(0);
4380 ; return 0; }
4381 EOF
4382 if { (eval echo configure:4383: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4383   rm -rf conftest*
4384   glibcpp_cv_func___builtin_sinl_use=yes
4385 else
4386   echo "configure: failed program was:" >&5
4387   cat conftest.$ac_ext >&5
4388   rm -rf conftest*
4389   glibcpp_cv_func___builtin_sinl_use=no
4390 fi
4391 rm -f conftest*
4392     ac_ext=c
4393 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4394 ac_cpp='$CPP $CPPFLAGS'
4395 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4396 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4397 cross_compiling=$ac_cv_prog_cc_cross
4398
4399
4400 fi
4401
4402   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
4403   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
4404     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
4405 echo "configure:4406: checking for __builtin_sinl linkage" >&5
4406     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
4407   echo $ac_n "(cached) $ac_c" 1>&6
4408 else
4409
4410       cat > conftest.$ac_ext <<EOF
4411 #line 4412 "configure"
4412 #include "confdefs.h"
4413 #include <math.h>
4414 int main() {
4415  __builtin_sinl(0);
4416 ; return 0; }
4417 EOF
4418 if { (eval echo configure:4419: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4419   rm -rf conftest*
4420   glibcpp_cv_func___builtin_sinl_link=yes
4421 else
4422   echo "configure: failed program was:" >&5
4423   cat conftest.$ac_ext >&5
4424   rm -rf conftest*
4425   glibcpp_cv_func___builtin_sinl_link=no
4426 fi
4427 rm -f conftest*
4428
4429 fi
4430
4431     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
4432     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
4433       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4434       cat >> confdefs.h <<EOF
4435 #define ${ac_tr_func} 1
4436 EOF
4437
4438     fi
4439   fi
4440
4441
4442
4443   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
4444 echo "configure:4445: checking for __builtin_cosf declaration" >&5
4445   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
4446   echo $ac_n "(cached) $ac_c" 1>&6
4447 else
4448
4449
4450     ac_ext=C
4451 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4452 ac_cpp='$CXXCPP $CPPFLAGS'
4453 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4454 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4455 cross_compiling=$ac_cv_prog_cxx_cross
4456
4457     cat > conftest.$ac_ext <<EOF
4458 #line 4459 "configure"
4459 #include "confdefs.h"
4460 #include <math.h>
4461 int main() {
4462  __builtin_cosf(0);
4463 ; return 0; }
4464 EOF
4465 if { (eval echo configure:4466: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4466   rm -rf conftest*
4467   glibcpp_cv_func___builtin_cosf_use=yes
4468 else
4469   echo "configure: failed program was:" >&5
4470   cat conftest.$ac_ext >&5
4471   rm -rf conftest*
4472   glibcpp_cv_func___builtin_cosf_use=no
4473 fi
4474 rm -f conftest*
4475     ac_ext=c
4476 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4477 ac_cpp='$CPP $CPPFLAGS'
4478 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4479 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4480 cross_compiling=$ac_cv_prog_cc_cross
4481
4482
4483 fi
4484
4485   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
4486   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
4487     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
4488 echo "configure:4489: checking for __builtin_cosf linkage" >&5
4489     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
4490   echo $ac_n "(cached) $ac_c" 1>&6
4491 else
4492
4493       cat > conftest.$ac_ext <<EOF
4494 #line 4495 "configure"
4495 #include "confdefs.h"
4496 #include <math.h>
4497 int main() {
4498  __builtin_cosf(0);
4499 ; return 0; }
4500 EOF
4501 if { (eval echo configure:4502: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4502   rm -rf conftest*
4503   glibcpp_cv_func___builtin_cosf_link=yes
4504 else
4505   echo "configure: failed program was:" >&5
4506   cat conftest.$ac_ext >&5
4507   rm -rf conftest*
4508   glibcpp_cv_func___builtin_cosf_link=no
4509 fi
4510 rm -f conftest*
4511
4512 fi
4513
4514     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
4515     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
4516       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4517       cat >> confdefs.h <<EOF
4518 #define ${ac_tr_func} 1
4519 EOF
4520
4521     fi
4522   fi
4523
4524
4525   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
4526 echo "configure:4527: checking for __builtin_cos declaration" >&5
4527   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
4528   echo $ac_n "(cached) $ac_c" 1>&6
4529 else
4530
4531
4532     ac_ext=C
4533 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4534 ac_cpp='$CXXCPP $CPPFLAGS'
4535 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4536 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4537 cross_compiling=$ac_cv_prog_cxx_cross
4538
4539     cat > conftest.$ac_ext <<EOF
4540 #line 4541 "configure"
4541 #include "confdefs.h"
4542 #include <math.h>
4543 int main() {
4544  __builtin_cos(0);
4545 ; return 0; }
4546 EOF
4547 if { (eval echo configure:4548: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4548   rm -rf conftest*
4549   glibcpp_cv_func___builtin_cos_use=yes
4550 else
4551   echo "configure: failed program was:" >&5
4552   cat conftest.$ac_ext >&5
4553   rm -rf conftest*
4554   glibcpp_cv_func___builtin_cos_use=no
4555 fi
4556 rm -f conftest*
4557     ac_ext=c
4558 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4559 ac_cpp='$CPP $CPPFLAGS'
4560 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4561 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4562 cross_compiling=$ac_cv_prog_cc_cross
4563
4564
4565 fi
4566
4567   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
4568   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
4569     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
4570 echo "configure:4571: checking for __builtin_cos linkage" >&5
4571     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
4572   echo $ac_n "(cached) $ac_c" 1>&6
4573 else
4574
4575       cat > conftest.$ac_ext <<EOF
4576 #line 4577 "configure"
4577 #include "confdefs.h"
4578 #include <math.h>
4579 int main() {
4580  __builtin_cos(0);
4581 ; return 0; }
4582 EOF
4583 if { (eval echo configure:4584: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4584   rm -rf conftest*
4585   glibcpp_cv_func___builtin_cos_link=yes
4586 else
4587   echo "configure: failed program was:" >&5
4588   cat conftest.$ac_ext >&5
4589   rm -rf conftest*
4590   glibcpp_cv_func___builtin_cos_link=no
4591 fi
4592 rm -f conftest*
4593
4594 fi
4595
4596     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
4597     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
4598       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4599       cat >> confdefs.h <<EOF
4600 #define ${ac_tr_func} 1
4601 EOF
4602
4603     fi
4604   fi
4605
4606
4607   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
4608 echo "configure:4609: checking for __builtin_cosl declaration" >&5
4609   if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
4610   echo $ac_n "(cached) $ac_c" 1>&6
4611 else
4612
4613
4614     ac_ext=C
4615 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4616 ac_cpp='$CXXCPP $CPPFLAGS'
4617 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4618 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4619 cross_compiling=$ac_cv_prog_cxx_cross
4620
4621     cat > conftest.$ac_ext <<EOF
4622 #line 4623 "configure"
4623 #include "confdefs.h"
4624 #include <math.h>
4625 int main() {
4626  __builtin_cosl(0);
4627 ; return 0; }
4628 EOF
4629 if { (eval echo configure:4630: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4630   rm -rf conftest*
4631   glibcpp_cv_func___builtin_cosl_use=yes
4632 else
4633   echo "configure: failed program was:" >&5
4634   cat conftest.$ac_ext >&5
4635   rm -rf conftest*
4636   glibcpp_cv_func___builtin_cosl_use=no
4637 fi
4638 rm -f conftest*
4639     ac_ext=c
4640 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4641 ac_cpp='$CPP $CPPFLAGS'
4642 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4643 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4644 cross_compiling=$ac_cv_prog_cc_cross
4645
4646
4647 fi
4648
4649   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
4650   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
4651     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
4652 echo "configure:4653: checking for __builtin_cosl linkage" >&5
4653     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
4654   echo $ac_n "(cached) $ac_c" 1>&6
4655 else
4656
4657       cat > conftest.$ac_ext <<EOF
4658 #line 4659 "configure"
4659 #include "confdefs.h"
4660 #include <math.h>
4661 int main() {
4662  __builtin_cosl(0);
4663 ; return 0; }
4664 EOF
4665 if { (eval echo configure:4666: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4666   rm -rf conftest*
4667   glibcpp_cv_func___builtin_cosl_link=yes
4668 else
4669   echo "configure: failed program was:" >&5
4670   cat conftest.$ac_ext >&5
4671   rm -rf conftest*
4672   glibcpp_cv_func___builtin_cosl_link=no
4673 fi
4674 rm -f conftest*
4675
4676 fi
4677
4678     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
4679     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
4680       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4681       cat >> confdefs.h <<EOF
4682 #define ${ac_tr_func} 1
4683 EOF
4684
4685     fi
4686   fi
4687
4688
4689               dummyvar=no
4690   if test x$dummyvar = x"yes"; then
4691     cat >> confdefs.h <<\EOF
4692 #define HAVE___BUILTIN_ABS 1
4693 EOF
4694
4695     cat >> confdefs.h <<\EOF
4696 #define HAVE___BUILTIN_LABS 1
4697 EOF
4698
4699     cat >> confdefs.h <<\EOF
4700 #define HAVE___BUILTIN_COS 1
4701 EOF
4702
4703     cat >> confdefs.h <<\EOF
4704 #define HAVE___BUILTIN_COSF 1
4705 EOF
4706
4707     cat >> confdefs.h <<\EOF
4708 #define HAVE___BUILTIN_COSL 1
4709 EOF
4710
4711     cat >> confdefs.h <<\EOF
4712 #define HAVE___BUILTIN_FABS 1
4713 EOF
4714
4715     cat >> confdefs.h <<\EOF
4716 #define HAVE___BUILTIN_FABSF 1
4717 EOF
4718
4719     cat >> confdefs.h <<\EOF
4720 #define HAVE___BUILTIN_FABSL 1
4721 EOF
4722
4723     cat >> confdefs.h <<\EOF
4724 #define HAVE___BUILTIN_SIN 1
4725 EOF
4726
4727     cat >> confdefs.h <<\EOF
4728 #define HAVE___BUILTIN_SINF 1
4729 EOF
4730
4731     cat >> confdefs.h <<\EOF
4732 #define HAVE___BUILTIN_SINL 1
4733 EOF
4734
4735     cat >> confdefs.h <<\EOF
4736 #define HAVE___BUILTIN_FSQRT 1
4737 EOF
4738
4739     cat >> confdefs.h <<\EOF
4740 #define HAVE___BUILTIN_SQRTF 1
4741 EOF
4742
4743     cat >> confdefs.h <<\EOF
4744 #define HAVE___BUILTIN_SQRTL 1
4745 EOF
4746
4747   fi
4748
4749
4750   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4751   ac_save_CXXFLAGS="$CXXFLAGS"
4752   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
4753
4754     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
4755 echo "configure:4756: checking for sin in -lm" >&5
4756 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
4757 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4758   echo $ac_n "(cached) $ac_c" 1>&6
4759 else
4760   ac_save_LIBS="$LIBS"
4761 LIBS="-lm  $LIBS"
4762 cat > conftest.$ac_ext <<EOF
4763 #line 4764 "configure"
4764 #include "confdefs.h"
4765 /* Override any gcc2 internal prototype to avoid an error.  */
4766 /* We use char because int might match the return type of a gcc2
4767     builtin and then its argument prototype would still apply.  */
4768 char sin();
4769
4770 int main() {
4771 sin()
4772 ; return 0; }
4773 EOF
4774 if { (eval echo configure:4775: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4775   rm -rf conftest*
4776   eval "ac_cv_lib_$ac_lib_var=yes"
4777 else
4778   echo "configure: failed program was:" >&5
4779   cat conftest.$ac_ext >&5
4780   rm -rf conftest*
4781   eval "ac_cv_lib_$ac_lib_var=no"
4782 fi
4783 rm -f conftest*
4784 LIBS="$ac_save_LIBS"
4785
4786 fi
4787 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4788   echo "$ac_t""yes" 1>&6
4789   libm="-lm"
4790 else
4791   echo "$ac_t""no" 1>&6
4792 fi
4793
4794   ac_save_LIBS="$LIBS"
4795   LIBS="$LIBS $libm"
4796
4797
4798   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4799 echo "configure:4800: checking for isinf declaration" >&5
4800   if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
4801   echo $ac_n "(cached) $ac_c" 1>&6
4802 else
4803
4804
4805     ac_ext=C
4806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4807 ac_cpp='$CXXCPP $CPPFLAGS'
4808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4810 cross_compiling=$ac_cv_prog_cxx_cross
4811
4812     cat > conftest.$ac_ext <<EOF
4813 #line 4814 "configure"
4814 #include "confdefs.h"
4815 #include <math.h>
4816 int main() {
4817  isinf(0);
4818 ; return 0; }
4819 EOF
4820 if { (eval echo configure:4821: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4821   rm -rf conftest*
4822   glibcpp_cv_func_isinf_use=yes
4823 else
4824   echo "configure: failed program was:" >&5
4825   cat conftest.$ac_ext >&5
4826   rm -rf conftest*
4827   glibcpp_cv_func_isinf_use=no
4828 fi
4829 rm -f conftest*
4830     ac_ext=c
4831 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4832 ac_cpp='$CPP $CPPFLAGS'
4833 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4834 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4835 cross_compiling=$ac_cv_prog_cc_cross
4836
4837
4838 fi
4839
4840   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
4841   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
4842     for ac_func in isinf
4843 do
4844 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4845 echo "configure:4846: checking for $ac_func" >&5
4846 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4847   echo $ac_n "(cached) $ac_c" 1>&6
4848 else
4849   cat > conftest.$ac_ext <<EOF
4850 #line 4851 "configure"
4851 #include "confdefs.h"
4852 /* System header to define __stub macros and hopefully few prototypes,
4853     which can conflict with char $ac_func(); below.  */
4854 #include <assert.h>
4855 /* Override any gcc2 internal prototype to avoid an error.  */
4856 /* We use char because int might match the return type of a gcc2
4857     builtin and then its argument prototype would still apply.  */
4858 char $ac_func();
4859
4860 int main() {
4861
4862 /* The GNU C library defines this for functions which it implements
4863     to always fail with ENOSYS.  Some functions are actually named
4864     something starting with __ and the normal name is an alias.  */
4865 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4866 choke me
4867 #else
4868 $ac_func();
4869 #endif
4870
4871 ; return 0; }
4872 EOF
4873 if { (eval echo configure:4874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4874   rm -rf conftest*
4875   eval "ac_cv_func_$ac_func=yes"
4876 else
4877   echo "configure: failed program was:" >&5
4878   cat conftest.$ac_ext >&5
4879   rm -rf conftest*
4880   eval "ac_cv_func_$ac_func=no"
4881 fi
4882 rm -f conftest*
4883 fi
4884
4885 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4886   echo "$ac_t""yes" 1>&6
4887     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4888   cat >> confdefs.h <<EOF
4889 #define $ac_tr_func 1
4890 EOF
4891
4892 else
4893   echo "$ac_t""no" 1>&6
4894 fi
4895 done
4896
4897   fi
4898
4899
4900   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4901 echo "configure:4902: checking for isnan declaration" >&5
4902   if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
4903   echo $ac_n "(cached) $ac_c" 1>&6
4904 else
4905
4906
4907     ac_ext=C
4908 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4909 ac_cpp='$CXXCPP $CPPFLAGS'
4910 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4911 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4912 cross_compiling=$ac_cv_prog_cxx_cross
4913
4914     cat > conftest.$ac_ext <<EOF
4915 #line 4916 "configure"
4916 #include "confdefs.h"
4917 #include <math.h>
4918 int main() {
4919  isnan(0);
4920 ; return 0; }
4921 EOF
4922 if { (eval echo configure:4923: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4923   rm -rf conftest*
4924   glibcpp_cv_func_isnan_use=yes
4925 else
4926   echo "configure: failed program was:" >&5
4927   cat conftest.$ac_ext >&5
4928   rm -rf conftest*
4929   glibcpp_cv_func_isnan_use=no
4930 fi
4931 rm -f conftest*
4932     ac_ext=c
4933 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4934 ac_cpp='$CPP $CPPFLAGS'
4935 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4936 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4937 cross_compiling=$ac_cv_prog_cc_cross
4938
4939
4940 fi
4941
4942   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
4943   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
4944     for ac_func in isnan
4945 do
4946 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4947 echo "configure:4948: checking for $ac_func" >&5
4948 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4949   echo $ac_n "(cached) $ac_c" 1>&6
4950 else
4951   cat > conftest.$ac_ext <<EOF
4952 #line 4953 "configure"
4953 #include "confdefs.h"
4954 /* System header to define __stub macros and hopefully few prototypes,
4955     which can conflict with char $ac_func(); below.  */
4956 #include <assert.h>
4957 /* Override any gcc2 internal prototype to avoid an error.  */
4958 /* We use char because int might match the return type of a gcc2
4959     builtin and then its argument prototype would still apply.  */
4960 char $ac_func();
4961
4962 int main() {
4963
4964 /* The GNU C library defines this for functions which it implements
4965     to always fail with ENOSYS.  Some functions are actually named
4966     something starting with __ and the normal name is an alias.  */
4967 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4968 choke me
4969 #else
4970 $ac_func();
4971 #endif
4972
4973 ; return 0; }
4974 EOF
4975 if { (eval echo configure:4976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4976   rm -rf conftest*
4977   eval "ac_cv_func_$ac_func=yes"
4978 else
4979   echo "configure: failed program was:" >&5
4980   cat conftest.$ac_ext >&5
4981   rm -rf conftest*
4982   eval "ac_cv_func_$ac_func=no"
4983 fi
4984 rm -f conftest*
4985 fi
4986
4987 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4988   echo "$ac_t""yes" 1>&6
4989     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4990   cat >> confdefs.h <<EOF
4991 #define $ac_tr_func 1
4992 EOF
4993
4994 else
4995   echo "$ac_t""no" 1>&6
4996 fi
4997 done
4998
4999   fi
5000
5001
5002   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
5003 echo "configure:5004: checking for finite declaration" >&5
5004   if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
5005   echo $ac_n "(cached) $ac_c" 1>&6
5006 else
5007
5008
5009     ac_ext=C
5010 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5011 ac_cpp='$CXXCPP $CPPFLAGS'
5012 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5013 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5014 cross_compiling=$ac_cv_prog_cxx_cross
5015
5016     cat > conftest.$ac_ext <<EOF
5017 #line 5018 "configure"
5018 #include "confdefs.h"
5019 #include <math.h>
5020 int main() {
5021  finite(0);
5022 ; return 0; }
5023 EOF
5024 if { (eval echo configure:5025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5025   rm -rf conftest*
5026   glibcpp_cv_func_finite_use=yes
5027 else
5028   echo "configure: failed program was:" >&5
5029   cat conftest.$ac_ext >&5
5030   rm -rf conftest*
5031   glibcpp_cv_func_finite_use=no
5032 fi
5033 rm -f conftest*
5034     ac_ext=c
5035 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5036 ac_cpp='$CPP $CPPFLAGS'
5037 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5038 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5039 cross_compiling=$ac_cv_prog_cc_cross
5040
5041
5042 fi
5043
5044   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
5045   if test x$glibcpp_cv_func_finite_use = x"yes"; then
5046     for ac_func in finite
5047 do
5048 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5049 echo "configure:5050: checking for $ac_func" >&5
5050 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5051   echo $ac_n "(cached) $ac_c" 1>&6
5052 else
5053   cat > conftest.$ac_ext <<EOF
5054 #line 5055 "configure"
5055 #include "confdefs.h"
5056 /* System header to define __stub macros and hopefully few prototypes,
5057     which can conflict with char $ac_func(); below.  */
5058 #include <assert.h>
5059 /* Override any gcc2 internal prototype to avoid an error.  */
5060 /* We use char because int might match the return type of a gcc2
5061     builtin and then its argument prototype would still apply.  */
5062 char $ac_func();
5063
5064 int main() {
5065
5066 /* The GNU C library defines this for functions which it implements
5067     to always fail with ENOSYS.  Some functions are actually named
5068     something starting with __ and the normal name is an alias.  */
5069 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5070 choke me
5071 #else
5072 $ac_func();
5073 #endif
5074
5075 ; return 0; }
5076 EOF
5077 if { (eval echo configure:5078: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5078   rm -rf conftest*
5079   eval "ac_cv_func_$ac_func=yes"
5080 else
5081   echo "configure: failed program was:" >&5
5082   cat conftest.$ac_ext >&5
5083   rm -rf conftest*
5084   eval "ac_cv_func_$ac_func=no"
5085 fi
5086 rm -f conftest*
5087 fi
5088
5089 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5090   echo "$ac_t""yes" 1>&6
5091     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5092   cat >> confdefs.h <<EOF
5093 #define $ac_tr_func 1
5094 EOF
5095
5096 else
5097   echo "$ac_t""no" 1>&6
5098 fi
5099 done
5100
5101   fi
5102
5103
5104   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
5105 echo "configure:5106: checking for copysign declaration" >&5
5106   if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
5107   echo $ac_n "(cached) $ac_c" 1>&6
5108 else
5109
5110
5111     ac_ext=C
5112 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5113 ac_cpp='$CXXCPP $CPPFLAGS'
5114 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5115 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5116 cross_compiling=$ac_cv_prog_cxx_cross
5117
5118     cat > conftest.$ac_ext <<EOF
5119 #line 5120 "configure"
5120 #include "confdefs.h"
5121 #include <math.h>
5122 int main() {
5123  copysign(0, 0);
5124 ; return 0; }
5125 EOF
5126 if { (eval echo configure:5127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5127   rm -rf conftest*
5128   glibcpp_cv_func_copysign_use=yes
5129 else
5130   echo "configure: failed program was:" >&5
5131   cat conftest.$ac_ext >&5
5132   rm -rf conftest*
5133   glibcpp_cv_func_copysign_use=no
5134 fi
5135 rm -f conftest*
5136     ac_ext=c
5137 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5138 ac_cpp='$CPP $CPPFLAGS'
5139 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5140 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5141 cross_compiling=$ac_cv_prog_cc_cross
5142
5143
5144 fi
5145
5146   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
5147   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
5148     for ac_func in copysign
5149 do
5150 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5151 echo "configure:5152: checking for $ac_func" >&5
5152 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5153   echo $ac_n "(cached) $ac_c" 1>&6
5154 else
5155   cat > conftest.$ac_ext <<EOF
5156 #line 5157 "configure"
5157 #include "confdefs.h"
5158 /* System header to define __stub macros and hopefully few prototypes,
5159     which can conflict with char $ac_func(); below.  */
5160 #include <assert.h>
5161 /* Override any gcc2 internal prototype to avoid an error.  */
5162 /* We use char because int might match the return type of a gcc2
5163     builtin and then its argument prototype would still apply.  */
5164 char $ac_func();
5165
5166 int main() {
5167
5168 /* The GNU C library defines this for functions which it implements
5169     to always fail with ENOSYS.  Some functions are actually named
5170     something starting with __ and the normal name is an alias.  */
5171 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5172 choke me
5173 #else
5174 $ac_func();
5175 #endif
5176
5177 ; return 0; }
5178 EOF
5179 if { (eval echo configure:5180: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5180   rm -rf conftest*
5181   eval "ac_cv_func_$ac_func=yes"
5182 else
5183   echo "configure: failed program was:" >&5
5184   cat conftest.$ac_ext >&5
5185   rm -rf conftest*
5186   eval "ac_cv_func_$ac_func=no"
5187 fi
5188 rm -f conftest*
5189 fi
5190
5191 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5192   echo "$ac_t""yes" 1>&6
5193     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5194   cat >> confdefs.h <<EOF
5195 #define $ac_tr_func 1
5196 EOF
5197
5198 else
5199   echo "$ac_t""no" 1>&6
5200 fi
5201 done
5202
5203   fi
5204
5205
5206   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
5207 echo "configure:5208: checking for sincos declaration" >&5
5208   if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
5209   echo $ac_n "(cached) $ac_c" 1>&6
5210 else
5211
5212
5213     ac_ext=C
5214 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5215 ac_cpp='$CXXCPP $CPPFLAGS'
5216 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5217 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5218 cross_compiling=$ac_cv_prog_cxx_cross
5219
5220     cat > conftest.$ac_ext <<EOF
5221 #line 5222 "configure"
5222 #include "confdefs.h"
5223 #include <math.h>
5224 int main() {
5225  sincos(0, 0, 0);
5226 ; return 0; }
5227 EOF
5228 if { (eval echo configure:5229: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5229   rm -rf conftest*
5230   glibcpp_cv_func_sincos_use=yes
5231 else
5232   echo "configure: failed program was:" >&5
5233   cat conftest.$ac_ext >&5
5234   rm -rf conftest*
5235   glibcpp_cv_func_sincos_use=no
5236 fi
5237 rm -f conftest*
5238     ac_ext=c
5239 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5240 ac_cpp='$CPP $CPPFLAGS'
5241 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5242 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5243 cross_compiling=$ac_cv_prog_cc_cross
5244
5245
5246 fi
5247
5248   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
5249   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
5250     for ac_func in sincos
5251 do
5252 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5253 echo "configure:5254: checking for $ac_func" >&5
5254 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5255   echo $ac_n "(cached) $ac_c" 1>&6
5256 else
5257   cat > conftest.$ac_ext <<EOF
5258 #line 5259 "configure"
5259 #include "confdefs.h"
5260 /* System header to define __stub macros and hopefully few prototypes,
5261     which can conflict with char $ac_func(); below.  */
5262 #include <assert.h>
5263 /* Override any gcc2 internal prototype to avoid an error.  */
5264 /* We use char because int might match the return type of a gcc2
5265     builtin and then its argument prototype would still apply.  */
5266 char $ac_func();
5267
5268 int main() {
5269
5270 /* The GNU C library defines this for functions which it implements
5271     to always fail with ENOSYS.  Some functions are actually named
5272     something starting with __ and the normal name is an alias.  */
5273 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5274 choke me
5275 #else
5276 $ac_func();
5277 #endif
5278
5279 ; return 0; }
5280 EOF
5281 if { (eval echo configure:5282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5282   rm -rf conftest*
5283   eval "ac_cv_func_$ac_func=yes"
5284 else
5285   echo "configure: failed program was:" >&5
5286   cat conftest.$ac_ext >&5
5287   rm -rf conftest*
5288   eval "ac_cv_func_$ac_func=no"
5289 fi
5290 rm -f conftest*
5291 fi
5292
5293 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5294   echo "$ac_t""yes" 1>&6
5295     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5296   cat >> confdefs.h <<EOF
5297 #define $ac_tr_func 1
5298 EOF
5299
5300 else
5301   echo "$ac_t""no" 1>&6
5302 fi
5303 done
5304
5305   fi
5306
5307
5308   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
5309 echo "configure:5310: checking for fpclass declaration" >&5
5310   if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
5311   echo $ac_n "(cached) $ac_c" 1>&6
5312 else
5313
5314
5315     ac_ext=C
5316 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5317 ac_cpp='$CXXCPP $CPPFLAGS'
5318 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5319 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5320 cross_compiling=$ac_cv_prog_cxx_cross
5321
5322     cat > conftest.$ac_ext <<EOF
5323 #line 5324 "configure"
5324 #include "confdefs.h"
5325 #include <math.h>
5326 int main() {
5327  fpclass(0);
5328 ; return 0; }
5329 EOF
5330 if { (eval echo configure:5331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5331   rm -rf conftest*
5332   glibcpp_cv_func_fpclass_use=yes
5333 else
5334   echo "configure: failed program was:" >&5
5335   cat conftest.$ac_ext >&5
5336   rm -rf conftest*
5337   glibcpp_cv_func_fpclass_use=no
5338 fi
5339 rm -f conftest*
5340     ac_ext=c
5341 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5342 ac_cpp='$CPP $CPPFLAGS'
5343 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5344 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5345 cross_compiling=$ac_cv_prog_cc_cross
5346
5347
5348 fi
5349
5350   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
5351   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
5352     for ac_func in fpclass
5353 do
5354 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5355 echo "configure:5356: checking for $ac_func" >&5
5356 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5357   echo $ac_n "(cached) $ac_c" 1>&6
5358 else
5359   cat > conftest.$ac_ext <<EOF
5360 #line 5361 "configure"
5361 #include "confdefs.h"
5362 /* System header to define __stub macros and hopefully few prototypes,
5363     which can conflict with char $ac_func(); below.  */
5364 #include <assert.h>
5365 /* Override any gcc2 internal prototype to avoid an error.  */
5366 /* We use char because int might match the return type of a gcc2
5367     builtin and then its argument prototype would still apply.  */
5368 char $ac_func();
5369
5370 int main() {
5371
5372 /* The GNU C library defines this for functions which it implements
5373     to always fail with ENOSYS.  Some functions are actually named
5374     something starting with __ and the normal name is an alias.  */
5375 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5376 choke me
5377 #else
5378 $ac_func();
5379 #endif
5380
5381 ; return 0; }
5382 EOF
5383 if { (eval echo configure:5384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5384   rm -rf conftest*
5385   eval "ac_cv_func_$ac_func=yes"
5386 else
5387   echo "configure: failed program was:" >&5
5388   cat conftest.$ac_ext >&5
5389   rm -rf conftest*
5390   eval "ac_cv_func_$ac_func=no"
5391 fi
5392 rm -f conftest*
5393 fi
5394
5395 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5396   echo "$ac_t""yes" 1>&6
5397     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5398   cat >> confdefs.h <<EOF
5399 #define $ac_tr_func 1
5400 EOF
5401
5402 else
5403   echo "$ac_t""no" 1>&6
5404 fi
5405 done
5406
5407   fi
5408
5409
5410   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
5411 echo "configure:5412: checking for qfpclass declaration" >&5
5412   if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
5413   echo $ac_n "(cached) $ac_c" 1>&6
5414 else
5415
5416
5417     ac_ext=C
5418 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5419 ac_cpp='$CXXCPP $CPPFLAGS'
5420 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5421 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5422 cross_compiling=$ac_cv_prog_cxx_cross
5423
5424     cat > conftest.$ac_ext <<EOF
5425 #line 5426 "configure"
5426 #include "confdefs.h"
5427 #include <math.h>
5428 int main() {
5429  qfpclass(0);
5430 ; return 0; }
5431 EOF
5432 if { (eval echo configure:5433: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5433   rm -rf conftest*
5434   glibcpp_cv_func_qfpclass_use=yes
5435 else
5436   echo "configure: failed program was:" >&5
5437   cat conftest.$ac_ext >&5
5438   rm -rf conftest*
5439   glibcpp_cv_func_qfpclass_use=no
5440 fi
5441 rm -f conftest*
5442     ac_ext=c
5443 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5444 ac_cpp='$CPP $CPPFLAGS'
5445 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5446 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5447 cross_compiling=$ac_cv_prog_cc_cross
5448
5449
5450 fi
5451
5452   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
5453   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
5454     for ac_func in qfpclass
5455 do
5456 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5457 echo "configure:5458: checking for $ac_func" >&5
5458 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5459   echo $ac_n "(cached) $ac_c" 1>&6
5460 else
5461   cat > conftest.$ac_ext <<EOF
5462 #line 5463 "configure"
5463 #include "confdefs.h"
5464 /* System header to define __stub macros and hopefully few prototypes,
5465     which can conflict with char $ac_func(); below.  */
5466 #include <assert.h>
5467 /* Override any gcc2 internal prototype to avoid an error.  */
5468 /* We use char because int might match the return type of a gcc2
5469     builtin and then its argument prototype would still apply.  */
5470 char $ac_func();
5471
5472 int main() {
5473
5474 /* The GNU C library defines this for functions which it implements
5475     to always fail with ENOSYS.  Some functions are actually named
5476     something starting with __ and the normal name is an alias.  */
5477 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5478 choke me
5479 #else
5480 $ac_func();
5481 #endif
5482
5483 ; return 0; }
5484 EOF
5485 if { (eval echo configure:5486: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5486   rm -rf conftest*
5487   eval "ac_cv_func_$ac_func=yes"
5488 else
5489   echo "configure: failed program was:" >&5
5490   cat conftest.$ac_ext >&5
5491   rm -rf conftest*
5492   eval "ac_cv_func_$ac_func=no"
5493 fi
5494 rm -f conftest*
5495 fi
5496
5497 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5498   echo "$ac_t""yes" 1>&6
5499     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5500   cat >> confdefs.h <<EOF
5501 #define $ac_tr_func 1
5502 EOF
5503
5504 else
5505   echo "$ac_t""no" 1>&6
5506 fi
5507 done
5508
5509   fi
5510
5511
5512
5513   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
5514 echo "configure:5515: checking for isnanf declaration" >&5
5515   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
5516   echo $ac_n "(cached) $ac_c" 1>&6
5517 else
5518
5519
5520     ac_ext=C
5521 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5522 ac_cpp='$CXXCPP $CPPFLAGS'
5523 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5524 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5525 cross_compiling=$ac_cv_prog_cxx_cross
5526
5527     cat > conftest.$ac_ext <<EOF
5528 #line 5529 "configure"
5529 #include "confdefs.h"
5530 #include <math.h>
5531 int main() {
5532  isnanf(0);
5533 ; return 0; }
5534 EOF
5535 if { (eval echo configure:5536: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5536   rm -rf conftest*
5537   glibcpp_cv_func_isnanf_use=yes
5538 else
5539   echo "configure: failed program was:" >&5
5540   cat conftest.$ac_ext >&5
5541   rm -rf conftest*
5542   glibcpp_cv_func_isnanf_use=no
5543 fi
5544 rm -f conftest*
5545     ac_ext=c
5546 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5547 ac_cpp='$CPP $CPPFLAGS'
5548 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5549 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5550 cross_compiling=$ac_cv_prog_cc_cross
5551
5552
5553 fi
5554
5555   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
5556   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
5557     for ac_func in isnanf
5558 do
5559 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5560 echo "configure:5561: checking for $ac_func" >&5
5561 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5562   echo $ac_n "(cached) $ac_c" 1>&6
5563 else
5564   cat > conftest.$ac_ext <<EOF
5565 #line 5566 "configure"
5566 #include "confdefs.h"
5567 /* System header to define __stub macros and hopefully few prototypes,
5568     which can conflict with char $ac_func(); below.  */
5569 #include <assert.h>
5570 /* Override any gcc2 internal prototype to avoid an error.  */
5571 /* We use char because int might match the return type of a gcc2
5572     builtin and then its argument prototype would still apply.  */
5573 char $ac_func();
5574
5575 int main() {
5576
5577 /* The GNU C library defines this for functions which it implements
5578     to always fail with ENOSYS.  Some functions are actually named
5579     something starting with __ and the normal name is an alias.  */
5580 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5581 choke me
5582 #else
5583 $ac_func();
5584 #endif
5585
5586 ; return 0; }
5587 EOF
5588 if { (eval echo configure:5589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5589   rm -rf conftest*
5590   eval "ac_cv_func_$ac_func=yes"
5591 else
5592   echo "configure: failed program was:" >&5
5593   cat conftest.$ac_ext >&5
5594   rm -rf conftest*
5595   eval "ac_cv_func_$ac_func=no"
5596 fi
5597 rm -f conftest*
5598 fi
5599
5600 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5601   echo "$ac_t""yes" 1>&6
5602     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5603   cat >> confdefs.h <<EOF
5604 #define $ac_tr_func 1
5605 EOF
5606
5607 else
5608   echo "$ac_t""no" 1>&6
5609 fi
5610 done
5611
5612   fi
5613
5614
5615   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
5616 echo "configure:5617: checking for isinff declaration" >&5
5617   if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
5618   echo $ac_n "(cached) $ac_c" 1>&6
5619 else
5620
5621
5622     ac_ext=C
5623 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5624 ac_cpp='$CXXCPP $CPPFLAGS'
5625 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5626 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5627 cross_compiling=$ac_cv_prog_cxx_cross
5628
5629     cat > conftest.$ac_ext <<EOF
5630 #line 5631 "configure"
5631 #include "confdefs.h"
5632 #include <math.h>
5633 int main() {
5634  isinff(0);
5635 ; return 0; }
5636 EOF
5637 if { (eval echo configure:5638: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5638   rm -rf conftest*
5639   glibcpp_cv_func_isinff_use=yes
5640 else
5641   echo "configure: failed program was:" >&5
5642   cat conftest.$ac_ext >&5
5643   rm -rf conftest*
5644   glibcpp_cv_func_isinff_use=no
5645 fi
5646 rm -f conftest*
5647     ac_ext=c
5648 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5649 ac_cpp='$CPP $CPPFLAGS'
5650 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5651 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5652 cross_compiling=$ac_cv_prog_cc_cross
5653
5654
5655 fi
5656
5657   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
5658   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
5659     for ac_func in isinff
5660 do
5661 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5662 echo "configure:5663: checking for $ac_func" >&5
5663 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5664   echo $ac_n "(cached) $ac_c" 1>&6
5665 else
5666   cat > conftest.$ac_ext <<EOF
5667 #line 5668 "configure"
5668 #include "confdefs.h"
5669 /* System header to define __stub macros and hopefully few prototypes,
5670     which can conflict with char $ac_func(); below.  */
5671 #include <assert.h>
5672 /* Override any gcc2 internal prototype to avoid an error.  */
5673 /* We use char because int might match the return type of a gcc2
5674     builtin and then its argument prototype would still apply.  */
5675 char $ac_func();
5676
5677 int main() {
5678
5679 /* The GNU C library defines this for functions which it implements
5680     to always fail with ENOSYS.  Some functions are actually named
5681     something starting with __ and the normal name is an alias.  */
5682 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5683 choke me
5684 #else
5685 $ac_func();
5686 #endif
5687
5688 ; return 0; }
5689 EOF
5690 if { (eval echo configure:5691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5691   rm -rf conftest*
5692   eval "ac_cv_func_$ac_func=yes"
5693 else
5694   echo "configure: failed program was:" >&5
5695   cat conftest.$ac_ext >&5
5696   rm -rf conftest*
5697   eval "ac_cv_func_$ac_func=no"
5698 fi
5699 rm -f conftest*
5700 fi
5701
5702 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5703   echo "$ac_t""yes" 1>&6
5704     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5705   cat >> confdefs.h <<EOF
5706 #define $ac_tr_func 1
5707 EOF
5708
5709 else
5710   echo "$ac_t""no" 1>&6
5711 fi
5712 done
5713
5714   fi
5715
5716
5717   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
5718 echo "configure:5719: checking for acosf declaration" >&5
5719   if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
5720   echo $ac_n "(cached) $ac_c" 1>&6
5721 else
5722
5723
5724     ac_ext=C
5725 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5726 ac_cpp='$CXXCPP $CPPFLAGS'
5727 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5728 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5729 cross_compiling=$ac_cv_prog_cxx_cross
5730
5731     cat > conftest.$ac_ext <<EOF
5732 #line 5733 "configure"
5733 #include "confdefs.h"
5734 #include <math.h>
5735 int main() {
5736  acosf(0);
5737 ; return 0; }
5738 EOF
5739 if { (eval echo configure:5740: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5740   rm -rf conftest*
5741   glibcpp_cv_func_acosf_use=yes
5742 else
5743   echo "configure: failed program was:" >&5
5744   cat conftest.$ac_ext >&5
5745   rm -rf conftest*
5746   glibcpp_cv_func_acosf_use=no
5747 fi
5748 rm -f conftest*
5749     ac_ext=c
5750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5751 ac_cpp='$CPP $CPPFLAGS'
5752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5754 cross_compiling=$ac_cv_prog_cc_cross
5755
5756
5757 fi
5758
5759   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
5760   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
5761     for ac_func in acosf
5762 do
5763 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5764 echo "configure:5765: checking for $ac_func" >&5
5765 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5766   echo $ac_n "(cached) $ac_c" 1>&6
5767 else
5768   cat > conftest.$ac_ext <<EOF
5769 #line 5770 "configure"
5770 #include "confdefs.h"
5771 /* System header to define __stub macros and hopefully few prototypes,
5772     which can conflict with char $ac_func(); below.  */
5773 #include <assert.h>
5774 /* Override any gcc2 internal prototype to avoid an error.  */
5775 /* We use char because int might match the return type of a gcc2
5776     builtin and then its argument prototype would still apply.  */
5777 char $ac_func();
5778
5779 int main() {
5780
5781 /* The GNU C library defines this for functions which it implements
5782     to always fail with ENOSYS.  Some functions are actually named
5783     something starting with __ and the normal name is an alias.  */
5784 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5785 choke me
5786 #else
5787 $ac_func();
5788 #endif
5789
5790 ; return 0; }
5791 EOF
5792 if { (eval echo configure:5793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5793   rm -rf conftest*
5794   eval "ac_cv_func_$ac_func=yes"
5795 else
5796   echo "configure: failed program was:" >&5
5797   cat conftest.$ac_ext >&5
5798   rm -rf conftest*
5799   eval "ac_cv_func_$ac_func=no"
5800 fi
5801 rm -f conftest*
5802 fi
5803
5804 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5805   echo "$ac_t""yes" 1>&6
5806     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5807   cat >> confdefs.h <<EOF
5808 #define $ac_tr_func 1
5809 EOF
5810
5811 else
5812   echo "$ac_t""no" 1>&6
5813 fi
5814 done
5815
5816   fi
5817
5818
5819   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5820 echo "configure:5821: checking for asinf declaration" >&5
5821   if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
5822   echo $ac_n "(cached) $ac_c" 1>&6
5823 else
5824
5825
5826     ac_ext=C
5827 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5828 ac_cpp='$CXXCPP $CPPFLAGS'
5829 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5830 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5831 cross_compiling=$ac_cv_prog_cxx_cross
5832
5833     cat > conftest.$ac_ext <<EOF
5834 #line 5835 "configure"
5835 #include "confdefs.h"
5836 #include <math.h>
5837 int main() {
5838  asinf(0);
5839 ; return 0; }
5840 EOF
5841 if { (eval echo configure:5842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5842   rm -rf conftest*
5843   glibcpp_cv_func_asinf_use=yes
5844 else
5845   echo "configure: failed program was:" >&5
5846   cat conftest.$ac_ext >&5
5847   rm -rf conftest*
5848   glibcpp_cv_func_asinf_use=no
5849 fi
5850 rm -f conftest*
5851     ac_ext=c
5852 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5853 ac_cpp='$CPP $CPPFLAGS'
5854 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5855 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5856 cross_compiling=$ac_cv_prog_cc_cross
5857
5858
5859 fi
5860
5861   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
5862   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
5863     for ac_func in asinf
5864 do
5865 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5866 echo "configure:5867: checking for $ac_func" >&5
5867 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5868   echo $ac_n "(cached) $ac_c" 1>&6
5869 else
5870   cat > conftest.$ac_ext <<EOF
5871 #line 5872 "configure"
5872 #include "confdefs.h"
5873 /* System header to define __stub macros and hopefully few prototypes,
5874     which can conflict with char $ac_func(); below.  */
5875 #include <assert.h>
5876 /* Override any gcc2 internal prototype to avoid an error.  */
5877 /* We use char because int might match the return type of a gcc2
5878     builtin and then its argument prototype would still apply.  */
5879 char $ac_func();
5880
5881 int main() {
5882
5883 /* The GNU C library defines this for functions which it implements
5884     to always fail with ENOSYS.  Some functions are actually named
5885     something starting with __ and the normal name is an alias.  */
5886 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5887 choke me
5888 #else
5889 $ac_func();
5890 #endif
5891
5892 ; return 0; }
5893 EOF
5894 if { (eval echo configure:5895: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5895   rm -rf conftest*
5896   eval "ac_cv_func_$ac_func=yes"
5897 else
5898   echo "configure: failed program was:" >&5
5899   cat conftest.$ac_ext >&5
5900   rm -rf conftest*
5901   eval "ac_cv_func_$ac_func=no"
5902 fi
5903 rm -f conftest*
5904 fi
5905
5906 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5907   echo "$ac_t""yes" 1>&6
5908     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5909   cat >> confdefs.h <<EOF
5910 #define $ac_tr_func 1
5911 EOF
5912
5913 else
5914   echo "$ac_t""no" 1>&6
5915 fi
5916 done
5917
5918   fi
5919
5920
5921   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5922 echo "configure:5923: checking for atanf declaration" >&5
5923   if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
5924   echo $ac_n "(cached) $ac_c" 1>&6
5925 else
5926
5927
5928     ac_ext=C
5929 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5930 ac_cpp='$CXXCPP $CPPFLAGS'
5931 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5932 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5933 cross_compiling=$ac_cv_prog_cxx_cross
5934
5935     cat > conftest.$ac_ext <<EOF
5936 #line 5937 "configure"
5937 #include "confdefs.h"
5938 #include <math.h>
5939 int main() {
5940  atanf(0);
5941 ; return 0; }
5942 EOF
5943 if { (eval echo configure:5944: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5944   rm -rf conftest*
5945   glibcpp_cv_func_atanf_use=yes
5946 else
5947   echo "configure: failed program was:" >&5
5948   cat conftest.$ac_ext >&5
5949   rm -rf conftest*
5950   glibcpp_cv_func_atanf_use=no
5951 fi
5952 rm -f conftest*
5953     ac_ext=c
5954 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5955 ac_cpp='$CPP $CPPFLAGS'
5956 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5957 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5958 cross_compiling=$ac_cv_prog_cc_cross
5959
5960
5961 fi
5962
5963   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
5964   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
5965     for ac_func in atanf
5966 do
5967 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5968 echo "configure:5969: checking for $ac_func" >&5
5969 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5970   echo $ac_n "(cached) $ac_c" 1>&6
5971 else
5972   cat > conftest.$ac_ext <<EOF
5973 #line 5974 "configure"
5974 #include "confdefs.h"
5975 /* System header to define __stub macros and hopefully few prototypes,
5976     which can conflict with char $ac_func(); below.  */
5977 #include <assert.h>
5978 /* Override any gcc2 internal prototype to avoid an error.  */
5979 /* We use char because int might match the return type of a gcc2
5980     builtin and then its argument prototype would still apply.  */
5981 char $ac_func();
5982
5983 int main() {
5984
5985 /* The GNU C library defines this for functions which it implements
5986     to always fail with ENOSYS.  Some functions are actually named
5987     something starting with __ and the normal name is an alias.  */
5988 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5989 choke me
5990 #else
5991 $ac_func();
5992 #endif
5993
5994 ; return 0; }
5995 EOF
5996 if { (eval echo configure:5997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5997   rm -rf conftest*
5998   eval "ac_cv_func_$ac_func=yes"
5999 else
6000   echo "configure: failed program was:" >&5
6001   cat conftest.$ac_ext >&5
6002   rm -rf conftest*
6003   eval "ac_cv_func_$ac_func=no"
6004 fi
6005 rm -f conftest*
6006 fi
6007
6008 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6009   echo "$ac_t""yes" 1>&6
6010     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6011   cat >> confdefs.h <<EOF
6012 #define $ac_tr_func 1
6013 EOF
6014
6015 else
6016   echo "$ac_t""no" 1>&6
6017 fi
6018 done
6019
6020   fi
6021
6022
6023   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
6024 echo "configure:6025: checking for atan2f declaration" >&5
6025   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
6026   echo $ac_n "(cached) $ac_c" 1>&6
6027 else
6028
6029
6030     ac_ext=C
6031 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6032 ac_cpp='$CXXCPP $CPPFLAGS'
6033 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6034 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6035 cross_compiling=$ac_cv_prog_cxx_cross
6036
6037     cat > conftest.$ac_ext <<EOF
6038 #line 6039 "configure"
6039 #include "confdefs.h"
6040 #include <math.h>
6041 int main() {
6042  atan2f(0, 0);
6043 ; return 0; }
6044 EOF
6045 if { (eval echo configure:6046: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6046   rm -rf conftest*
6047   glibcpp_cv_func_atan2f_use=yes
6048 else
6049   echo "configure: failed program was:" >&5
6050   cat conftest.$ac_ext >&5
6051   rm -rf conftest*
6052   glibcpp_cv_func_atan2f_use=no
6053 fi
6054 rm -f conftest*
6055     ac_ext=c
6056 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6057 ac_cpp='$CPP $CPPFLAGS'
6058 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6059 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6060 cross_compiling=$ac_cv_prog_cc_cross
6061
6062
6063 fi
6064
6065   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
6066   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
6067     for ac_func in atan2f
6068 do
6069 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6070 echo "configure:6071: checking for $ac_func" >&5
6071 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6072   echo $ac_n "(cached) $ac_c" 1>&6
6073 else
6074   cat > conftest.$ac_ext <<EOF
6075 #line 6076 "configure"
6076 #include "confdefs.h"
6077 /* System header to define __stub macros and hopefully few prototypes,
6078     which can conflict with char $ac_func(); below.  */
6079 #include <assert.h>
6080 /* Override any gcc2 internal prototype to avoid an error.  */
6081 /* We use char because int might match the return type of a gcc2
6082     builtin and then its argument prototype would still apply.  */
6083 char $ac_func();
6084
6085 int main() {
6086
6087 /* The GNU C library defines this for functions which it implements
6088     to always fail with ENOSYS.  Some functions are actually named
6089     something starting with __ and the normal name is an alias.  */
6090 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6091 choke me
6092 #else
6093 $ac_func();
6094 #endif
6095
6096 ; return 0; }
6097 EOF
6098 if { (eval echo configure:6099: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6099   rm -rf conftest*
6100   eval "ac_cv_func_$ac_func=yes"
6101 else
6102   echo "configure: failed program was:" >&5
6103   cat conftest.$ac_ext >&5
6104   rm -rf conftest*
6105   eval "ac_cv_func_$ac_func=no"
6106 fi
6107 rm -f conftest*
6108 fi
6109
6110 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6111   echo "$ac_t""yes" 1>&6
6112     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6113   cat >> confdefs.h <<EOF
6114 #define $ac_tr_func 1
6115 EOF
6116
6117 else
6118   echo "$ac_t""no" 1>&6
6119 fi
6120 done
6121
6122   fi
6123
6124
6125   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
6126 echo "configure:6127: checking for ceilf declaration" >&5
6127   if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
6128   echo $ac_n "(cached) $ac_c" 1>&6
6129 else
6130
6131
6132     ac_ext=C
6133 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6134 ac_cpp='$CXXCPP $CPPFLAGS'
6135 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6136 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6137 cross_compiling=$ac_cv_prog_cxx_cross
6138
6139     cat > conftest.$ac_ext <<EOF
6140 #line 6141 "configure"
6141 #include "confdefs.h"
6142 #include <math.h>
6143 int main() {
6144  ceilf(0);
6145 ; return 0; }
6146 EOF
6147 if { (eval echo configure:6148: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6148   rm -rf conftest*
6149   glibcpp_cv_func_ceilf_use=yes
6150 else
6151   echo "configure: failed program was:" >&5
6152   cat conftest.$ac_ext >&5
6153   rm -rf conftest*
6154   glibcpp_cv_func_ceilf_use=no
6155 fi
6156 rm -f conftest*
6157     ac_ext=c
6158 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6159 ac_cpp='$CPP $CPPFLAGS'
6160 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6161 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6162 cross_compiling=$ac_cv_prog_cc_cross
6163
6164
6165 fi
6166
6167   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
6168   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
6169     for ac_func in ceilf
6170 do
6171 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6172 echo "configure:6173: checking for $ac_func" >&5
6173 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6174   echo $ac_n "(cached) $ac_c" 1>&6
6175 else
6176   cat > conftest.$ac_ext <<EOF
6177 #line 6178 "configure"
6178 #include "confdefs.h"
6179 /* System header to define __stub macros and hopefully few prototypes,
6180     which can conflict with char $ac_func(); below.  */
6181 #include <assert.h>
6182 /* Override any gcc2 internal prototype to avoid an error.  */
6183 /* We use char because int might match the return type of a gcc2
6184     builtin and then its argument prototype would still apply.  */
6185 char $ac_func();
6186
6187 int main() {
6188
6189 /* The GNU C library defines this for functions which it implements
6190     to always fail with ENOSYS.  Some functions are actually named
6191     something starting with __ and the normal name is an alias.  */
6192 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6193 choke me
6194 #else
6195 $ac_func();
6196 #endif
6197
6198 ; return 0; }
6199 EOF
6200 if { (eval echo configure:6201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6201   rm -rf conftest*
6202   eval "ac_cv_func_$ac_func=yes"
6203 else
6204   echo "configure: failed program was:" >&5
6205   cat conftest.$ac_ext >&5
6206   rm -rf conftest*
6207   eval "ac_cv_func_$ac_func=no"
6208 fi
6209 rm -f conftest*
6210 fi
6211
6212 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6213   echo "$ac_t""yes" 1>&6
6214     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6215   cat >> confdefs.h <<EOF
6216 #define $ac_tr_func 1
6217 EOF
6218
6219 else
6220   echo "$ac_t""no" 1>&6
6221 fi
6222 done
6223
6224   fi
6225
6226
6227   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
6228 echo "configure:6229: checking for cosf declaration" >&5
6229   if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
6230   echo $ac_n "(cached) $ac_c" 1>&6
6231 else
6232
6233
6234     ac_ext=C
6235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6236 ac_cpp='$CXXCPP $CPPFLAGS'
6237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6239 cross_compiling=$ac_cv_prog_cxx_cross
6240
6241     cat > conftest.$ac_ext <<EOF
6242 #line 6243 "configure"
6243 #include "confdefs.h"
6244 #include <math.h>
6245 int main() {
6246  cosf(0);
6247 ; return 0; }
6248 EOF
6249 if { (eval echo configure:6250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6250   rm -rf conftest*
6251   glibcpp_cv_func_cosf_use=yes
6252 else
6253   echo "configure: failed program was:" >&5
6254   cat conftest.$ac_ext >&5
6255   rm -rf conftest*
6256   glibcpp_cv_func_cosf_use=no
6257 fi
6258 rm -f conftest*
6259     ac_ext=c
6260 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6261 ac_cpp='$CPP $CPPFLAGS'
6262 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6263 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6264 cross_compiling=$ac_cv_prog_cc_cross
6265
6266
6267 fi
6268
6269   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
6270   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
6271     for ac_func in cosf
6272 do
6273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6274 echo "configure:6275: checking for $ac_func" >&5
6275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6276   echo $ac_n "(cached) $ac_c" 1>&6
6277 else
6278   cat > conftest.$ac_ext <<EOF
6279 #line 6280 "configure"
6280 #include "confdefs.h"
6281 /* System header to define __stub macros and hopefully few prototypes,
6282     which can conflict with char $ac_func(); below.  */
6283 #include <assert.h>
6284 /* Override any gcc2 internal prototype to avoid an error.  */
6285 /* We use char because int might match the return type of a gcc2
6286     builtin and then its argument prototype would still apply.  */
6287 char $ac_func();
6288
6289 int main() {
6290
6291 /* The GNU C library defines this for functions which it implements
6292     to always fail with ENOSYS.  Some functions are actually named
6293     something starting with __ and the normal name is an alias.  */
6294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6295 choke me
6296 #else
6297 $ac_func();
6298 #endif
6299
6300 ; return 0; }
6301 EOF
6302 if { (eval echo configure:6303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6303   rm -rf conftest*
6304   eval "ac_cv_func_$ac_func=yes"
6305 else
6306   echo "configure: failed program was:" >&5
6307   cat conftest.$ac_ext >&5
6308   rm -rf conftest*
6309   eval "ac_cv_func_$ac_func=no"
6310 fi
6311 rm -f conftest*
6312 fi
6313
6314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6315   echo "$ac_t""yes" 1>&6
6316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6317   cat >> confdefs.h <<EOF
6318 #define $ac_tr_func 1
6319 EOF
6320
6321 else
6322   echo "$ac_t""no" 1>&6
6323 fi
6324 done
6325
6326   fi
6327
6328
6329   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
6330 echo "configure:6331: checking for coshf declaration" >&5
6331   if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
6332   echo $ac_n "(cached) $ac_c" 1>&6
6333 else
6334
6335
6336     ac_ext=C
6337 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6338 ac_cpp='$CXXCPP $CPPFLAGS'
6339 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6340 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6341 cross_compiling=$ac_cv_prog_cxx_cross
6342
6343     cat > conftest.$ac_ext <<EOF
6344 #line 6345 "configure"
6345 #include "confdefs.h"
6346 #include <math.h>
6347 int main() {
6348  coshf(0);
6349 ; return 0; }
6350 EOF
6351 if { (eval echo configure:6352: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6352   rm -rf conftest*
6353   glibcpp_cv_func_coshf_use=yes
6354 else
6355   echo "configure: failed program was:" >&5
6356   cat conftest.$ac_ext >&5
6357   rm -rf conftest*
6358   glibcpp_cv_func_coshf_use=no
6359 fi
6360 rm -f conftest*
6361     ac_ext=c
6362 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6363 ac_cpp='$CPP $CPPFLAGS'
6364 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6365 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6366 cross_compiling=$ac_cv_prog_cc_cross
6367
6368
6369 fi
6370
6371   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
6372   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
6373     for ac_func in coshf
6374 do
6375 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6376 echo "configure:6377: checking for $ac_func" >&5
6377 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6378   echo $ac_n "(cached) $ac_c" 1>&6
6379 else
6380   cat > conftest.$ac_ext <<EOF
6381 #line 6382 "configure"
6382 #include "confdefs.h"
6383 /* System header to define __stub macros and hopefully few prototypes,
6384     which can conflict with char $ac_func(); below.  */
6385 #include <assert.h>
6386 /* Override any gcc2 internal prototype to avoid an error.  */
6387 /* We use char because int might match the return type of a gcc2
6388     builtin and then its argument prototype would still apply.  */
6389 char $ac_func();
6390
6391 int main() {
6392
6393 /* The GNU C library defines this for functions which it implements
6394     to always fail with ENOSYS.  Some functions are actually named
6395     something starting with __ and the normal name is an alias.  */
6396 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6397 choke me
6398 #else
6399 $ac_func();
6400 #endif
6401
6402 ; return 0; }
6403 EOF
6404 if { (eval echo configure:6405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6405   rm -rf conftest*
6406   eval "ac_cv_func_$ac_func=yes"
6407 else
6408   echo "configure: failed program was:" >&5
6409   cat conftest.$ac_ext >&5
6410   rm -rf conftest*
6411   eval "ac_cv_func_$ac_func=no"
6412 fi
6413 rm -f conftest*
6414 fi
6415
6416 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6417   echo "$ac_t""yes" 1>&6
6418     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6419   cat >> confdefs.h <<EOF
6420 #define $ac_tr_func 1
6421 EOF
6422
6423 else
6424   echo "$ac_t""no" 1>&6
6425 fi
6426 done
6427
6428   fi
6429
6430
6431   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
6432 echo "configure:6433: checking for expf declaration" >&5
6433   if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
6434   echo $ac_n "(cached) $ac_c" 1>&6
6435 else
6436
6437
6438     ac_ext=C
6439 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6440 ac_cpp='$CXXCPP $CPPFLAGS'
6441 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6442 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6443 cross_compiling=$ac_cv_prog_cxx_cross
6444
6445     cat > conftest.$ac_ext <<EOF
6446 #line 6447 "configure"
6447 #include "confdefs.h"
6448 #include <math.h>
6449 int main() {
6450  expf(0);
6451 ; return 0; }
6452 EOF
6453 if { (eval echo configure:6454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6454   rm -rf conftest*
6455   glibcpp_cv_func_expf_use=yes
6456 else
6457   echo "configure: failed program was:" >&5
6458   cat conftest.$ac_ext >&5
6459   rm -rf conftest*
6460   glibcpp_cv_func_expf_use=no
6461 fi
6462 rm -f conftest*
6463     ac_ext=c
6464 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6465 ac_cpp='$CPP $CPPFLAGS'
6466 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6467 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6468 cross_compiling=$ac_cv_prog_cc_cross
6469
6470
6471 fi
6472
6473   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
6474   if test x$glibcpp_cv_func_expf_use = x"yes"; then
6475     for ac_func in expf
6476 do
6477 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6478 echo "configure:6479: checking for $ac_func" >&5
6479 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6480   echo $ac_n "(cached) $ac_c" 1>&6
6481 else
6482   cat > conftest.$ac_ext <<EOF
6483 #line 6484 "configure"
6484 #include "confdefs.h"
6485 /* System header to define __stub macros and hopefully few prototypes,
6486     which can conflict with char $ac_func(); below.  */
6487 #include <assert.h>
6488 /* Override any gcc2 internal prototype to avoid an error.  */
6489 /* We use char because int might match the return type of a gcc2
6490     builtin and then its argument prototype would still apply.  */
6491 char $ac_func();
6492
6493 int main() {
6494
6495 /* The GNU C library defines this for functions which it implements
6496     to always fail with ENOSYS.  Some functions are actually named
6497     something starting with __ and the normal name is an alias.  */
6498 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6499 choke me
6500 #else
6501 $ac_func();
6502 #endif
6503
6504 ; return 0; }
6505 EOF
6506 if { (eval echo configure:6507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6507   rm -rf conftest*
6508   eval "ac_cv_func_$ac_func=yes"
6509 else
6510   echo "configure: failed program was:" >&5
6511   cat conftest.$ac_ext >&5
6512   rm -rf conftest*
6513   eval "ac_cv_func_$ac_func=no"
6514 fi
6515 rm -f conftest*
6516 fi
6517
6518 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6519   echo "$ac_t""yes" 1>&6
6520     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6521   cat >> confdefs.h <<EOF
6522 #define $ac_tr_func 1
6523 EOF
6524
6525 else
6526   echo "$ac_t""no" 1>&6
6527 fi
6528 done
6529
6530   fi
6531
6532
6533   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
6534 echo "configure:6535: checking for fabsf declaration" >&5
6535   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
6536   echo $ac_n "(cached) $ac_c" 1>&6
6537 else
6538
6539
6540     ac_ext=C
6541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6542 ac_cpp='$CXXCPP $CPPFLAGS'
6543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6545 cross_compiling=$ac_cv_prog_cxx_cross
6546
6547     cat > conftest.$ac_ext <<EOF
6548 #line 6549 "configure"
6549 #include "confdefs.h"
6550 #include <math.h>
6551 int main() {
6552  fabsf(0);
6553 ; return 0; }
6554 EOF
6555 if { (eval echo configure:6556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6556   rm -rf conftest*
6557   glibcpp_cv_func_fabsf_use=yes
6558 else
6559   echo "configure: failed program was:" >&5
6560   cat conftest.$ac_ext >&5
6561   rm -rf conftest*
6562   glibcpp_cv_func_fabsf_use=no
6563 fi
6564 rm -f conftest*
6565     ac_ext=c
6566 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6567 ac_cpp='$CPP $CPPFLAGS'
6568 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6569 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6570 cross_compiling=$ac_cv_prog_cc_cross
6571
6572
6573 fi
6574
6575   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
6576   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
6577     for ac_func in fabsf
6578 do
6579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6580 echo "configure:6581: checking for $ac_func" >&5
6581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6582   echo $ac_n "(cached) $ac_c" 1>&6
6583 else
6584   cat > conftest.$ac_ext <<EOF
6585 #line 6586 "configure"
6586 #include "confdefs.h"
6587 /* System header to define __stub macros and hopefully few prototypes,
6588     which can conflict with char $ac_func(); below.  */
6589 #include <assert.h>
6590 /* Override any gcc2 internal prototype to avoid an error.  */
6591 /* We use char because int might match the return type of a gcc2
6592     builtin and then its argument prototype would still apply.  */
6593 char $ac_func();
6594
6595 int main() {
6596
6597 /* The GNU C library defines this for functions which it implements
6598     to always fail with ENOSYS.  Some functions are actually named
6599     something starting with __ and the normal name is an alias.  */
6600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6601 choke me
6602 #else
6603 $ac_func();
6604 #endif
6605
6606 ; return 0; }
6607 EOF
6608 if { (eval echo configure:6609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6609   rm -rf conftest*
6610   eval "ac_cv_func_$ac_func=yes"
6611 else
6612   echo "configure: failed program was:" >&5
6613   cat conftest.$ac_ext >&5
6614   rm -rf conftest*
6615   eval "ac_cv_func_$ac_func=no"
6616 fi
6617 rm -f conftest*
6618 fi
6619
6620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6621   echo "$ac_t""yes" 1>&6
6622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6623   cat >> confdefs.h <<EOF
6624 #define $ac_tr_func 1
6625 EOF
6626
6627 else
6628   echo "$ac_t""no" 1>&6
6629 fi
6630 done
6631
6632   fi
6633
6634
6635   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
6636 echo "configure:6637: checking for floorf declaration" >&5
6637   if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
6638   echo $ac_n "(cached) $ac_c" 1>&6
6639 else
6640
6641
6642     ac_ext=C
6643 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6644 ac_cpp='$CXXCPP $CPPFLAGS'
6645 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6646 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6647 cross_compiling=$ac_cv_prog_cxx_cross
6648
6649     cat > conftest.$ac_ext <<EOF
6650 #line 6651 "configure"
6651 #include "confdefs.h"
6652 #include <math.h>
6653 int main() {
6654  floorf(0);
6655 ; return 0; }
6656 EOF
6657 if { (eval echo configure:6658: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6658   rm -rf conftest*
6659   glibcpp_cv_func_floorf_use=yes
6660 else
6661   echo "configure: failed program was:" >&5
6662   cat conftest.$ac_ext >&5
6663   rm -rf conftest*
6664   glibcpp_cv_func_floorf_use=no
6665 fi
6666 rm -f conftest*
6667     ac_ext=c
6668 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6669 ac_cpp='$CPP $CPPFLAGS'
6670 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6671 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6672 cross_compiling=$ac_cv_prog_cc_cross
6673
6674
6675 fi
6676
6677   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
6678   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
6679     for ac_func in floorf
6680 do
6681 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6682 echo "configure:6683: checking for $ac_func" >&5
6683 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6684   echo $ac_n "(cached) $ac_c" 1>&6
6685 else
6686   cat > conftest.$ac_ext <<EOF
6687 #line 6688 "configure"
6688 #include "confdefs.h"
6689 /* System header to define __stub macros and hopefully few prototypes,
6690     which can conflict with char $ac_func(); below.  */
6691 #include <assert.h>
6692 /* Override any gcc2 internal prototype to avoid an error.  */
6693 /* We use char because int might match the return type of a gcc2
6694     builtin and then its argument prototype would still apply.  */
6695 char $ac_func();
6696
6697 int main() {
6698
6699 /* The GNU C library defines this for functions which it implements
6700     to always fail with ENOSYS.  Some functions are actually named
6701     something starting with __ and the normal name is an alias.  */
6702 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6703 choke me
6704 #else
6705 $ac_func();
6706 #endif
6707
6708 ; return 0; }
6709 EOF
6710 if { (eval echo configure:6711: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6711   rm -rf conftest*
6712   eval "ac_cv_func_$ac_func=yes"
6713 else
6714   echo "configure: failed program was:" >&5
6715   cat conftest.$ac_ext >&5
6716   rm -rf conftest*
6717   eval "ac_cv_func_$ac_func=no"
6718 fi
6719 rm -f conftest*
6720 fi
6721
6722 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6723   echo "$ac_t""yes" 1>&6
6724     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6725   cat >> confdefs.h <<EOF
6726 #define $ac_tr_func 1
6727 EOF
6728
6729 else
6730   echo "$ac_t""no" 1>&6
6731 fi
6732 done
6733
6734   fi
6735
6736
6737   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
6738 echo "configure:6739: checking for fmodf declaration" >&5
6739   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
6740   echo $ac_n "(cached) $ac_c" 1>&6
6741 else
6742
6743
6744     ac_ext=C
6745 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6746 ac_cpp='$CXXCPP $CPPFLAGS'
6747 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6748 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6749 cross_compiling=$ac_cv_prog_cxx_cross
6750
6751     cat > conftest.$ac_ext <<EOF
6752 #line 6753 "configure"
6753 #include "confdefs.h"
6754 #include <math.h>
6755 int main() {
6756  fmodf(0, 0);
6757 ; return 0; }
6758 EOF
6759 if { (eval echo configure:6760: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6760   rm -rf conftest*
6761   glibcpp_cv_func_fmodf_use=yes
6762 else
6763   echo "configure: failed program was:" >&5
6764   cat conftest.$ac_ext >&5
6765   rm -rf conftest*
6766   glibcpp_cv_func_fmodf_use=no
6767 fi
6768 rm -f conftest*
6769     ac_ext=c
6770 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6771 ac_cpp='$CPP $CPPFLAGS'
6772 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6773 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6774 cross_compiling=$ac_cv_prog_cc_cross
6775
6776
6777 fi
6778
6779   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
6780   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
6781     for ac_func in fmodf
6782 do
6783 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6784 echo "configure:6785: checking for $ac_func" >&5
6785 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6786   echo $ac_n "(cached) $ac_c" 1>&6
6787 else
6788   cat > conftest.$ac_ext <<EOF
6789 #line 6790 "configure"
6790 #include "confdefs.h"
6791 /* System header to define __stub macros and hopefully few prototypes,
6792     which can conflict with char $ac_func(); below.  */
6793 #include <assert.h>
6794 /* Override any gcc2 internal prototype to avoid an error.  */
6795 /* We use char because int might match the return type of a gcc2
6796     builtin and then its argument prototype would still apply.  */
6797 char $ac_func();
6798
6799 int main() {
6800
6801 /* The GNU C library defines this for functions which it implements
6802     to always fail with ENOSYS.  Some functions are actually named
6803     something starting with __ and the normal name is an alias.  */
6804 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6805 choke me
6806 #else
6807 $ac_func();
6808 #endif
6809
6810 ; return 0; }
6811 EOF
6812 if { (eval echo configure:6813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6813   rm -rf conftest*
6814   eval "ac_cv_func_$ac_func=yes"
6815 else
6816   echo "configure: failed program was:" >&5
6817   cat conftest.$ac_ext >&5
6818   rm -rf conftest*
6819   eval "ac_cv_func_$ac_func=no"
6820 fi
6821 rm -f conftest*
6822 fi
6823
6824 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6825   echo "$ac_t""yes" 1>&6
6826     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6827   cat >> confdefs.h <<EOF
6828 #define $ac_tr_func 1
6829 EOF
6830
6831 else
6832   echo "$ac_t""no" 1>&6
6833 fi
6834 done
6835
6836   fi
6837
6838
6839   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
6840 echo "configure:6841: checking for frexpf declaration" >&5
6841   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
6842   echo $ac_n "(cached) $ac_c" 1>&6
6843 else
6844
6845
6846     ac_ext=C
6847 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6848 ac_cpp='$CXXCPP $CPPFLAGS'
6849 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6850 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6851 cross_compiling=$ac_cv_prog_cxx_cross
6852
6853     cat > conftest.$ac_ext <<EOF
6854 #line 6855 "configure"
6855 #include "confdefs.h"
6856 #include <math.h>
6857 int main() {
6858  frexpf(0, 0);
6859 ; return 0; }
6860 EOF
6861 if { (eval echo configure:6862: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6862   rm -rf conftest*
6863   glibcpp_cv_func_frexpf_use=yes
6864 else
6865   echo "configure: failed program was:" >&5
6866   cat conftest.$ac_ext >&5
6867   rm -rf conftest*
6868   glibcpp_cv_func_frexpf_use=no
6869 fi
6870 rm -f conftest*
6871     ac_ext=c
6872 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6873 ac_cpp='$CPP $CPPFLAGS'
6874 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6875 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6876 cross_compiling=$ac_cv_prog_cc_cross
6877
6878
6879 fi
6880
6881   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
6882   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
6883     for ac_func in frexpf
6884 do
6885 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6886 echo "configure:6887: checking for $ac_func" >&5
6887 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6888   echo $ac_n "(cached) $ac_c" 1>&6
6889 else
6890   cat > conftest.$ac_ext <<EOF
6891 #line 6892 "configure"
6892 #include "confdefs.h"
6893 /* System header to define __stub macros and hopefully few prototypes,
6894     which can conflict with char $ac_func(); below.  */
6895 #include <assert.h>
6896 /* Override any gcc2 internal prototype to avoid an error.  */
6897 /* We use char because int might match the return type of a gcc2
6898     builtin and then its argument prototype would still apply.  */
6899 char $ac_func();
6900
6901 int main() {
6902
6903 /* The GNU C library defines this for functions which it implements
6904     to always fail with ENOSYS.  Some functions are actually named
6905     something starting with __ and the normal name is an alias.  */
6906 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6907 choke me
6908 #else
6909 $ac_func();
6910 #endif
6911
6912 ; return 0; }
6913 EOF
6914 if { (eval echo configure:6915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6915   rm -rf conftest*
6916   eval "ac_cv_func_$ac_func=yes"
6917 else
6918   echo "configure: failed program was:" >&5
6919   cat conftest.$ac_ext >&5
6920   rm -rf conftest*
6921   eval "ac_cv_func_$ac_func=no"
6922 fi
6923 rm -f conftest*
6924 fi
6925
6926 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6927   echo "$ac_t""yes" 1>&6
6928     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6929   cat >> confdefs.h <<EOF
6930 #define $ac_tr_func 1
6931 EOF
6932
6933 else
6934   echo "$ac_t""no" 1>&6
6935 fi
6936 done
6937
6938   fi
6939
6940
6941   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6942 echo "configure:6943: checking for ldexpf declaration" >&5
6943   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
6944   echo $ac_n "(cached) $ac_c" 1>&6
6945 else
6946
6947
6948     ac_ext=C
6949 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6950 ac_cpp='$CXXCPP $CPPFLAGS'
6951 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6952 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6953 cross_compiling=$ac_cv_prog_cxx_cross
6954
6955     cat > conftest.$ac_ext <<EOF
6956 #line 6957 "configure"
6957 #include "confdefs.h"
6958 #include <math.h>
6959 int main() {
6960  ldexpf(0, 0);
6961 ; return 0; }
6962 EOF
6963 if { (eval echo configure:6964: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6964   rm -rf conftest*
6965   glibcpp_cv_func_ldexpf_use=yes
6966 else
6967   echo "configure: failed program was:" >&5
6968   cat conftest.$ac_ext >&5
6969   rm -rf conftest*
6970   glibcpp_cv_func_ldexpf_use=no
6971 fi
6972 rm -f conftest*
6973     ac_ext=c
6974 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6975 ac_cpp='$CPP $CPPFLAGS'
6976 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6977 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6978 cross_compiling=$ac_cv_prog_cc_cross
6979
6980
6981 fi
6982
6983   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
6984   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
6985     for ac_func in ldexpf
6986 do
6987 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6988 echo "configure:6989: checking for $ac_func" >&5
6989 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6990   echo $ac_n "(cached) $ac_c" 1>&6
6991 else
6992   cat > conftest.$ac_ext <<EOF
6993 #line 6994 "configure"
6994 #include "confdefs.h"
6995 /* System header to define __stub macros and hopefully few prototypes,
6996     which can conflict with char $ac_func(); below.  */
6997 #include <assert.h>
6998 /* Override any gcc2 internal prototype to avoid an error.  */
6999 /* We use char because int might match the return type of a gcc2
7000     builtin and then its argument prototype would still apply.  */
7001 char $ac_func();
7002
7003 int main() {
7004
7005 /* The GNU C library defines this for functions which it implements
7006     to always fail with ENOSYS.  Some functions are actually named
7007     something starting with __ and the normal name is an alias.  */
7008 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7009 choke me
7010 #else
7011 $ac_func();
7012 #endif
7013
7014 ; return 0; }
7015 EOF
7016 if { (eval echo configure:7017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7017   rm -rf conftest*
7018   eval "ac_cv_func_$ac_func=yes"
7019 else
7020   echo "configure: failed program was:" >&5
7021   cat conftest.$ac_ext >&5
7022   rm -rf conftest*
7023   eval "ac_cv_func_$ac_func=no"
7024 fi
7025 rm -f conftest*
7026 fi
7027
7028 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7029   echo "$ac_t""yes" 1>&6
7030     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7031   cat >> confdefs.h <<EOF
7032 #define $ac_tr_func 1
7033 EOF
7034
7035 else
7036   echo "$ac_t""no" 1>&6
7037 fi
7038 done
7039
7040   fi
7041
7042
7043   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
7044 echo "configure:7045: checking for logf declaration" >&5
7045   if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
7046   echo $ac_n "(cached) $ac_c" 1>&6
7047 else
7048
7049
7050     ac_ext=C
7051 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7052 ac_cpp='$CXXCPP $CPPFLAGS'
7053 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7054 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7055 cross_compiling=$ac_cv_prog_cxx_cross
7056
7057     cat > conftest.$ac_ext <<EOF
7058 #line 7059 "configure"
7059 #include "confdefs.h"
7060 #include <math.h>
7061 int main() {
7062  logf(0);
7063 ; return 0; }
7064 EOF
7065 if { (eval echo configure:7066: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7066   rm -rf conftest*
7067   glibcpp_cv_func_logf_use=yes
7068 else
7069   echo "configure: failed program was:" >&5
7070   cat conftest.$ac_ext >&5
7071   rm -rf conftest*
7072   glibcpp_cv_func_logf_use=no
7073 fi
7074 rm -f conftest*
7075     ac_ext=c
7076 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7077 ac_cpp='$CPP $CPPFLAGS'
7078 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7079 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7080 cross_compiling=$ac_cv_prog_cc_cross
7081
7082
7083 fi
7084
7085   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
7086   if test x$glibcpp_cv_func_logf_use = x"yes"; then
7087     for ac_func in logf
7088 do
7089 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7090 echo "configure:7091: checking for $ac_func" >&5
7091 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7092   echo $ac_n "(cached) $ac_c" 1>&6
7093 else
7094   cat > conftest.$ac_ext <<EOF
7095 #line 7096 "configure"
7096 #include "confdefs.h"
7097 /* System header to define __stub macros and hopefully few prototypes,
7098     which can conflict with char $ac_func(); below.  */
7099 #include <assert.h>
7100 /* Override any gcc2 internal prototype to avoid an error.  */
7101 /* We use char because int might match the return type of a gcc2
7102     builtin and then its argument prototype would still apply.  */
7103 char $ac_func();
7104
7105 int main() {
7106
7107 /* The GNU C library defines this for functions which it implements
7108     to always fail with ENOSYS.  Some functions are actually named
7109     something starting with __ and the normal name is an alias.  */
7110 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7111 choke me
7112 #else
7113 $ac_func();
7114 #endif
7115
7116 ; return 0; }
7117 EOF
7118 if { (eval echo configure:7119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7119   rm -rf conftest*
7120   eval "ac_cv_func_$ac_func=yes"
7121 else
7122   echo "configure: failed program was:" >&5
7123   cat conftest.$ac_ext >&5
7124   rm -rf conftest*
7125   eval "ac_cv_func_$ac_func=no"
7126 fi
7127 rm -f conftest*
7128 fi
7129
7130 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7131   echo "$ac_t""yes" 1>&6
7132     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7133   cat >> confdefs.h <<EOF
7134 #define $ac_tr_func 1
7135 EOF
7136
7137 else
7138   echo "$ac_t""no" 1>&6
7139 fi
7140 done
7141
7142   fi
7143
7144
7145   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
7146 echo "configure:7147: checking for log10f declaration" >&5
7147   if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
7148   echo $ac_n "(cached) $ac_c" 1>&6
7149 else
7150
7151
7152     ac_ext=C
7153 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7154 ac_cpp='$CXXCPP $CPPFLAGS'
7155 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7156 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7157 cross_compiling=$ac_cv_prog_cxx_cross
7158
7159     cat > conftest.$ac_ext <<EOF
7160 #line 7161 "configure"
7161 #include "confdefs.h"
7162 #include <math.h>
7163 int main() {
7164  log10f(0);
7165 ; return 0; }
7166 EOF
7167 if { (eval echo configure:7168: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7168   rm -rf conftest*
7169   glibcpp_cv_func_log10f_use=yes
7170 else
7171   echo "configure: failed program was:" >&5
7172   cat conftest.$ac_ext >&5
7173   rm -rf conftest*
7174   glibcpp_cv_func_log10f_use=no
7175 fi
7176 rm -f conftest*
7177     ac_ext=c
7178 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7179 ac_cpp='$CPP $CPPFLAGS'
7180 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7181 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7182 cross_compiling=$ac_cv_prog_cc_cross
7183
7184
7185 fi
7186
7187   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
7188   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
7189     for ac_func in log10f
7190 do
7191 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7192 echo "configure:7193: checking for $ac_func" >&5
7193 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7194   echo $ac_n "(cached) $ac_c" 1>&6
7195 else
7196   cat > conftest.$ac_ext <<EOF
7197 #line 7198 "configure"
7198 #include "confdefs.h"
7199 /* System header to define __stub macros and hopefully few prototypes,
7200     which can conflict with char $ac_func(); below.  */
7201 #include <assert.h>
7202 /* Override any gcc2 internal prototype to avoid an error.  */
7203 /* We use char because int might match the return type of a gcc2
7204     builtin and then its argument prototype would still apply.  */
7205 char $ac_func();
7206
7207 int main() {
7208
7209 /* The GNU C library defines this for functions which it implements
7210     to always fail with ENOSYS.  Some functions are actually named
7211     something starting with __ and the normal name is an alias.  */
7212 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7213 choke me
7214 #else
7215 $ac_func();
7216 #endif
7217
7218 ; return 0; }
7219 EOF
7220 if { (eval echo configure:7221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7221   rm -rf conftest*
7222   eval "ac_cv_func_$ac_func=yes"
7223 else
7224   echo "configure: failed program was:" >&5
7225   cat conftest.$ac_ext >&5
7226   rm -rf conftest*
7227   eval "ac_cv_func_$ac_func=no"
7228 fi
7229 rm -f conftest*
7230 fi
7231
7232 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7233   echo "$ac_t""yes" 1>&6
7234     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7235   cat >> confdefs.h <<EOF
7236 #define $ac_tr_func 1
7237 EOF
7238
7239 else
7240   echo "$ac_t""no" 1>&6
7241 fi
7242 done
7243
7244   fi
7245
7246
7247   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
7248 echo "configure:7249: checking for modff declaration" >&5
7249   if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
7250   echo $ac_n "(cached) $ac_c" 1>&6
7251 else
7252
7253
7254     ac_ext=C
7255 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7256 ac_cpp='$CXXCPP $CPPFLAGS'
7257 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7258 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7259 cross_compiling=$ac_cv_prog_cxx_cross
7260
7261     cat > conftest.$ac_ext <<EOF
7262 #line 7263 "configure"
7263 #include "confdefs.h"
7264 #include <math.h>
7265 int main() {
7266  modff(0, 0);
7267 ; return 0; }
7268 EOF
7269 if { (eval echo configure:7270: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7270   rm -rf conftest*
7271   glibcpp_cv_func_modff_use=yes
7272 else
7273   echo "configure: failed program was:" >&5
7274   cat conftest.$ac_ext >&5
7275   rm -rf conftest*
7276   glibcpp_cv_func_modff_use=no
7277 fi
7278 rm -f conftest*
7279     ac_ext=c
7280 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7281 ac_cpp='$CPP $CPPFLAGS'
7282 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7283 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7284 cross_compiling=$ac_cv_prog_cc_cross
7285
7286
7287 fi
7288
7289   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
7290   if test x$glibcpp_cv_func_modff_use = x"yes"; then
7291     for ac_func in modff
7292 do
7293 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7294 echo "configure:7295: checking for $ac_func" >&5
7295 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7296   echo $ac_n "(cached) $ac_c" 1>&6
7297 else
7298   cat > conftest.$ac_ext <<EOF
7299 #line 7300 "configure"
7300 #include "confdefs.h"
7301 /* System header to define __stub macros and hopefully few prototypes,
7302     which can conflict with char $ac_func(); below.  */
7303 #include <assert.h>
7304 /* Override any gcc2 internal prototype to avoid an error.  */
7305 /* We use char because int might match the return type of a gcc2
7306     builtin and then its argument prototype would still apply.  */
7307 char $ac_func();
7308
7309 int main() {
7310
7311 /* The GNU C library defines this for functions which it implements
7312     to always fail with ENOSYS.  Some functions are actually named
7313     something starting with __ and the normal name is an alias.  */
7314 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7315 choke me
7316 #else
7317 $ac_func();
7318 #endif
7319
7320 ; return 0; }
7321 EOF
7322 if { (eval echo configure:7323: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7323   rm -rf conftest*
7324   eval "ac_cv_func_$ac_func=yes"
7325 else
7326   echo "configure: failed program was:" >&5
7327   cat conftest.$ac_ext >&5
7328   rm -rf conftest*
7329   eval "ac_cv_func_$ac_func=no"
7330 fi
7331 rm -f conftest*
7332 fi
7333
7334 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7335   echo "$ac_t""yes" 1>&6
7336     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7337   cat >> confdefs.h <<EOF
7338 #define $ac_tr_func 1
7339 EOF
7340
7341 else
7342   echo "$ac_t""no" 1>&6
7343 fi
7344 done
7345
7346   fi
7347
7348
7349   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
7350 echo "configure:7351: checking for powf declaration" >&5
7351   if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
7352   echo $ac_n "(cached) $ac_c" 1>&6
7353 else
7354
7355
7356     ac_ext=C
7357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7358 ac_cpp='$CXXCPP $CPPFLAGS'
7359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7361 cross_compiling=$ac_cv_prog_cxx_cross
7362
7363     cat > conftest.$ac_ext <<EOF
7364 #line 7365 "configure"
7365 #include "confdefs.h"
7366 #include <math.h>
7367 int main() {
7368  powf(0, 0);
7369 ; return 0; }
7370 EOF
7371 if { (eval echo configure:7372: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7372   rm -rf conftest*
7373   glibcpp_cv_func_powf_use=yes
7374 else
7375   echo "configure: failed program was:" >&5
7376   cat conftest.$ac_ext >&5
7377   rm -rf conftest*
7378   glibcpp_cv_func_powf_use=no
7379 fi
7380 rm -f conftest*
7381     ac_ext=c
7382 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7383 ac_cpp='$CPP $CPPFLAGS'
7384 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7385 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7386 cross_compiling=$ac_cv_prog_cc_cross
7387
7388
7389 fi
7390
7391   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
7392   if test x$glibcpp_cv_func_powf_use = x"yes"; then
7393     for ac_func in powf
7394 do
7395 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7396 echo "configure:7397: checking for $ac_func" >&5
7397 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7398   echo $ac_n "(cached) $ac_c" 1>&6
7399 else
7400   cat > conftest.$ac_ext <<EOF
7401 #line 7402 "configure"
7402 #include "confdefs.h"
7403 /* System header to define __stub macros and hopefully few prototypes,
7404     which can conflict with char $ac_func(); below.  */
7405 #include <assert.h>
7406 /* Override any gcc2 internal prototype to avoid an error.  */
7407 /* We use char because int might match the return type of a gcc2
7408     builtin and then its argument prototype would still apply.  */
7409 char $ac_func();
7410
7411 int main() {
7412
7413 /* The GNU C library defines this for functions which it implements
7414     to always fail with ENOSYS.  Some functions are actually named
7415     something starting with __ and the normal name is an alias.  */
7416 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7417 choke me
7418 #else
7419 $ac_func();
7420 #endif
7421
7422 ; return 0; }
7423 EOF
7424 if { (eval echo configure:7425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7425   rm -rf conftest*
7426   eval "ac_cv_func_$ac_func=yes"
7427 else
7428   echo "configure: failed program was:" >&5
7429   cat conftest.$ac_ext >&5
7430   rm -rf conftest*
7431   eval "ac_cv_func_$ac_func=no"
7432 fi
7433 rm -f conftest*
7434 fi
7435
7436 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7437   echo "$ac_t""yes" 1>&6
7438     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7439   cat >> confdefs.h <<EOF
7440 #define $ac_tr_func 1
7441 EOF
7442
7443 else
7444   echo "$ac_t""no" 1>&6
7445 fi
7446 done
7447
7448   fi
7449
7450
7451   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
7452 echo "configure:7453: checking for sinf declaration" >&5
7453   if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
7454   echo $ac_n "(cached) $ac_c" 1>&6
7455 else
7456
7457
7458     ac_ext=C
7459 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7460 ac_cpp='$CXXCPP $CPPFLAGS'
7461 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7462 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7463 cross_compiling=$ac_cv_prog_cxx_cross
7464
7465     cat > conftest.$ac_ext <<EOF
7466 #line 7467 "configure"
7467 #include "confdefs.h"
7468 #include <math.h>
7469 int main() {
7470  sinf(0);
7471 ; return 0; }
7472 EOF
7473 if { (eval echo configure:7474: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7474   rm -rf conftest*
7475   glibcpp_cv_func_sinf_use=yes
7476 else
7477   echo "configure: failed program was:" >&5
7478   cat conftest.$ac_ext >&5
7479   rm -rf conftest*
7480   glibcpp_cv_func_sinf_use=no
7481 fi
7482 rm -f conftest*
7483     ac_ext=c
7484 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7485 ac_cpp='$CPP $CPPFLAGS'
7486 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7487 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7488 cross_compiling=$ac_cv_prog_cc_cross
7489
7490
7491 fi
7492
7493   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
7494   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
7495     for ac_func in sinf
7496 do
7497 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7498 echo "configure:7499: checking for $ac_func" >&5
7499 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7500   echo $ac_n "(cached) $ac_c" 1>&6
7501 else
7502   cat > conftest.$ac_ext <<EOF
7503 #line 7504 "configure"
7504 #include "confdefs.h"
7505 /* System header to define __stub macros and hopefully few prototypes,
7506     which can conflict with char $ac_func(); below.  */
7507 #include <assert.h>
7508 /* Override any gcc2 internal prototype to avoid an error.  */
7509 /* We use char because int might match the return type of a gcc2
7510     builtin and then its argument prototype would still apply.  */
7511 char $ac_func();
7512
7513 int main() {
7514
7515 /* The GNU C library defines this for functions which it implements
7516     to always fail with ENOSYS.  Some functions are actually named
7517     something starting with __ and the normal name is an alias.  */
7518 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7519 choke me
7520 #else
7521 $ac_func();
7522 #endif
7523
7524 ; return 0; }
7525 EOF
7526 if { (eval echo configure:7527: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7527   rm -rf conftest*
7528   eval "ac_cv_func_$ac_func=yes"
7529 else
7530   echo "configure: failed program was:" >&5
7531   cat conftest.$ac_ext >&5
7532   rm -rf conftest*
7533   eval "ac_cv_func_$ac_func=no"
7534 fi
7535 rm -f conftest*
7536 fi
7537
7538 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7539   echo "$ac_t""yes" 1>&6
7540     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7541   cat >> confdefs.h <<EOF
7542 #define $ac_tr_func 1
7543 EOF
7544
7545 else
7546   echo "$ac_t""no" 1>&6
7547 fi
7548 done
7549
7550   fi
7551
7552
7553   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
7554 echo "configure:7555: checking for sinhf declaration" >&5
7555   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
7556   echo $ac_n "(cached) $ac_c" 1>&6
7557 else
7558
7559
7560     ac_ext=C
7561 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7562 ac_cpp='$CXXCPP $CPPFLAGS'
7563 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7564 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7565 cross_compiling=$ac_cv_prog_cxx_cross
7566
7567     cat > conftest.$ac_ext <<EOF
7568 #line 7569 "configure"
7569 #include "confdefs.h"
7570 #include <math.h>
7571 int main() {
7572  sinhf(0);
7573 ; return 0; }
7574 EOF
7575 if { (eval echo configure:7576: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7576   rm -rf conftest*
7577   glibcpp_cv_func_sinhf_use=yes
7578 else
7579   echo "configure: failed program was:" >&5
7580   cat conftest.$ac_ext >&5
7581   rm -rf conftest*
7582   glibcpp_cv_func_sinhf_use=no
7583 fi
7584 rm -f conftest*
7585     ac_ext=c
7586 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7587 ac_cpp='$CPP $CPPFLAGS'
7588 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7589 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7590 cross_compiling=$ac_cv_prog_cc_cross
7591
7592
7593 fi
7594
7595   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
7596   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
7597     for ac_func in sinhf
7598 do
7599 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7600 echo "configure:7601: checking for $ac_func" >&5
7601 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7602   echo $ac_n "(cached) $ac_c" 1>&6
7603 else
7604   cat > conftest.$ac_ext <<EOF
7605 #line 7606 "configure"
7606 #include "confdefs.h"
7607 /* System header to define __stub macros and hopefully few prototypes,
7608     which can conflict with char $ac_func(); below.  */
7609 #include <assert.h>
7610 /* Override any gcc2 internal prototype to avoid an error.  */
7611 /* We use char because int might match the return type of a gcc2
7612     builtin and then its argument prototype would still apply.  */
7613 char $ac_func();
7614
7615 int main() {
7616
7617 /* The GNU C library defines this for functions which it implements
7618     to always fail with ENOSYS.  Some functions are actually named
7619     something starting with __ and the normal name is an alias.  */
7620 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7621 choke me
7622 #else
7623 $ac_func();
7624 #endif
7625
7626 ; return 0; }
7627 EOF
7628 if { (eval echo configure:7629: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7629   rm -rf conftest*
7630   eval "ac_cv_func_$ac_func=yes"
7631 else
7632   echo "configure: failed program was:" >&5
7633   cat conftest.$ac_ext >&5
7634   rm -rf conftest*
7635   eval "ac_cv_func_$ac_func=no"
7636 fi
7637 rm -f conftest*
7638 fi
7639
7640 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7641   echo "$ac_t""yes" 1>&6
7642     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7643   cat >> confdefs.h <<EOF
7644 #define $ac_tr_func 1
7645 EOF
7646
7647 else
7648   echo "$ac_t""no" 1>&6
7649 fi
7650 done
7651
7652   fi
7653
7654
7655   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
7656 echo "configure:7657: checking for sqrtf declaration" >&5
7657   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
7658   echo $ac_n "(cached) $ac_c" 1>&6
7659 else
7660
7661
7662     ac_ext=C
7663 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7664 ac_cpp='$CXXCPP $CPPFLAGS'
7665 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7666 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7667 cross_compiling=$ac_cv_prog_cxx_cross
7668
7669     cat > conftest.$ac_ext <<EOF
7670 #line 7671 "configure"
7671 #include "confdefs.h"
7672 #include <math.h>
7673 int main() {
7674  sqrtf(0);
7675 ; return 0; }
7676 EOF
7677 if { (eval echo configure:7678: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7678   rm -rf conftest*
7679   glibcpp_cv_func_sqrtf_use=yes
7680 else
7681   echo "configure: failed program was:" >&5
7682   cat conftest.$ac_ext >&5
7683   rm -rf conftest*
7684   glibcpp_cv_func_sqrtf_use=no
7685 fi
7686 rm -f conftest*
7687     ac_ext=c
7688 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7689 ac_cpp='$CPP $CPPFLAGS'
7690 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7691 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7692 cross_compiling=$ac_cv_prog_cc_cross
7693
7694
7695 fi
7696
7697   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
7698   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
7699     for ac_func in sqrtf
7700 do
7701 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7702 echo "configure:7703: checking for $ac_func" >&5
7703 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7704   echo $ac_n "(cached) $ac_c" 1>&6
7705 else
7706   cat > conftest.$ac_ext <<EOF
7707 #line 7708 "configure"
7708 #include "confdefs.h"
7709 /* System header to define __stub macros and hopefully few prototypes,
7710     which can conflict with char $ac_func(); below.  */
7711 #include <assert.h>
7712 /* Override any gcc2 internal prototype to avoid an error.  */
7713 /* We use char because int might match the return type of a gcc2
7714     builtin and then its argument prototype would still apply.  */
7715 char $ac_func();
7716
7717 int main() {
7718
7719 /* The GNU C library defines this for functions which it implements
7720     to always fail with ENOSYS.  Some functions are actually named
7721     something starting with __ and the normal name is an alias.  */
7722 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7723 choke me
7724 #else
7725 $ac_func();
7726 #endif
7727
7728 ; return 0; }
7729 EOF
7730 if { (eval echo configure:7731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7731   rm -rf conftest*
7732   eval "ac_cv_func_$ac_func=yes"
7733 else
7734   echo "configure: failed program was:" >&5
7735   cat conftest.$ac_ext >&5
7736   rm -rf conftest*
7737   eval "ac_cv_func_$ac_func=no"
7738 fi
7739 rm -f conftest*
7740 fi
7741
7742 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7743   echo "$ac_t""yes" 1>&6
7744     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7745   cat >> confdefs.h <<EOF
7746 #define $ac_tr_func 1
7747 EOF
7748
7749 else
7750   echo "$ac_t""no" 1>&6
7751 fi
7752 done
7753
7754   fi
7755
7756
7757   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
7758 echo "configure:7759: checking for tanf declaration" >&5
7759   if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
7760   echo $ac_n "(cached) $ac_c" 1>&6
7761 else
7762
7763
7764     ac_ext=C
7765 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7766 ac_cpp='$CXXCPP $CPPFLAGS'
7767 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7768 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7769 cross_compiling=$ac_cv_prog_cxx_cross
7770
7771     cat > conftest.$ac_ext <<EOF
7772 #line 7773 "configure"
7773 #include "confdefs.h"
7774 #include <math.h>
7775 int main() {
7776  tanf(0);
7777 ; return 0; }
7778 EOF
7779 if { (eval echo configure:7780: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7780   rm -rf conftest*
7781   glibcpp_cv_func_tanf_use=yes
7782 else
7783   echo "configure: failed program was:" >&5
7784   cat conftest.$ac_ext >&5
7785   rm -rf conftest*
7786   glibcpp_cv_func_tanf_use=no
7787 fi
7788 rm -f conftest*
7789     ac_ext=c
7790 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7791 ac_cpp='$CPP $CPPFLAGS'
7792 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7793 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7794 cross_compiling=$ac_cv_prog_cc_cross
7795
7796
7797 fi
7798
7799   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
7800   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
7801     for ac_func in tanf
7802 do
7803 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7804 echo "configure:7805: checking for $ac_func" >&5
7805 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7806   echo $ac_n "(cached) $ac_c" 1>&6
7807 else
7808   cat > conftest.$ac_ext <<EOF
7809 #line 7810 "configure"
7810 #include "confdefs.h"
7811 /* System header to define __stub macros and hopefully few prototypes,
7812     which can conflict with char $ac_func(); below.  */
7813 #include <assert.h>
7814 /* Override any gcc2 internal prototype to avoid an error.  */
7815 /* We use char because int might match the return type of a gcc2
7816     builtin and then its argument prototype would still apply.  */
7817 char $ac_func();
7818
7819 int main() {
7820
7821 /* The GNU C library defines this for functions which it implements
7822     to always fail with ENOSYS.  Some functions are actually named
7823     something starting with __ and the normal name is an alias.  */
7824 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7825 choke me
7826 #else
7827 $ac_func();
7828 #endif
7829
7830 ; return 0; }
7831 EOF
7832 if { (eval echo configure:7833: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7833   rm -rf conftest*
7834   eval "ac_cv_func_$ac_func=yes"
7835 else
7836   echo "configure: failed program was:" >&5
7837   cat conftest.$ac_ext >&5
7838   rm -rf conftest*
7839   eval "ac_cv_func_$ac_func=no"
7840 fi
7841 rm -f conftest*
7842 fi
7843
7844 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7845   echo "$ac_t""yes" 1>&6
7846     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7847   cat >> confdefs.h <<EOF
7848 #define $ac_tr_func 1
7849 EOF
7850
7851 else
7852   echo "$ac_t""no" 1>&6
7853 fi
7854 done
7855
7856   fi
7857
7858
7859   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
7860 echo "configure:7861: checking for tanhf declaration" >&5
7861   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
7862   echo $ac_n "(cached) $ac_c" 1>&6
7863 else
7864
7865
7866     ac_ext=C
7867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7868 ac_cpp='$CXXCPP $CPPFLAGS'
7869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7871 cross_compiling=$ac_cv_prog_cxx_cross
7872
7873     cat > conftest.$ac_ext <<EOF
7874 #line 7875 "configure"
7875 #include "confdefs.h"
7876 #include <math.h>
7877 int main() {
7878  tanhf(0);
7879 ; return 0; }
7880 EOF
7881 if { (eval echo configure:7882: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7882   rm -rf conftest*
7883   glibcpp_cv_func_tanhf_use=yes
7884 else
7885   echo "configure: failed program was:" >&5
7886   cat conftest.$ac_ext >&5
7887   rm -rf conftest*
7888   glibcpp_cv_func_tanhf_use=no
7889 fi
7890 rm -f conftest*
7891     ac_ext=c
7892 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7893 ac_cpp='$CPP $CPPFLAGS'
7894 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7895 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7896 cross_compiling=$ac_cv_prog_cc_cross
7897
7898
7899 fi
7900
7901   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
7902   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
7903     for ac_func in tanhf
7904 do
7905 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7906 echo "configure:7907: checking for $ac_func" >&5
7907 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7908   echo $ac_n "(cached) $ac_c" 1>&6
7909 else
7910   cat > conftest.$ac_ext <<EOF
7911 #line 7912 "configure"
7912 #include "confdefs.h"
7913 /* System header to define __stub macros and hopefully few prototypes,
7914     which can conflict with char $ac_func(); below.  */
7915 #include <assert.h>
7916 /* Override any gcc2 internal prototype to avoid an error.  */
7917 /* We use char because int might match the return type of a gcc2
7918     builtin and then its argument prototype would still apply.  */
7919 char $ac_func();
7920
7921 int main() {
7922
7923 /* The GNU C library defines this for functions which it implements
7924     to always fail with ENOSYS.  Some functions are actually named
7925     something starting with __ and the normal name is an alias.  */
7926 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7927 choke me
7928 #else
7929 $ac_func();
7930 #endif
7931
7932 ; return 0; }
7933 EOF
7934 if { (eval echo configure:7935: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7935   rm -rf conftest*
7936   eval "ac_cv_func_$ac_func=yes"
7937 else
7938   echo "configure: failed program was:" >&5
7939   cat conftest.$ac_ext >&5
7940   rm -rf conftest*
7941   eval "ac_cv_func_$ac_func=no"
7942 fi
7943 rm -f conftest*
7944 fi
7945
7946 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7947   echo "$ac_t""yes" 1>&6
7948     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7949   cat >> confdefs.h <<EOF
7950 #define $ac_tr_func 1
7951 EOF
7952
7953 else
7954   echo "$ac_t""no" 1>&6
7955 fi
7956 done
7957
7958   fi
7959
7960
7961   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7962 echo "configure:7963: checking for sincosf declaration" >&5
7963   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
7964   echo $ac_n "(cached) $ac_c" 1>&6
7965 else
7966
7967
7968     ac_ext=C
7969 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7970 ac_cpp='$CXXCPP $CPPFLAGS'
7971 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7972 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7973 cross_compiling=$ac_cv_prog_cxx_cross
7974
7975     cat > conftest.$ac_ext <<EOF
7976 #line 7977 "configure"
7977 #include "confdefs.h"
7978 #include <math.h>
7979 int main() {
7980  sincosf(0, 0, 0);
7981 ; return 0; }
7982 EOF
7983 if { (eval echo configure:7984: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7984   rm -rf conftest*
7985   glibcpp_cv_func_sincosf_use=yes
7986 else
7987   echo "configure: failed program was:" >&5
7988   cat conftest.$ac_ext >&5
7989   rm -rf conftest*
7990   glibcpp_cv_func_sincosf_use=no
7991 fi
7992 rm -f conftest*
7993     ac_ext=c
7994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7995 ac_cpp='$CPP $CPPFLAGS'
7996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7998 cross_compiling=$ac_cv_prog_cc_cross
7999
8000
8001 fi
8002
8003   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
8004   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
8005     for ac_func in sincosf
8006 do
8007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8008 echo "configure:8009: checking for $ac_func" >&5
8009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8010   echo $ac_n "(cached) $ac_c" 1>&6
8011 else
8012   cat > conftest.$ac_ext <<EOF
8013 #line 8014 "configure"
8014 #include "confdefs.h"
8015 /* System header to define __stub macros and hopefully few prototypes,
8016     which can conflict with char $ac_func(); below.  */
8017 #include <assert.h>
8018 /* Override any gcc2 internal prototype to avoid an error.  */
8019 /* We use char because int might match the return type of a gcc2
8020     builtin and then its argument prototype would still apply.  */
8021 char $ac_func();
8022
8023 int main() {
8024
8025 /* The GNU C library defines this for functions which it implements
8026     to always fail with ENOSYS.  Some functions are actually named
8027     something starting with __ and the normal name is an alias.  */
8028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8029 choke me
8030 #else
8031 $ac_func();
8032 #endif
8033
8034 ; return 0; }
8035 EOF
8036 if { (eval echo configure:8037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8037   rm -rf conftest*
8038   eval "ac_cv_func_$ac_func=yes"
8039 else
8040   echo "configure: failed program was:" >&5
8041   cat conftest.$ac_ext >&5
8042   rm -rf conftest*
8043   eval "ac_cv_func_$ac_func=no"
8044 fi
8045 rm -f conftest*
8046 fi
8047
8048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8049   echo "$ac_t""yes" 1>&6
8050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8051   cat >> confdefs.h <<EOF
8052 #define $ac_tr_func 1
8053 EOF
8054
8055 else
8056   echo "$ac_t""no" 1>&6
8057 fi
8058 done
8059
8060   fi
8061
8062
8063   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
8064 echo "configure:8065: checking for finitef declaration" >&5
8065   if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
8066   echo $ac_n "(cached) $ac_c" 1>&6
8067 else
8068
8069
8070     ac_ext=C
8071 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8072 ac_cpp='$CXXCPP $CPPFLAGS'
8073 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8074 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8075 cross_compiling=$ac_cv_prog_cxx_cross
8076
8077     cat > conftest.$ac_ext <<EOF
8078 #line 8079 "configure"
8079 #include "confdefs.h"
8080 #include <math.h>
8081 int main() {
8082  finitef(0);
8083 ; return 0; }
8084 EOF
8085 if { (eval echo configure:8086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8086   rm -rf conftest*
8087   glibcpp_cv_func_finitef_use=yes
8088 else
8089   echo "configure: failed program was:" >&5
8090   cat conftest.$ac_ext >&5
8091   rm -rf conftest*
8092   glibcpp_cv_func_finitef_use=no
8093 fi
8094 rm -f conftest*
8095     ac_ext=c
8096 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8097 ac_cpp='$CPP $CPPFLAGS'
8098 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8099 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8100 cross_compiling=$ac_cv_prog_cc_cross
8101
8102
8103 fi
8104
8105   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
8106   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
8107     for ac_func in finitef
8108 do
8109 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8110 echo "configure:8111: checking for $ac_func" >&5
8111 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8112   echo $ac_n "(cached) $ac_c" 1>&6
8113 else
8114   cat > conftest.$ac_ext <<EOF
8115 #line 8116 "configure"
8116 #include "confdefs.h"
8117 /* System header to define __stub macros and hopefully few prototypes,
8118     which can conflict with char $ac_func(); below.  */
8119 #include <assert.h>
8120 /* Override any gcc2 internal prototype to avoid an error.  */
8121 /* We use char because int might match the return type of a gcc2
8122     builtin and then its argument prototype would still apply.  */
8123 char $ac_func();
8124
8125 int main() {
8126
8127 /* The GNU C library defines this for functions which it implements
8128     to always fail with ENOSYS.  Some functions are actually named
8129     something starting with __ and the normal name is an alias.  */
8130 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8131 choke me
8132 #else
8133 $ac_func();
8134 #endif
8135
8136 ; return 0; }
8137 EOF
8138 if { (eval echo configure:8139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8139   rm -rf conftest*
8140   eval "ac_cv_func_$ac_func=yes"
8141 else
8142   echo "configure: failed program was:" >&5
8143   cat conftest.$ac_ext >&5
8144   rm -rf conftest*
8145   eval "ac_cv_func_$ac_func=no"
8146 fi
8147 rm -f conftest*
8148 fi
8149
8150 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8151   echo "$ac_t""yes" 1>&6
8152     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8153   cat >> confdefs.h <<EOF
8154 #define $ac_tr_func 1
8155 EOF
8156
8157 else
8158   echo "$ac_t""no" 1>&6
8159 fi
8160 done
8161
8162   fi
8163
8164
8165
8166   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
8167 echo "configure:8168: checking for isnanl declaration" >&5
8168   if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
8169   echo $ac_n "(cached) $ac_c" 1>&6
8170 else
8171
8172
8173     ac_ext=C
8174 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8175 ac_cpp='$CXXCPP $CPPFLAGS'
8176 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8177 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8178 cross_compiling=$ac_cv_prog_cxx_cross
8179
8180     cat > conftest.$ac_ext <<EOF
8181 #line 8182 "configure"
8182 #include "confdefs.h"
8183 #include <math.h>
8184 int main() {
8185  isnanl(0);
8186 ; return 0; }
8187 EOF
8188 if { (eval echo configure:8189: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8189   rm -rf conftest*
8190   glibcpp_cv_func_isnanl_use=yes
8191 else
8192   echo "configure: failed program was:" >&5
8193   cat conftest.$ac_ext >&5
8194   rm -rf conftest*
8195   glibcpp_cv_func_isnanl_use=no
8196 fi
8197 rm -f conftest*
8198     ac_ext=c
8199 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8200 ac_cpp='$CPP $CPPFLAGS'
8201 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8202 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8203 cross_compiling=$ac_cv_prog_cc_cross
8204
8205
8206 fi
8207
8208   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
8209   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
8210     for ac_func in isnanl
8211 do
8212 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8213 echo "configure:8214: checking for $ac_func" >&5
8214 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8215   echo $ac_n "(cached) $ac_c" 1>&6
8216 else
8217   cat > conftest.$ac_ext <<EOF
8218 #line 8219 "configure"
8219 #include "confdefs.h"
8220 /* System header to define __stub macros and hopefully few prototypes,
8221     which can conflict with char $ac_func(); below.  */
8222 #include <assert.h>
8223 /* Override any gcc2 internal prototype to avoid an error.  */
8224 /* We use char because int might match the return type of a gcc2
8225     builtin and then its argument prototype would still apply.  */
8226 char $ac_func();
8227
8228 int main() {
8229
8230 /* The GNU C library defines this for functions which it implements
8231     to always fail with ENOSYS.  Some functions are actually named
8232     something starting with __ and the normal name is an alias.  */
8233 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8234 choke me
8235 #else
8236 $ac_func();
8237 #endif
8238
8239 ; return 0; }
8240 EOF
8241 if { (eval echo configure:8242: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8242   rm -rf conftest*
8243   eval "ac_cv_func_$ac_func=yes"
8244 else
8245   echo "configure: failed program was:" >&5
8246   cat conftest.$ac_ext >&5
8247   rm -rf conftest*
8248   eval "ac_cv_func_$ac_func=no"
8249 fi
8250 rm -f conftest*
8251 fi
8252
8253 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8254   echo "$ac_t""yes" 1>&6
8255     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8256   cat >> confdefs.h <<EOF
8257 #define $ac_tr_func 1
8258 EOF
8259
8260 else
8261   echo "$ac_t""no" 1>&6
8262 fi
8263 done
8264
8265   fi
8266
8267
8268   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
8269 echo "configure:8270: checking for isinfl declaration" >&5
8270   if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
8271   echo $ac_n "(cached) $ac_c" 1>&6
8272 else
8273
8274
8275     ac_ext=C
8276 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8277 ac_cpp='$CXXCPP $CPPFLAGS'
8278 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8279 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8280 cross_compiling=$ac_cv_prog_cxx_cross
8281
8282     cat > conftest.$ac_ext <<EOF
8283 #line 8284 "configure"
8284 #include "confdefs.h"
8285 #include <math.h>
8286 int main() {
8287  isinfl(0);
8288 ; return 0; }
8289 EOF
8290 if { (eval echo configure:8291: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8291   rm -rf conftest*
8292   glibcpp_cv_func_isinfl_use=yes
8293 else
8294   echo "configure: failed program was:" >&5
8295   cat conftest.$ac_ext >&5
8296   rm -rf conftest*
8297   glibcpp_cv_func_isinfl_use=no
8298 fi
8299 rm -f conftest*
8300     ac_ext=c
8301 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8302 ac_cpp='$CPP $CPPFLAGS'
8303 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8304 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8305 cross_compiling=$ac_cv_prog_cc_cross
8306
8307
8308 fi
8309
8310   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
8311   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
8312     for ac_func in isinfl
8313 do
8314 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8315 echo "configure:8316: checking for $ac_func" >&5
8316 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8317   echo $ac_n "(cached) $ac_c" 1>&6
8318 else
8319   cat > conftest.$ac_ext <<EOF
8320 #line 8321 "configure"
8321 #include "confdefs.h"
8322 /* System header to define __stub macros and hopefully few prototypes,
8323     which can conflict with char $ac_func(); below.  */
8324 #include <assert.h>
8325 /* Override any gcc2 internal prototype to avoid an error.  */
8326 /* We use char because int might match the return type of a gcc2
8327     builtin and then its argument prototype would still apply.  */
8328 char $ac_func();
8329
8330 int main() {
8331
8332 /* The GNU C library defines this for functions which it implements
8333     to always fail with ENOSYS.  Some functions are actually named
8334     something starting with __ and the normal name is an alias.  */
8335 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8336 choke me
8337 #else
8338 $ac_func();
8339 #endif
8340
8341 ; return 0; }
8342 EOF
8343 if { (eval echo configure:8344: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8344   rm -rf conftest*
8345   eval "ac_cv_func_$ac_func=yes"
8346 else
8347   echo "configure: failed program was:" >&5
8348   cat conftest.$ac_ext >&5
8349   rm -rf conftest*
8350   eval "ac_cv_func_$ac_func=no"
8351 fi
8352 rm -f conftest*
8353 fi
8354
8355 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8356   echo "$ac_t""yes" 1>&6
8357     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8358   cat >> confdefs.h <<EOF
8359 #define $ac_tr_func 1
8360 EOF
8361
8362 else
8363   echo "$ac_t""no" 1>&6
8364 fi
8365 done
8366
8367   fi
8368
8369
8370   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
8371 echo "configure:8372: checking for copysignl declaration" >&5
8372   if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
8373   echo $ac_n "(cached) $ac_c" 1>&6
8374 else
8375
8376
8377     ac_ext=C
8378 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8379 ac_cpp='$CXXCPP $CPPFLAGS'
8380 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8381 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8382 cross_compiling=$ac_cv_prog_cxx_cross
8383
8384     cat > conftest.$ac_ext <<EOF
8385 #line 8386 "configure"
8386 #include "confdefs.h"
8387 #include <math.h>
8388 int main() {
8389  copysignl(0, 0);
8390 ; return 0; }
8391 EOF
8392 if { (eval echo configure:8393: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8393   rm -rf conftest*
8394   glibcpp_cv_func_copysignl_use=yes
8395 else
8396   echo "configure: failed program was:" >&5
8397   cat conftest.$ac_ext >&5
8398   rm -rf conftest*
8399   glibcpp_cv_func_copysignl_use=no
8400 fi
8401 rm -f conftest*
8402     ac_ext=c
8403 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8404 ac_cpp='$CPP $CPPFLAGS'
8405 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8406 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8407 cross_compiling=$ac_cv_prog_cc_cross
8408
8409
8410 fi
8411
8412   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
8413   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
8414     for ac_func in copysignl
8415 do
8416 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8417 echo "configure:8418: checking for $ac_func" >&5
8418 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8419   echo $ac_n "(cached) $ac_c" 1>&6
8420 else
8421   cat > conftest.$ac_ext <<EOF
8422 #line 8423 "configure"
8423 #include "confdefs.h"
8424 /* System header to define __stub macros and hopefully few prototypes,
8425     which can conflict with char $ac_func(); below.  */
8426 #include <assert.h>
8427 /* Override any gcc2 internal prototype to avoid an error.  */
8428 /* We use char because int might match the return type of a gcc2
8429     builtin and then its argument prototype would still apply.  */
8430 char $ac_func();
8431
8432 int main() {
8433
8434 /* The GNU C library defines this for functions which it implements
8435     to always fail with ENOSYS.  Some functions are actually named
8436     something starting with __ and the normal name is an alias.  */
8437 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8438 choke me
8439 #else
8440 $ac_func();
8441 #endif
8442
8443 ; return 0; }
8444 EOF
8445 if { (eval echo configure:8446: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8446   rm -rf conftest*
8447   eval "ac_cv_func_$ac_func=yes"
8448 else
8449   echo "configure: failed program was:" >&5
8450   cat conftest.$ac_ext >&5
8451   rm -rf conftest*
8452   eval "ac_cv_func_$ac_func=no"
8453 fi
8454 rm -f conftest*
8455 fi
8456
8457 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8458   echo "$ac_t""yes" 1>&6
8459     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8460   cat >> confdefs.h <<EOF
8461 #define $ac_tr_func 1
8462 EOF
8463
8464 else
8465   echo "$ac_t""no" 1>&6
8466 fi
8467 done
8468
8469   fi
8470
8471
8472   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
8473 echo "configure:8474: checking for acosl declaration" >&5
8474   if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
8475   echo $ac_n "(cached) $ac_c" 1>&6
8476 else
8477
8478
8479     ac_ext=C
8480 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8481 ac_cpp='$CXXCPP $CPPFLAGS'
8482 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8483 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8484 cross_compiling=$ac_cv_prog_cxx_cross
8485
8486     cat > conftest.$ac_ext <<EOF
8487 #line 8488 "configure"
8488 #include "confdefs.h"
8489 #include <math.h>
8490 int main() {
8491  acosl(0);
8492 ; return 0; }
8493 EOF
8494 if { (eval echo configure:8495: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8495   rm -rf conftest*
8496   glibcpp_cv_func_acosl_use=yes
8497 else
8498   echo "configure: failed program was:" >&5
8499   cat conftest.$ac_ext >&5
8500   rm -rf conftest*
8501   glibcpp_cv_func_acosl_use=no
8502 fi
8503 rm -f conftest*
8504     ac_ext=c
8505 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8506 ac_cpp='$CPP $CPPFLAGS'
8507 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8508 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8509 cross_compiling=$ac_cv_prog_cc_cross
8510
8511
8512 fi
8513
8514   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
8515   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
8516     for ac_func in acosl
8517 do
8518 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8519 echo "configure:8520: checking for $ac_func" >&5
8520 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8521   echo $ac_n "(cached) $ac_c" 1>&6
8522 else
8523   cat > conftest.$ac_ext <<EOF
8524 #line 8525 "configure"
8525 #include "confdefs.h"
8526 /* System header to define __stub macros and hopefully few prototypes,
8527     which can conflict with char $ac_func(); below.  */
8528 #include <assert.h>
8529 /* Override any gcc2 internal prototype to avoid an error.  */
8530 /* We use char because int might match the return type of a gcc2
8531     builtin and then its argument prototype would still apply.  */
8532 char $ac_func();
8533
8534 int main() {
8535
8536 /* The GNU C library defines this for functions which it implements
8537     to always fail with ENOSYS.  Some functions are actually named
8538     something starting with __ and the normal name is an alias.  */
8539 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8540 choke me
8541 #else
8542 $ac_func();
8543 #endif
8544
8545 ; return 0; }
8546 EOF
8547 if { (eval echo configure:8548: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8548   rm -rf conftest*
8549   eval "ac_cv_func_$ac_func=yes"
8550 else
8551   echo "configure: failed program was:" >&5
8552   cat conftest.$ac_ext >&5
8553   rm -rf conftest*
8554   eval "ac_cv_func_$ac_func=no"
8555 fi
8556 rm -f conftest*
8557 fi
8558
8559 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8560   echo "$ac_t""yes" 1>&6
8561     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8562   cat >> confdefs.h <<EOF
8563 #define $ac_tr_func 1
8564 EOF
8565
8566 else
8567   echo "$ac_t""no" 1>&6
8568 fi
8569 done
8570
8571   fi
8572
8573
8574   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
8575 echo "configure:8576: checking for asinl declaration" >&5
8576   if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
8577   echo $ac_n "(cached) $ac_c" 1>&6
8578 else
8579
8580
8581     ac_ext=C
8582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8583 ac_cpp='$CXXCPP $CPPFLAGS'
8584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8586 cross_compiling=$ac_cv_prog_cxx_cross
8587
8588     cat > conftest.$ac_ext <<EOF
8589 #line 8590 "configure"
8590 #include "confdefs.h"
8591 #include <math.h>
8592 int main() {
8593  asinl(0);
8594 ; return 0; }
8595 EOF
8596 if { (eval echo configure:8597: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8597   rm -rf conftest*
8598   glibcpp_cv_func_asinl_use=yes
8599 else
8600   echo "configure: failed program was:" >&5
8601   cat conftest.$ac_ext >&5
8602   rm -rf conftest*
8603   glibcpp_cv_func_asinl_use=no
8604 fi
8605 rm -f conftest*
8606     ac_ext=c
8607 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8608 ac_cpp='$CPP $CPPFLAGS'
8609 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8610 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8611 cross_compiling=$ac_cv_prog_cc_cross
8612
8613
8614 fi
8615
8616   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
8617   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
8618     for ac_func in asinl
8619 do
8620 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8621 echo "configure:8622: checking for $ac_func" >&5
8622 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8623   echo $ac_n "(cached) $ac_c" 1>&6
8624 else
8625   cat > conftest.$ac_ext <<EOF
8626 #line 8627 "configure"
8627 #include "confdefs.h"
8628 /* System header to define __stub macros and hopefully few prototypes,
8629     which can conflict with char $ac_func(); below.  */
8630 #include <assert.h>
8631 /* Override any gcc2 internal prototype to avoid an error.  */
8632 /* We use char because int might match the return type of a gcc2
8633     builtin and then its argument prototype would still apply.  */
8634 char $ac_func();
8635
8636 int main() {
8637
8638 /* The GNU C library defines this for functions which it implements
8639     to always fail with ENOSYS.  Some functions are actually named
8640     something starting with __ and the normal name is an alias.  */
8641 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8642 choke me
8643 #else
8644 $ac_func();
8645 #endif
8646
8647 ; return 0; }
8648 EOF
8649 if { (eval echo configure:8650: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8650   rm -rf conftest*
8651   eval "ac_cv_func_$ac_func=yes"
8652 else
8653   echo "configure: failed program was:" >&5
8654   cat conftest.$ac_ext >&5
8655   rm -rf conftest*
8656   eval "ac_cv_func_$ac_func=no"
8657 fi
8658 rm -f conftest*
8659 fi
8660
8661 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8662   echo "$ac_t""yes" 1>&6
8663     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8664   cat >> confdefs.h <<EOF
8665 #define $ac_tr_func 1
8666 EOF
8667
8668 else
8669   echo "$ac_t""no" 1>&6
8670 fi
8671 done
8672
8673   fi
8674
8675
8676   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
8677 echo "configure:8678: checking for atanl declaration" >&5
8678   if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
8679   echo $ac_n "(cached) $ac_c" 1>&6
8680 else
8681
8682
8683     ac_ext=C
8684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8685 ac_cpp='$CXXCPP $CPPFLAGS'
8686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8688 cross_compiling=$ac_cv_prog_cxx_cross
8689
8690     cat > conftest.$ac_ext <<EOF
8691 #line 8692 "configure"
8692 #include "confdefs.h"
8693 #include <math.h>
8694 int main() {
8695  atanl(0);
8696 ; return 0; }
8697 EOF
8698 if { (eval echo configure:8699: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8699   rm -rf conftest*
8700   glibcpp_cv_func_atanl_use=yes
8701 else
8702   echo "configure: failed program was:" >&5
8703   cat conftest.$ac_ext >&5
8704   rm -rf conftest*
8705   glibcpp_cv_func_atanl_use=no
8706 fi
8707 rm -f conftest*
8708     ac_ext=c
8709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8710 ac_cpp='$CPP $CPPFLAGS'
8711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8713 cross_compiling=$ac_cv_prog_cc_cross
8714
8715
8716 fi
8717
8718   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
8719   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
8720     for ac_func in atanl
8721 do
8722 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8723 echo "configure:8724: checking for $ac_func" >&5
8724 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8725   echo $ac_n "(cached) $ac_c" 1>&6
8726 else
8727   cat > conftest.$ac_ext <<EOF
8728 #line 8729 "configure"
8729 #include "confdefs.h"
8730 /* System header to define __stub macros and hopefully few prototypes,
8731     which can conflict with char $ac_func(); below.  */
8732 #include <assert.h>
8733 /* Override any gcc2 internal prototype to avoid an error.  */
8734 /* We use char because int might match the return type of a gcc2
8735     builtin and then its argument prototype would still apply.  */
8736 char $ac_func();
8737
8738 int main() {
8739
8740 /* The GNU C library defines this for functions which it implements
8741     to always fail with ENOSYS.  Some functions are actually named
8742     something starting with __ and the normal name is an alias.  */
8743 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8744 choke me
8745 #else
8746 $ac_func();
8747 #endif
8748
8749 ; return 0; }
8750 EOF
8751 if { (eval echo configure:8752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8752   rm -rf conftest*
8753   eval "ac_cv_func_$ac_func=yes"
8754 else
8755   echo "configure: failed program was:" >&5
8756   cat conftest.$ac_ext >&5
8757   rm -rf conftest*
8758   eval "ac_cv_func_$ac_func=no"
8759 fi
8760 rm -f conftest*
8761 fi
8762
8763 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8764   echo "$ac_t""yes" 1>&6
8765     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8766   cat >> confdefs.h <<EOF
8767 #define $ac_tr_func 1
8768 EOF
8769
8770 else
8771   echo "$ac_t""no" 1>&6
8772 fi
8773 done
8774
8775   fi
8776
8777
8778   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
8779 echo "configure:8780: checking for atan2l declaration" >&5
8780   if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
8781   echo $ac_n "(cached) $ac_c" 1>&6
8782 else
8783
8784
8785     ac_ext=C
8786 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8787 ac_cpp='$CXXCPP $CPPFLAGS'
8788 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8789 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8790 cross_compiling=$ac_cv_prog_cxx_cross
8791
8792     cat > conftest.$ac_ext <<EOF
8793 #line 8794 "configure"
8794 #include "confdefs.h"
8795 #include <math.h>
8796 int main() {
8797  atan2l(0, 0);
8798 ; return 0; }
8799 EOF
8800 if { (eval echo configure:8801: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8801   rm -rf conftest*
8802   glibcpp_cv_func_atan2l_use=yes
8803 else
8804   echo "configure: failed program was:" >&5
8805   cat conftest.$ac_ext >&5
8806   rm -rf conftest*
8807   glibcpp_cv_func_atan2l_use=no
8808 fi
8809 rm -f conftest*
8810     ac_ext=c
8811 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8812 ac_cpp='$CPP $CPPFLAGS'
8813 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8814 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8815 cross_compiling=$ac_cv_prog_cc_cross
8816
8817
8818 fi
8819
8820   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
8821   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
8822     for ac_func in atan2l
8823 do
8824 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8825 echo "configure:8826: checking for $ac_func" >&5
8826 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8827   echo $ac_n "(cached) $ac_c" 1>&6
8828 else
8829   cat > conftest.$ac_ext <<EOF
8830 #line 8831 "configure"
8831 #include "confdefs.h"
8832 /* System header to define __stub macros and hopefully few prototypes,
8833     which can conflict with char $ac_func(); below.  */
8834 #include <assert.h>
8835 /* Override any gcc2 internal prototype to avoid an error.  */
8836 /* We use char because int might match the return type of a gcc2
8837     builtin and then its argument prototype would still apply.  */
8838 char $ac_func();
8839
8840 int main() {
8841
8842 /* The GNU C library defines this for functions which it implements
8843     to always fail with ENOSYS.  Some functions are actually named
8844     something starting with __ and the normal name is an alias.  */
8845 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8846 choke me
8847 #else
8848 $ac_func();
8849 #endif
8850
8851 ; return 0; }
8852 EOF
8853 if { (eval echo configure:8854: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8854   rm -rf conftest*
8855   eval "ac_cv_func_$ac_func=yes"
8856 else
8857   echo "configure: failed program was:" >&5
8858   cat conftest.$ac_ext >&5
8859   rm -rf conftest*
8860   eval "ac_cv_func_$ac_func=no"
8861 fi
8862 rm -f conftest*
8863 fi
8864
8865 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8866   echo "$ac_t""yes" 1>&6
8867     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8868   cat >> confdefs.h <<EOF
8869 #define $ac_tr_func 1
8870 EOF
8871
8872 else
8873   echo "$ac_t""no" 1>&6
8874 fi
8875 done
8876
8877   fi
8878
8879
8880   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
8881 echo "configure:8882: checking for ceill declaration" >&5
8882   if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
8883   echo $ac_n "(cached) $ac_c" 1>&6
8884 else
8885
8886
8887     ac_ext=C
8888 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8889 ac_cpp='$CXXCPP $CPPFLAGS'
8890 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8891 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8892 cross_compiling=$ac_cv_prog_cxx_cross
8893
8894     cat > conftest.$ac_ext <<EOF
8895 #line 8896 "configure"
8896 #include "confdefs.h"
8897 #include <math.h>
8898 int main() {
8899  ceill(0);
8900 ; return 0; }
8901 EOF
8902 if { (eval echo configure:8903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8903   rm -rf conftest*
8904   glibcpp_cv_func_ceill_use=yes
8905 else
8906   echo "configure: failed program was:" >&5
8907   cat conftest.$ac_ext >&5
8908   rm -rf conftest*
8909   glibcpp_cv_func_ceill_use=no
8910 fi
8911 rm -f conftest*
8912     ac_ext=c
8913 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8914 ac_cpp='$CPP $CPPFLAGS'
8915 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8916 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8917 cross_compiling=$ac_cv_prog_cc_cross
8918
8919
8920 fi
8921
8922   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
8923   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
8924     for ac_func in ceill
8925 do
8926 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8927 echo "configure:8928: checking for $ac_func" >&5
8928 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8929   echo $ac_n "(cached) $ac_c" 1>&6
8930 else
8931   cat > conftest.$ac_ext <<EOF
8932 #line 8933 "configure"
8933 #include "confdefs.h"
8934 /* System header to define __stub macros and hopefully few prototypes,
8935     which can conflict with char $ac_func(); below.  */
8936 #include <assert.h>
8937 /* Override any gcc2 internal prototype to avoid an error.  */
8938 /* We use char because int might match the return type of a gcc2
8939     builtin and then its argument prototype would still apply.  */
8940 char $ac_func();
8941
8942 int main() {
8943
8944 /* The GNU C library defines this for functions which it implements
8945     to always fail with ENOSYS.  Some functions are actually named
8946     something starting with __ and the normal name is an alias.  */
8947 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8948 choke me
8949 #else
8950 $ac_func();
8951 #endif
8952
8953 ; return 0; }
8954 EOF
8955 if { (eval echo configure:8956: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8956   rm -rf conftest*
8957   eval "ac_cv_func_$ac_func=yes"
8958 else
8959   echo "configure: failed program was:" >&5
8960   cat conftest.$ac_ext >&5
8961   rm -rf conftest*
8962   eval "ac_cv_func_$ac_func=no"
8963 fi
8964 rm -f conftest*
8965 fi
8966
8967 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8968   echo "$ac_t""yes" 1>&6
8969     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8970   cat >> confdefs.h <<EOF
8971 #define $ac_tr_func 1
8972 EOF
8973
8974 else
8975   echo "$ac_t""no" 1>&6
8976 fi
8977 done
8978
8979   fi
8980
8981
8982   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
8983 echo "configure:8984: checking for cosl declaration" >&5
8984   if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
8985   echo $ac_n "(cached) $ac_c" 1>&6
8986 else
8987
8988
8989     ac_ext=C
8990 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8991 ac_cpp='$CXXCPP $CPPFLAGS'
8992 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8993 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8994 cross_compiling=$ac_cv_prog_cxx_cross
8995
8996     cat > conftest.$ac_ext <<EOF
8997 #line 8998 "configure"
8998 #include "confdefs.h"
8999 #include <math.h>
9000 int main() {
9001  cosl(0);
9002 ; return 0; }
9003 EOF
9004 if { (eval echo configure:9005: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9005   rm -rf conftest*
9006   glibcpp_cv_func_cosl_use=yes
9007 else
9008   echo "configure: failed program was:" >&5
9009   cat conftest.$ac_ext >&5
9010   rm -rf conftest*
9011   glibcpp_cv_func_cosl_use=no
9012 fi
9013 rm -f conftest*
9014     ac_ext=c
9015 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9016 ac_cpp='$CPP $CPPFLAGS'
9017 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9018 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9019 cross_compiling=$ac_cv_prog_cc_cross
9020
9021
9022 fi
9023
9024   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
9025   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
9026     for ac_func in cosl
9027 do
9028 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9029 echo "configure:9030: checking for $ac_func" >&5
9030 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9031   echo $ac_n "(cached) $ac_c" 1>&6
9032 else
9033   cat > conftest.$ac_ext <<EOF
9034 #line 9035 "configure"
9035 #include "confdefs.h"
9036 /* System header to define __stub macros and hopefully few prototypes,
9037     which can conflict with char $ac_func(); below.  */
9038 #include <assert.h>
9039 /* Override any gcc2 internal prototype to avoid an error.  */
9040 /* We use char because int might match the return type of a gcc2
9041     builtin and then its argument prototype would still apply.  */
9042 char $ac_func();
9043
9044 int main() {
9045
9046 /* The GNU C library defines this for functions which it implements
9047     to always fail with ENOSYS.  Some functions are actually named
9048     something starting with __ and the normal name is an alias.  */
9049 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9050 choke me
9051 #else
9052 $ac_func();
9053 #endif
9054
9055 ; return 0; }
9056 EOF
9057 if { (eval echo configure:9058: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9058   rm -rf conftest*
9059   eval "ac_cv_func_$ac_func=yes"
9060 else
9061   echo "configure: failed program was:" >&5
9062   cat conftest.$ac_ext >&5
9063   rm -rf conftest*
9064   eval "ac_cv_func_$ac_func=no"
9065 fi
9066 rm -f conftest*
9067 fi
9068
9069 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9070   echo "$ac_t""yes" 1>&6
9071     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9072   cat >> confdefs.h <<EOF
9073 #define $ac_tr_func 1
9074 EOF
9075
9076 else
9077   echo "$ac_t""no" 1>&6
9078 fi
9079 done
9080
9081   fi
9082
9083
9084   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
9085 echo "configure:9086: checking for coshl declaration" >&5
9086   if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
9087   echo $ac_n "(cached) $ac_c" 1>&6
9088 else
9089
9090
9091     ac_ext=C
9092 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9093 ac_cpp='$CXXCPP $CPPFLAGS'
9094 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9095 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9096 cross_compiling=$ac_cv_prog_cxx_cross
9097
9098     cat > conftest.$ac_ext <<EOF
9099 #line 9100 "configure"
9100 #include "confdefs.h"
9101 #include <math.h>
9102 int main() {
9103  coshl(0);
9104 ; return 0; }
9105 EOF
9106 if { (eval echo configure:9107: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9107   rm -rf conftest*
9108   glibcpp_cv_func_coshl_use=yes
9109 else
9110   echo "configure: failed program was:" >&5
9111   cat conftest.$ac_ext >&5
9112   rm -rf conftest*
9113   glibcpp_cv_func_coshl_use=no
9114 fi
9115 rm -f conftest*
9116     ac_ext=c
9117 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9118 ac_cpp='$CPP $CPPFLAGS'
9119 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9120 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9121 cross_compiling=$ac_cv_prog_cc_cross
9122
9123
9124 fi
9125
9126   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
9127   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
9128     for ac_func in coshl
9129 do
9130 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9131 echo "configure:9132: checking for $ac_func" >&5
9132 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9133   echo $ac_n "(cached) $ac_c" 1>&6
9134 else
9135   cat > conftest.$ac_ext <<EOF
9136 #line 9137 "configure"
9137 #include "confdefs.h"
9138 /* System header to define __stub macros and hopefully few prototypes,
9139     which can conflict with char $ac_func(); below.  */
9140 #include <assert.h>
9141 /* Override any gcc2 internal prototype to avoid an error.  */
9142 /* We use char because int might match the return type of a gcc2
9143     builtin and then its argument prototype would still apply.  */
9144 char $ac_func();
9145
9146 int main() {
9147
9148 /* The GNU C library defines this for functions which it implements
9149     to always fail with ENOSYS.  Some functions are actually named
9150     something starting with __ and the normal name is an alias.  */
9151 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9152 choke me
9153 #else
9154 $ac_func();
9155 #endif
9156
9157 ; return 0; }
9158 EOF
9159 if { (eval echo configure:9160: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9160   rm -rf conftest*
9161   eval "ac_cv_func_$ac_func=yes"
9162 else
9163   echo "configure: failed program was:" >&5
9164   cat conftest.$ac_ext >&5
9165   rm -rf conftest*
9166   eval "ac_cv_func_$ac_func=no"
9167 fi
9168 rm -f conftest*
9169 fi
9170
9171 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9172   echo "$ac_t""yes" 1>&6
9173     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9174   cat >> confdefs.h <<EOF
9175 #define $ac_tr_func 1
9176 EOF
9177
9178 else
9179   echo "$ac_t""no" 1>&6
9180 fi
9181 done
9182
9183   fi
9184
9185
9186   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
9187 echo "configure:9188: checking for expl declaration" >&5
9188   if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
9189   echo $ac_n "(cached) $ac_c" 1>&6
9190 else
9191
9192
9193     ac_ext=C
9194 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9195 ac_cpp='$CXXCPP $CPPFLAGS'
9196 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9197 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9198 cross_compiling=$ac_cv_prog_cxx_cross
9199
9200     cat > conftest.$ac_ext <<EOF
9201 #line 9202 "configure"
9202 #include "confdefs.h"
9203 #include <math.h>
9204 int main() {
9205  expl(0);
9206 ; return 0; }
9207 EOF
9208 if { (eval echo configure:9209: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9209   rm -rf conftest*
9210   glibcpp_cv_func_expl_use=yes
9211 else
9212   echo "configure: failed program was:" >&5
9213   cat conftest.$ac_ext >&5
9214   rm -rf conftest*
9215   glibcpp_cv_func_expl_use=no
9216 fi
9217 rm -f conftest*
9218     ac_ext=c
9219 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9220 ac_cpp='$CPP $CPPFLAGS'
9221 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9222 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9223 cross_compiling=$ac_cv_prog_cc_cross
9224
9225
9226 fi
9227
9228   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
9229   if test x$glibcpp_cv_func_expl_use = x"yes"; then
9230     for ac_func in expl
9231 do
9232 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9233 echo "configure:9234: checking for $ac_func" >&5
9234 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9235   echo $ac_n "(cached) $ac_c" 1>&6
9236 else
9237   cat > conftest.$ac_ext <<EOF
9238 #line 9239 "configure"
9239 #include "confdefs.h"
9240 /* System header to define __stub macros and hopefully few prototypes,
9241     which can conflict with char $ac_func(); below.  */
9242 #include <assert.h>
9243 /* Override any gcc2 internal prototype to avoid an error.  */
9244 /* We use char because int might match the return type of a gcc2
9245     builtin and then its argument prototype would still apply.  */
9246 char $ac_func();
9247
9248 int main() {
9249
9250 /* The GNU C library defines this for functions which it implements
9251     to always fail with ENOSYS.  Some functions are actually named
9252     something starting with __ and the normal name is an alias.  */
9253 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9254 choke me
9255 #else
9256 $ac_func();
9257 #endif
9258
9259 ; return 0; }
9260 EOF
9261 if { (eval echo configure:9262: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9262   rm -rf conftest*
9263   eval "ac_cv_func_$ac_func=yes"
9264 else
9265   echo "configure: failed program was:" >&5
9266   cat conftest.$ac_ext >&5
9267   rm -rf conftest*
9268   eval "ac_cv_func_$ac_func=no"
9269 fi
9270 rm -f conftest*
9271 fi
9272
9273 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9274   echo "$ac_t""yes" 1>&6
9275     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9276   cat >> confdefs.h <<EOF
9277 #define $ac_tr_func 1
9278 EOF
9279
9280 else
9281   echo "$ac_t""no" 1>&6
9282 fi
9283 done
9284
9285   fi
9286
9287
9288   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
9289 echo "configure:9290: checking for fabsl declaration" >&5
9290   if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
9291   echo $ac_n "(cached) $ac_c" 1>&6
9292 else
9293
9294
9295     ac_ext=C
9296 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9297 ac_cpp='$CXXCPP $CPPFLAGS'
9298 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9299 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9300 cross_compiling=$ac_cv_prog_cxx_cross
9301
9302     cat > conftest.$ac_ext <<EOF
9303 #line 9304 "configure"
9304 #include "confdefs.h"
9305 #include <math.h>
9306 int main() {
9307  fabsl(0);
9308 ; return 0; }
9309 EOF
9310 if { (eval echo configure:9311: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9311   rm -rf conftest*
9312   glibcpp_cv_func_fabsl_use=yes
9313 else
9314   echo "configure: failed program was:" >&5
9315   cat conftest.$ac_ext >&5
9316   rm -rf conftest*
9317   glibcpp_cv_func_fabsl_use=no
9318 fi
9319 rm -f conftest*
9320     ac_ext=c
9321 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9322 ac_cpp='$CPP $CPPFLAGS'
9323 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9324 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9325 cross_compiling=$ac_cv_prog_cc_cross
9326
9327
9328 fi
9329
9330   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
9331   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
9332     for ac_func in fabsl
9333 do
9334 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9335 echo "configure:9336: checking for $ac_func" >&5
9336 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9337   echo $ac_n "(cached) $ac_c" 1>&6
9338 else
9339   cat > conftest.$ac_ext <<EOF
9340 #line 9341 "configure"
9341 #include "confdefs.h"
9342 /* System header to define __stub macros and hopefully few prototypes,
9343     which can conflict with char $ac_func(); below.  */
9344 #include <assert.h>
9345 /* Override any gcc2 internal prototype to avoid an error.  */
9346 /* We use char because int might match the return type of a gcc2
9347     builtin and then its argument prototype would still apply.  */
9348 char $ac_func();
9349
9350 int main() {
9351
9352 /* The GNU C library defines this for functions which it implements
9353     to always fail with ENOSYS.  Some functions are actually named
9354     something starting with __ and the normal name is an alias.  */
9355 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9356 choke me
9357 #else
9358 $ac_func();
9359 #endif
9360
9361 ; return 0; }
9362 EOF
9363 if { (eval echo configure:9364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9364   rm -rf conftest*
9365   eval "ac_cv_func_$ac_func=yes"
9366 else
9367   echo "configure: failed program was:" >&5
9368   cat conftest.$ac_ext >&5
9369   rm -rf conftest*
9370   eval "ac_cv_func_$ac_func=no"
9371 fi
9372 rm -f conftest*
9373 fi
9374
9375 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9376   echo "$ac_t""yes" 1>&6
9377     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9378   cat >> confdefs.h <<EOF
9379 #define $ac_tr_func 1
9380 EOF
9381
9382 else
9383   echo "$ac_t""no" 1>&6
9384 fi
9385 done
9386
9387   fi
9388
9389
9390   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
9391 echo "configure:9392: checking for floorl declaration" >&5
9392   if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
9393   echo $ac_n "(cached) $ac_c" 1>&6
9394 else
9395
9396
9397     ac_ext=C
9398 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9399 ac_cpp='$CXXCPP $CPPFLAGS'
9400 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9401 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9402 cross_compiling=$ac_cv_prog_cxx_cross
9403
9404     cat > conftest.$ac_ext <<EOF
9405 #line 9406 "configure"
9406 #include "confdefs.h"
9407 #include <math.h>
9408 int main() {
9409  floorl(0);
9410 ; return 0; }
9411 EOF
9412 if { (eval echo configure:9413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9413   rm -rf conftest*
9414   glibcpp_cv_func_floorl_use=yes
9415 else
9416   echo "configure: failed program was:" >&5
9417   cat conftest.$ac_ext >&5
9418   rm -rf conftest*
9419   glibcpp_cv_func_floorl_use=no
9420 fi
9421 rm -f conftest*
9422     ac_ext=c
9423 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9424 ac_cpp='$CPP $CPPFLAGS'
9425 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9426 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9427 cross_compiling=$ac_cv_prog_cc_cross
9428
9429
9430 fi
9431
9432   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
9433   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
9434     for ac_func in floorl
9435 do
9436 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9437 echo "configure:9438: checking for $ac_func" >&5
9438 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9439   echo $ac_n "(cached) $ac_c" 1>&6
9440 else
9441   cat > conftest.$ac_ext <<EOF
9442 #line 9443 "configure"
9443 #include "confdefs.h"
9444 /* System header to define __stub macros and hopefully few prototypes,
9445     which can conflict with char $ac_func(); below.  */
9446 #include <assert.h>
9447 /* Override any gcc2 internal prototype to avoid an error.  */
9448 /* We use char because int might match the return type of a gcc2
9449     builtin and then its argument prototype would still apply.  */
9450 char $ac_func();
9451
9452 int main() {
9453
9454 /* The GNU C library defines this for functions which it implements
9455     to always fail with ENOSYS.  Some functions are actually named
9456     something starting with __ and the normal name is an alias.  */
9457 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9458 choke me
9459 #else
9460 $ac_func();
9461 #endif
9462
9463 ; return 0; }
9464 EOF
9465 if { (eval echo configure:9466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9466   rm -rf conftest*
9467   eval "ac_cv_func_$ac_func=yes"
9468 else
9469   echo "configure: failed program was:" >&5
9470   cat conftest.$ac_ext >&5
9471   rm -rf conftest*
9472   eval "ac_cv_func_$ac_func=no"
9473 fi
9474 rm -f conftest*
9475 fi
9476
9477 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9478   echo "$ac_t""yes" 1>&6
9479     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9480   cat >> confdefs.h <<EOF
9481 #define $ac_tr_func 1
9482 EOF
9483
9484 else
9485   echo "$ac_t""no" 1>&6
9486 fi
9487 done
9488
9489   fi
9490
9491
9492   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
9493 echo "configure:9494: checking for fmodl declaration" >&5
9494   if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
9495   echo $ac_n "(cached) $ac_c" 1>&6
9496 else
9497
9498
9499     ac_ext=C
9500 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9501 ac_cpp='$CXXCPP $CPPFLAGS'
9502 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9503 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9504 cross_compiling=$ac_cv_prog_cxx_cross
9505
9506     cat > conftest.$ac_ext <<EOF
9507 #line 9508 "configure"
9508 #include "confdefs.h"
9509 #include <math.h>
9510 int main() {
9511  fmodl(0, 0);
9512 ; return 0; }
9513 EOF
9514 if { (eval echo configure:9515: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9515   rm -rf conftest*
9516   glibcpp_cv_func_fmodl_use=yes
9517 else
9518   echo "configure: failed program was:" >&5
9519   cat conftest.$ac_ext >&5
9520   rm -rf conftest*
9521   glibcpp_cv_func_fmodl_use=no
9522 fi
9523 rm -f conftest*
9524     ac_ext=c
9525 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9526 ac_cpp='$CPP $CPPFLAGS'
9527 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9528 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9529 cross_compiling=$ac_cv_prog_cc_cross
9530
9531
9532 fi
9533
9534   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
9535   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
9536     for ac_func in fmodl
9537 do
9538 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9539 echo "configure:9540: checking for $ac_func" >&5
9540 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9541   echo $ac_n "(cached) $ac_c" 1>&6
9542 else
9543   cat > conftest.$ac_ext <<EOF
9544 #line 9545 "configure"
9545 #include "confdefs.h"
9546 /* System header to define __stub macros and hopefully few prototypes,
9547     which can conflict with char $ac_func(); below.  */
9548 #include <assert.h>
9549 /* Override any gcc2 internal prototype to avoid an error.  */
9550 /* We use char because int might match the return type of a gcc2
9551     builtin and then its argument prototype would still apply.  */
9552 char $ac_func();
9553
9554 int main() {
9555
9556 /* The GNU C library defines this for functions which it implements
9557     to always fail with ENOSYS.  Some functions are actually named
9558     something starting with __ and the normal name is an alias.  */
9559 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9560 choke me
9561 #else
9562 $ac_func();
9563 #endif
9564
9565 ; return 0; }
9566 EOF
9567 if { (eval echo configure:9568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9568   rm -rf conftest*
9569   eval "ac_cv_func_$ac_func=yes"
9570 else
9571   echo "configure: failed program was:" >&5
9572   cat conftest.$ac_ext >&5
9573   rm -rf conftest*
9574   eval "ac_cv_func_$ac_func=no"
9575 fi
9576 rm -f conftest*
9577 fi
9578
9579 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9580   echo "$ac_t""yes" 1>&6
9581     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9582   cat >> confdefs.h <<EOF
9583 #define $ac_tr_func 1
9584 EOF
9585
9586 else
9587   echo "$ac_t""no" 1>&6
9588 fi
9589 done
9590
9591   fi
9592
9593
9594   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
9595 echo "configure:9596: checking for frexpl declaration" >&5
9596   if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
9597   echo $ac_n "(cached) $ac_c" 1>&6
9598 else
9599
9600
9601     ac_ext=C
9602 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9603 ac_cpp='$CXXCPP $CPPFLAGS'
9604 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9605 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9606 cross_compiling=$ac_cv_prog_cxx_cross
9607
9608     cat > conftest.$ac_ext <<EOF
9609 #line 9610 "configure"
9610 #include "confdefs.h"
9611 #include <math.h>
9612 int main() {
9613  frexpl(0, 0);
9614 ; return 0; }
9615 EOF
9616 if { (eval echo configure:9617: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9617   rm -rf conftest*
9618   glibcpp_cv_func_frexpl_use=yes
9619 else
9620   echo "configure: failed program was:" >&5
9621   cat conftest.$ac_ext >&5
9622   rm -rf conftest*
9623   glibcpp_cv_func_frexpl_use=no
9624 fi
9625 rm -f conftest*
9626     ac_ext=c
9627 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9628 ac_cpp='$CPP $CPPFLAGS'
9629 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9630 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9631 cross_compiling=$ac_cv_prog_cc_cross
9632
9633
9634 fi
9635
9636   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
9637   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
9638     for ac_func in frexpl
9639 do
9640 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9641 echo "configure:9642: checking for $ac_func" >&5
9642 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9643   echo $ac_n "(cached) $ac_c" 1>&6
9644 else
9645   cat > conftest.$ac_ext <<EOF
9646 #line 9647 "configure"
9647 #include "confdefs.h"
9648 /* System header to define __stub macros and hopefully few prototypes,
9649     which can conflict with char $ac_func(); below.  */
9650 #include <assert.h>
9651 /* Override any gcc2 internal prototype to avoid an error.  */
9652 /* We use char because int might match the return type of a gcc2
9653     builtin and then its argument prototype would still apply.  */
9654 char $ac_func();
9655
9656 int main() {
9657
9658 /* The GNU C library defines this for functions which it implements
9659     to always fail with ENOSYS.  Some functions are actually named
9660     something starting with __ and the normal name is an alias.  */
9661 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9662 choke me
9663 #else
9664 $ac_func();
9665 #endif
9666
9667 ; return 0; }
9668 EOF
9669 if { (eval echo configure:9670: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9670   rm -rf conftest*
9671   eval "ac_cv_func_$ac_func=yes"
9672 else
9673   echo "configure: failed program was:" >&5
9674   cat conftest.$ac_ext >&5
9675   rm -rf conftest*
9676   eval "ac_cv_func_$ac_func=no"
9677 fi
9678 rm -f conftest*
9679 fi
9680
9681 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9682   echo "$ac_t""yes" 1>&6
9683     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9684   cat >> confdefs.h <<EOF
9685 #define $ac_tr_func 1
9686 EOF
9687
9688 else
9689   echo "$ac_t""no" 1>&6
9690 fi
9691 done
9692
9693   fi
9694
9695
9696   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
9697 echo "configure:9698: checking for ldexpl declaration" >&5
9698   if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
9699   echo $ac_n "(cached) $ac_c" 1>&6
9700 else
9701
9702
9703     ac_ext=C
9704 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9705 ac_cpp='$CXXCPP $CPPFLAGS'
9706 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9707 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9708 cross_compiling=$ac_cv_prog_cxx_cross
9709
9710     cat > conftest.$ac_ext <<EOF
9711 #line 9712 "configure"
9712 #include "confdefs.h"
9713 #include <math.h>
9714 int main() {
9715  ldexpl(0, 0);
9716 ; return 0; }
9717 EOF
9718 if { (eval echo configure:9719: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9719   rm -rf conftest*
9720   glibcpp_cv_func_ldexpl_use=yes
9721 else
9722   echo "configure: failed program was:" >&5
9723   cat conftest.$ac_ext >&5
9724   rm -rf conftest*
9725   glibcpp_cv_func_ldexpl_use=no
9726 fi
9727 rm -f conftest*
9728     ac_ext=c
9729 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9730 ac_cpp='$CPP $CPPFLAGS'
9731 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9732 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9733 cross_compiling=$ac_cv_prog_cc_cross
9734
9735
9736 fi
9737
9738   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
9739   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
9740     for ac_func in ldexpl
9741 do
9742 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9743 echo "configure:9744: checking for $ac_func" >&5
9744 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9745   echo $ac_n "(cached) $ac_c" 1>&6
9746 else
9747   cat > conftest.$ac_ext <<EOF
9748 #line 9749 "configure"
9749 #include "confdefs.h"
9750 /* System header to define __stub macros and hopefully few prototypes,
9751     which can conflict with char $ac_func(); below.  */
9752 #include <assert.h>
9753 /* Override any gcc2 internal prototype to avoid an error.  */
9754 /* We use char because int might match the return type of a gcc2
9755     builtin and then its argument prototype would still apply.  */
9756 char $ac_func();
9757
9758 int main() {
9759
9760 /* The GNU C library defines this for functions which it implements
9761     to always fail with ENOSYS.  Some functions are actually named
9762     something starting with __ and the normal name is an alias.  */
9763 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9764 choke me
9765 #else
9766 $ac_func();
9767 #endif
9768
9769 ; return 0; }
9770 EOF
9771 if { (eval echo configure:9772: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9772   rm -rf conftest*
9773   eval "ac_cv_func_$ac_func=yes"
9774 else
9775   echo "configure: failed program was:" >&5
9776   cat conftest.$ac_ext >&5
9777   rm -rf conftest*
9778   eval "ac_cv_func_$ac_func=no"
9779 fi
9780 rm -f conftest*
9781 fi
9782
9783 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9784   echo "$ac_t""yes" 1>&6
9785     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9786   cat >> confdefs.h <<EOF
9787 #define $ac_tr_func 1
9788 EOF
9789
9790 else
9791   echo "$ac_t""no" 1>&6
9792 fi
9793 done
9794
9795   fi
9796
9797
9798   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
9799 echo "configure:9800: checking for logl declaration" >&5
9800   if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
9801   echo $ac_n "(cached) $ac_c" 1>&6
9802 else
9803
9804
9805     ac_ext=C
9806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9807 ac_cpp='$CXXCPP $CPPFLAGS'
9808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9810 cross_compiling=$ac_cv_prog_cxx_cross
9811
9812     cat > conftest.$ac_ext <<EOF
9813 #line 9814 "configure"
9814 #include "confdefs.h"
9815 #include <math.h>
9816 int main() {
9817  logl(0);
9818 ; return 0; }
9819 EOF
9820 if { (eval echo configure:9821: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9821   rm -rf conftest*
9822   glibcpp_cv_func_logl_use=yes
9823 else
9824   echo "configure: failed program was:" >&5
9825   cat conftest.$ac_ext >&5
9826   rm -rf conftest*
9827   glibcpp_cv_func_logl_use=no
9828 fi
9829 rm -f conftest*
9830     ac_ext=c
9831 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9832 ac_cpp='$CPP $CPPFLAGS'
9833 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9834 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9835 cross_compiling=$ac_cv_prog_cc_cross
9836
9837
9838 fi
9839
9840   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
9841   if test x$glibcpp_cv_func_logl_use = x"yes"; then
9842     for ac_func in logl
9843 do
9844 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9845 echo "configure:9846: checking for $ac_func" >&5
9846 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9847   echo $ac_n "(cached) $ac_c" 1>&6
9848 else
9849   cat > conftest.$ac_ext <<EOF
9850 #line 9851 "configure"
9851 #include "confdefs.h"
9852 /* System header to define __stub macros and hopefully few prototypes,
9853     which can conflict with char $ac_func(); below.  */
9854 #include <assert.h>
9855 /* Override any gcc2 internal prototype to avoid an error.  */
9856 /* We use char because int might match the return type of a gcc2
9857     builtin and then its argument prototype would still apply.  */
9858 char $ac_func();
9859
9860 int main() {
9861
9862 /* The GNU C library defines this for functions which it implements
9863     to always fail with ENOSYS.  Some functions are actually named
9864     something starting with __ and the normal name is an alias.  */
9865 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9866 choke me
9867 #else
9868 $ac_func();
9869 #endif
9870
9871 ; return 0; }
9872 EOF
9873 if { (eval echo configure:9874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9874   rm -rf conftest*
9875   eval "ac_cv_func_$ac_func=yes"
9876 else
9877   echo "configure: failed program was:" >&5
9878   cat conftest.$ac_ext >&5
9879   rm -rf conftest*
9880   eval "ac_cv_func_$ac_func=no"
9881 fi
9882 rm -f conftest*
9883 fi
9884
9885 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9886   echo "$ac_t""yes" 1>&6
9887     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9888   cat >> confdefs.h <<EOF
9889 #define $ac_tr_func 1
9890 EOF
9891
9892 else
9893   echo "$ac_t""no" 1>&6
9894 fi
9895 done
9896
9897   fi
9898
9899
9900   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
9901 echo "configure:9902: checking for log10l declaration" >&5
9902   if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
9903   echo $ac_n "(cached) $ac_c" 1>&6
9904 else
9905
9906
9907     ac_ext=C
9908 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9909 ac_cpp='$CXXCPP $CPPFLAGS'
9910 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9911 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9912 cross_compiling=$ac_cv_prog_cxx_cross
9913
9914     cat > conftest.$ac_ext <<EOF
9915 #line 9916 "configure"
9916 #include "confdefs.h"
9917 #include <math.h>
9918 int main() {
9919  log10l(0);
9920 ; return 0; }
9921 EOF
9922 if { (eval echo configure:9923: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9923   rm -rf conftest*
9924   glibcpp_cv_func_log10l_use=yes
9925 else
9926   echo "configure: failed program was:" >&5
9927   cat conftest.$ac_ext >&5
9928   rm -rf conftest*
9929   glibcpp_cv_func_log10l_use=no
9930 fi
9931 rm -f conftest*
9932     ac_ext=c
9933 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9934 ac_cpp='$CPP $CPPFLAGS'
9935 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9936 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9937 cross_compiling=$ac_cv_prog_cc_cross
9938
9939
9940 fi
9941
9942   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
9943   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
9944     for ac_func in log10l
9945 do
9946 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9947 echo "configure:9948: checking for $ac_func" >&5
9948 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9949   echo $ac_n "(cached) $ac_c" 1>&6
9950 else
9951   cat > conftest.$ac_ext <<EOF
9952 #line 9953 "configure"
9953 #include "confdefs.h"
9954 /* System header to define __stub macros and hopefully few prototypes,
9955     which can conflict with char $ac_func(); below.  */
9956 #include <assert.h>
9957 /* Override any gcc2 internal prototype to avoid an error.  */
9958 /* We use char because int might match the return type of a gcc2
9959     builtin and then its argument prototype would still apply.  */
9960 char $ac_func();
9961
9962 int main() {
9963
9964 /* The GNU C library defines this for functions which it implements
9965     to always fail with ENOSYS.  Some functions are actually named
9966     something starting with __ and the normal name is an alias.  */
9967 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9968 choke me
9969 #else
9970 $ac_func();
9971 #endif
9972
9973 ; return 0; }
9974 EOF
9975 if { (eval echo configure:9976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9976   rm -rf conftest*
9977   eval "ac_cv_func_$ac_func=yes"
9978 else
9979   echo "configure: failed program was:" >&5
9980   cat conftest.$ac_ext >&5
9981   rm -rf conftest*
9982   eval "ac_cv_func_$ac_func=no"
9983 fi
9984 rm -f conftest*
9985 fi
9986
9987 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9988   echo "$ac_t""yes" 1>&6
9989     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9990   cat >> confdefs.h <<EOF
9991 #define $ac_tr_func 1
9992 EOF
9993
9994 else
9995   echo "$ac_t""no" 1>&6
9996 fi
9997 done
9998
9999   fi
10000
10001
10002   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
10003 echo "configure:10004: checking for modfl declaration" >&5
10004   if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
10005   echo $ac_n "(cached) $ac_c" 1>&6
10006 else
10007
10008
10009     ac_ext=C
10010 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10011 ac_cpp='$CXXCPP $CPPFLAGS'
10012 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10013 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10014 cross_compiling=$ac_cv_prog_cxx_cross
10015
10016     cat > conftest.$ac_ext <<EOF
10017 #line 10018 "configure"
10018 #include "confdefs.h"
10019 #include <math.h>
10020 int main() {
10021  modfl(0, 0);
10022 ; return 0; }
10023 EOF
10024 if { (eval echo configure:10025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10025   rm -rf conftest*
10026   glibcpp_cv_func_modfl_use=yes
10027 else
10028   echo "configure: failed program was:" >&5
10029   cat conftest.$ac_ext >&5
10030   rm -rf conftest*
10031   glibcpp_cv_func_modfl_use=no
10032 fi
10033 rm -f conftest*
10034     ac_ext=c
10035 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10036 ac_cpp='$CPP $CPPFLAGS'
10037 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10038 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10039 cross_compiling=$ac_cv_prog_cc_cross
10040
10041
10042 fi
10043
10044   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
10045   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
10046     for ac_func in modfl
10047 do
10048 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10049 echo "configure:10050: checking for $ac_func" >&5
10050 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10051   echo $ac_n "(cached) $ac_c" 1>&6
10052 else
10053   cat > conftest.$ac_ext <<EOF
10054 #line 10055 "configure"
10055 #include "confdefs.h"
10056 /* System header to define __stub macros and hopefully few prototypes,
10057     which can conflict with char $ac_func(); below.  */
10058 #include <assert.h>
10059 /* Override any gcc2 internal prototype to avoid an error.  */
10060 /* We use char because int might match the return type of a gcc2
10061     builtin and then its argument prototype would still apply.  */
10062 char $ac_func();
10063
10064 int main() {
10065
10066 /* The GNU C library defines this for functions which it implements
10067     to always fail with ENOSYS.  Some functions are actually named
10068     something starting with __ and the normal name is an alias.  */
10069 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10070 choke me
10071 #else
10072 $ac_func();
10073 #endif
10074
10075 ; return 0; }
10076 EOF
10077 if { (eval echo configure:10078: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10078   rm -rf conftest*
10079   eval "ac_cv_func_$ac_func=yes"
10080 else
10081   echo "configure: failed program was:" >&5
10082   cat conftest.$ac_ext >&5
10083   rm -rf conftest*
10084   eval "ac_cv_func_$ac_func=no"
10085 fi
10086 rm -f conftest*
10087 fi
10088
10089 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10090   echo "$ac_t""yes" 1>&6
10091     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10092   cat >> confdefs.h <<EOF
10093 #define $ac_tr_func 1
10094 EOF
10095
10096 else
10097   echo "$ac_t""no" 1>&6
10098 fi
10099 done
10100
10101   fi
10102
10103
10104   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
10105 echo "configure:10106: checking for powl declaration" >&5
10106   if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
10107   echo $ac_n "(cached) $ac_c" 1>&6
10108 else
10109
10110
10111     ac_ext=C
10112 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10113 ac_cpp='$CXXCPP $CPPFLAGS'
10114 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10115 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10116 cross_compiling=$ac_cv_prog_cxx_cross
10117
10118     cat > conftest.$ac_ext <<EOF
10119 #line 10120 "configure"
10120 #include "confdefs.h"
10121 #include <math.h>
10122 int main() {
10123  powl(0, 0);
10124 ; return 0; }
10125 EOF
10126 if { (eval echo configure:10127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10127   rm -rf conftest*
10128   glibcpp_cv_func_powl_use=yes
10129 else
10130   echo "configure: failed program was:" >&5
10131   cat conftest.$ac_ext >&5
10132   rm -rf conftest*
10133   glibcpp_cv_func_powl_use=no
10134 fi
10135 rm -f conftest*
10136     ac_ext=c
10137 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10138 ac_cpp='$CPP $CPPFLAGS'
10139 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10140 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10141 cross_compiling=$ac_cv_prog_cc_cross
10142
10143
10144 fi
10145
10146   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
10147   if test x$glibcpp_cv_func_powl_use = x"yes"; then
10148     for ac_func in powl
10149 do
10150 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10151 echo "configure:10152: checking for $ac_func" >&5
10152 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10153   echo $ac_n "(cached) $ac_c" 1>&6
10154 else
10155   cat > conftest.$ac_ext <<EOF
10156 #line 10157 "configure"
10157 #include "confdefs.h"
10158 /* System header to define __stub macros and hopefully few prototypes,
10159     which can conflict with char $ac_func(); below.  */
10160 #include <assert.h>
10161 /* Override any gcc2 internal prototype to avoid an error.  */
10162 /* We use char because int might match the return type of a gcc2
10163     builtin and then its argument prototype would still apply.  */
10164 char $ac_func();
10165
10166 int main() {
10167
10168 /* The GNU C library defines this for functions which it implements
10169     to always fail with ENOSYS.  Some functions are actually named
10170     something starting with __ and the normal name is an alias.  */
10171 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10172 choke me
10173 #else
10174 $ac_func();
10175 #endif
10176
10177 ; return 0; }
10178 EOF
10179 if { (eval echo configure:10180: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10180   rm -rf conftest*
10181   eval "ac_cv_func_$ac_func=yes"
10182 else
10183   echo "configure: failed program was:" >&5
10184   cat conftest.$ac_ext >&5
10185   rm -rf conftest*
10186   eval "ac_cv_func_$ac_func=no"
10187 fi
10188 rm -f conftest*
10189 fi
10190
10191 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10192   echo "$ac_t""yes" 1>&6
10193     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10194   cat >> confdefs.h <<EOF
10195 #define $ac_tr_func 1
10196 EOF
10197
10198 else
10199   echo "$ac_t""no" 1>&6
10200 fi
10201 done
10202
10203   fi
10204
10205
10206   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
10207 echo "configure:10208: checking for sinl declaration" >&5
10208   if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
10209   echo $ac_n "(cached) $ac_c" 1>&6
10210 else
10211
10212
10213     ac_ext=C
10214 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10215 ac_cpp='$CXXCPP $CPPFLAGS'
10216 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10217 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10218 cross_compiling=$ac_cv_prog_cxx_cross
10219
10220     cat > conftest.$ac_ext <<EOF
10221 #line 10222 "configure"
10222 #include "confdefs.h"
10223 #include <math.h>
10224 int main() {
10225  sinl(0);
10226 ; return 0; }
10227 EOF
10228 if { (eval echo configure:10229: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10229   rm -rf conftest*
10230   glibcpp_cv_func_sinl_use=yes
10231 else
10232   echo "configure: failed program was:" >&5
10233   cat conftest.$ac_ext >&5
10234   rm -rf conftest*
10235   glibcpp_cv_func_sinl_use=no
10236 fi
10237 rm -f conftest*
10238     ac_ext=c
10239 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10240 ac_cpp='$CPP $CPPFLAGS'
10241 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10242 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10243 cross_compiling=$ac_cv_prog_cc_cross
10244
10245
10246 fi
10247
10248   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
10249   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
10250     for ac_func in sinl
10251 do
10252 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10253 echo "configure:10254: checking for $ac_func" >&5
10254 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10255   echo $ac_n "(cached) $ac_c" 1>&6
10256 else
10257   cat > conftest.$ac_ext <<EOF
10258 #line 10259 "configure"
10259 #include "confdefs.h"
10260 /* System header to define __stub macros and hopefully few prototypes,
10261     which can conflict with char $ac_func(); below.  */
10262 #include <assert.h>
10263 /* Override any gcc2 internal prototype to avoid an error.  */
10264 /* We use char because int might match the return type of a gcc2
10265     builtin and then its argument prototype would still apply.  */
10266 char $ac_func();
10267
10268 int main() {
10269
10270 /* The GNU C library defines this for functions which it implements
10271     to always fail with ENOSYS.  Some functions are actually named
10272     something starting with __ and the normal name is an alias.  */
10273 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10274 choke me
10275 #else
10276 $ac_func();
10277 #endif
10278
10279 ; return 0; }
10280 EOF
10281 if { (eval echo configure:10282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10282   rm -rf conftest*
10283   eval "ac_cv_func_$ac_func=yes"
10284 else
10285   echo "configure: failed program was:" >&5
10286   cat conftest.$ac_ext >&5
10287   rm -rf conftest*
10288   eval "ac_cv_func_$ac_func=no"
10289 fi
10290 rm -f conftest*
10291 fi
10292
10293 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10294   echo "$ac_t""yes" 1>&6
10295     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10296   cat >> confdefs.h <<EOF
10297 #define $ac_tr_func 1
10298 EOF
10299
10300 else
10301   echo "$ac_t""no" 1>&6
10302 fi
10303 done
10304
10305   fi
10306
10307
10308   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
10309 echo "configure:10310: checking for sinhl declaration" >&5
10310   if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
10311   echo $ac_n "(cached) $ac_c" 1>&6
10312 else
10313
10314
10315     ac_ext=C
10316 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10317 ac_cpp='$CXXCPP $CPPFLAGS'
10318 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10319 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10320 cross_compiling=$ac_cv_prog_cxx_cross
10321
10322     cat > conftest.$ac_ext <<EOF
10323 #line 10324 "configure"
10324 #include "confdefs.h"
10325 #include <math.h>
10326 int main() {
10327  sinhl(0);
10328 ; return 0; }
10329 EOF
10330 if { (eval echo configure:10331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10331   rm -rf conftest*
10332   glibcpp_cv_func_sinhl_use=yes
10333 else
10334   echo "configure: failed program was:" >&5
10335   cat conftest.$ac_ext >&5
10336   rm -rf conftest*
10337   glibcpp_cv_func_sinhl_use=no
10338 fi
10339 rm -f conftest*
10340     ac_ext=c
10341 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10342 ac_cpp='$CPP $CPPFLAGS'
10343 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10344 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10345 cross_compiling=$ac_cv_prog_cc_cross
10346
10347
10348 fi
10349
10350   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
10351   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
10352     for ac_func in sinhl
10353 do
10354 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10355 echo "configure:10356: checking for $ac_func" >&5
10356 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10357   echo $ac_n "(cached) $ac_c" 1>&6
10358 else
10359   cat > conftest.$ac_ext <<EOF
10360 #line 10361 "configure"
10361 #include "confdefs.h"
10362 /* System header to define __stub macros and hopefully few prototypes,
10363     which can conflict with char $ac_func(); below.  */
10364 #include <assert.h>
10365 /* Override any gcc2 internal prototype to avoid an error.  */
10366 /* We use char because int might match the return type of a gcc2
10367     builtin and then its argument prototype would still apply.  */
10368 char $ac_func();
10369
10370 int main() {
10371
10372 /* The GNU C library defines this for functions which it implements
10373     to always fail with ENOSYS.  Some functions are actually named
10374     something starting with __ and the normal name is an alias.  */
10375 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10376 choke me
10377 #else
10378 $ac_func();
10379 #endif
10380
10381 ; return 0; }
10382 EOF
10383 if { (eval echo configure:10384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10384   rm -rf conftest*
10385   eval "ac_cv_func_$ac_func=yes"
10386 else
10387   echo "configure: failed program was:" >&5
10388   cat conftest.$ac_ext >&5
10389   rm -rf conftest*
10390   eval "ac_cv_func_$ac_func=no"
10391 fi
10392 rm -f conftest*
10393 fi
10394
10395 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10396   echo "$ac_t""yes" 1>&6
10397     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10398   cat >> confdefs.h <<EOF
10399 #define $ac_tr_func 1
10400 EOF
10401
10402 else
10403   echo "$ac_t""no" 1>&6
10404 fi
10405 done
10406
10407   fi
10408
10409
10410   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
10411 echo "configure:10412: checking for sqrtl declaration" >&5
10412   if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
10413   echo $ac_n "(cached) $ac_c" 1>&6
10414 else
10415
10416
10417     ac_ext=C
10418 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10419 ac_cpp='$CXXCPP $CPPFLAGS'
10420 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10421 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10422 cross_compiling=$ac_cv_prog_cxx_cross
10423
10424     cat > conftest.$ac_ext <<EOF
10425 #line 10426 "configure"
10426 #include "confdefs.h"
10427 #include <math.h>
10428 int main() {
10429  sqrtl(0);
10430 ; return 0; }
10431 EOF
10432 if { (eval echo configure:10433: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10433   rm -rf conftest*
10434   glibcpp_cv_func_sqrtl_use=yes
10435 else
10436   echo "configure: failed program was:" >&5
10437   cat conftest.$ac_ext >&5
10438   rm -rf conftest*
10439   glibcpp_cv_func_sqrtl_use=no
10440 fi
10441 rm -f conftest*
10442     ac_ext=c
10443 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10444 ac_cpp='$CPP $CPPFLAGS'
10445 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10446 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10447 cross_compiling=$ac_cv_prog_cc_cross
10448
10449
10450 fi
10451
10452   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
10453   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
10454     for ac_func in sqrtl
10455 do
10456 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10457 echo "configure:10458: checking for $ac_func" >&5
10458 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10459   echo $ac_n "(cached) $ac_c" 1>&6
10460 else
10461   cat > conftest.$ac_ext <<EOF
10462 #line 10463 "configure"
10463 #include "confdefs.h"
10464 /* System header to define __stub macros and hopefully few prototypes,
10465     which can conflict with char $ac_func(); below.  */
10466 #include <assert.h>
10467 /* Override any gcc2 internal prototype to avoid an error.  */
10468 /* We use char because int might match the return type of a gcc2
10469     builtin and then its argument prototype would still apply.  */
10470 char $ac_func();
10471
10472 int main() {
10473
10474 /* The GNU C library defines this for functions which it implements
10475     to always fail with ENOSYS.  Some functions are actually named
10476     something starting with __ and the normal name is an alias.  */
10477 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10478 choke me
10479 #else
10480 $ac_func();
10481 #endif
10482
10483 ; return 0; }
10484 EOF
10485 if { (eval echo configure:10486: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10486   rm -rf conftest*
10487   eval "ac_cv_func_$ac_func=yes"
10488 else
10489   echo "configure: failed program was:" >&5
10490   cat conftest.$ac_ext >&5
10491   rm -rf conftest*
10492   eval "ac_cv_func_$ac_func=no"
10493 fi
10494 rm -f conftest*
10495 fi
10496
10497 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10498   echo "$ac_t""yes" 1>&6
10499     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10500   cat >> confdefs.h <<EOF
10501 #define $ac_tr_func 1
10502 EOF
10503
10504 else
10505   echo "$ac_t""no" 1>&6
10506 fi
10507 done
10508
10509   fi
10510
10511
10512   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
10513 echo "configure:10514: checking for tanl declaration" >&5
10514   if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
10515   echo $ac_n "(cached) $ac_c" 1>&6
10516 else
10517
10518
10519     ac_ext=C
10520 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10521 ac_cpp='$CXXCPP $CPPFLAGS'
10522 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10523 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10524 cross_compiling=$ac_cv_prog_cxx_cross
10525
10526     cat > conftest.$ac_ext <<EOF
10527 #line 10528 "configure"
10528 #include "confdefs.h"
10529 #include <math.h>
10530 int main() {
10531  tanl(0);
10532 ; return 0; }
10533 EOF
10534 if { (eval echo configure:10535: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10535   rm -rf conftest*
10536   glibcpp_cv_func_tanl_use=yes
10537 else
10538   echo "configure: failed program was:" >&5
10539   cat conftest.$ac_ext >&5
10540   rm -rf conftest*
10541   glibcpp_cv_func_tanl_use=no
10542 fi
10543 rm -f conftest*
10544     ac_ext=c
10545 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10546 ac_cpp='$CPP $CPPFLAGS'
10547 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10548 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10549 cross_compiling=$ac_cv_prog_cc_cross
10550
10551
10552 fi
10553
10554   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
10555   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
10556     for ac_func in tanl
10557 do
10558 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10559 echo "configure:10560: checking for $ac_func" >&5
10560 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10561   echo $ac_n "(cached) $ac_c" 1>&6
10562 else
10563   cat > conftest.$ac_ext <<EOF
10564 #line 10565 "configure"
10565 #include "confdefs.h"
10566 /* System header to define __stub macros and hopefully few prototypes,
10567     which can conflict with char $ac_func(); below.  */
10568 #include <assert.h>
10569 /* Override any gcc2 internal prototype to avoid an error.  */
10570 /* We use char because int might match the return type of a gcc2
10571     builtin and then its argument prototype would still apply.  */
10572 char $ac_func();
10573
10574 int main() {
10575
10576 /* The GNU C library defines this for functions which it implements
10577     to always fail with ENOSYS.  Some functions are actually named
10578     something starting with __ and the normal name is an alias.  */
10579 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10580 choke me
10581 #else
10582 $ac_func();
10583 #endif
10584
10585 ; return 0; }
10586 EOF
10587 if { (eval echo configure:10588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10588   rm -rf conftest*
10589   eval "ac_cv_func_$ac_func=yes"
10590 else
10591   echo "configure: failed program was:" >&5
10592   cat conftest.$ac_ext >&5
10593   rm -rf conftest*
10594   eval "ac_cv_func_$ac_func=no"
10595 fi
10596 rm -f conftest*
10597 fi
10598
10599 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10600   echo "$ac_t""yes" 1>&6
10601     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10602   cat >> confdefs.h <<EOF
10603 #define $ac_tr_func 1
10604 EOF
10605
10606 else
10607   echo "$ac_t""no" 1>&6
10608 fi
10609 done
10610
10611   fi
10612
10613
10614   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
10615 echo "configure:10616: checking for tanhl declaration" >&5
10616   if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
10617   echo $ac_n "(cached) $ac_c" 1>&6
10618 else
10619
10620
10621     ac_ext=C
10622 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10623 ac_cpp='$CXXCPP $CPPFLAGS'
10624 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10625 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10626 cross_compiling=$ac_cv_prog_cxx_cross
10627
10628     cat > conftest.$ac_ext <<EOF
10629 #line 10630 "configure"
10630 #include "confdefs.h"
10631 #include <math.h>
10632 int main() {
10633  tanhl(0);
10634 ; return 0; }
10635 EOF
10636 if { (eval echo configure:10637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10637   rm -rf conftest*
10638   glibcpp_cv_func_tanhl_use=yes
10639 else
10640   echo "configure: failed program was:" >&5
10641   cat conftest.$ac_ext >&5
10642   rm -rf conftest*
10643   glibcpp_cv_func_tanhl_use=no
10644 fi
10645 rm -f conftest*
10646     ac_ext=c
10647 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10648 ac_cpp='$CPP $CPPFLAGS'
10649 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10650 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10651 cross_compiling=$ac_cv_prog_cc_cross
10652
10653
10654 fi
10655
10656   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
10657   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
10658     for ac_func in tanhl
10659 do
10660 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10661 echo "configure:10662: checking for $ac_func" >&5
10662 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10663   echo $ac_n "(cached) $ac_c" 1>&6
10664 else
10665   cat > conftest.$ac_ext <<EOF
10666 #line 10667 "configure"
10667 #include "confdefs.h"
10668 /* System header to define __stub macros and hopefully few prototypes,
10669     which can conflict with char $ac_func(); below.  */
10670 #include <assert.h>
10671 /* Override any gcc2 internal prototype to avoid an error.  */
10672 /* We use char because int might match the return type of a gcc2
10673     builtin and then its argument prototype would still apply.  */
10674 char $ac_func();
10675
10676 int main() {
10677
10678 /* The GNU C library defines this for functions which it implements
10679     to always fail with ENOSYS.  Some functions are actually named
10680     something starting with __ and the normal name is an alias.  */
10681 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10682 choke me
10683 #else
10684 $ac_func();
10685 #endif
10686
10687 ; return 0; }
10688 EOF
10689 if { (eval echo configure:10690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10690   rm -rf conftest*
10691   eval "ac_cv_func_$ac_func=yes"
10692 else
10693   echo "configure: failed program was:" >&5
10694   cat conftest.$ac_ext >&5
10695   rm -rf conftest*
10696   eval "ac_cv_func_$ac_func=no"
10697 fi
10698 rm -f conftest*
10699 fi
10700
10701 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10702   echo "$ac_t""yes" 1>&6
10703     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10704   cat >> confdefs.h <<EOF
10705 #define $ac_tr_func 1
10706 EOF
10707
10708 else
10709   echo "$ac_t""no" 1>&6
10710 fi
10711 done
10712
10713   fi
10714
10715
10716   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
10717 echo "configure:10718: checking for sincosl declaration" >&5
10718   if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
10719   echo $ac_n "(cached) $ac_c" 1>&6
10720 else
10721
10722
10723     ac_ext=C
10724 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10725 ac_cpp='$CXXCPP $CPPFLAGS'
10726 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10727 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10728 cross_compiling=$ac_cv_prog_cxx_cross
10729
10730     cat > conftest.$ac_ext <<EOF
10731 #line 10732 "configure"
10732 #include "confdefs.h"
10733 #include <math.h>
10734 int main() {
10735  sincosl(0, 0, 0);
10736 ; return 0; }
10737 EOF
10738 if { (eval echo configure:10739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10739   rm -rf conftest*
10740   glibcpp_cv_func_sincosl_use=yes
10741 else
10742   echo "configure: failed program was:" >&5
10743   cat conftest.$ac_ext >&5
10744   rm -rf conftest*
10745   glibcpp_cv_func_sincosl_use=no
10746 fi
10747 rm -f conftest*
10748     ac_ext=c
10749 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10750 ac_cpp='$CPP $CPPFLAGS'
10751 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10752 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10753 cross_compiling=$ac_cv_prog_cc_cross
10754
10755
10756 fi
10757
10758   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
10759   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
10760     for ac_func in sincosl
10761 do
10762 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10763 echo "configure:10764: checking for $ac_func" >&5
10764 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10765   echo $ac_n "(cached) $ac_c" 1>&6
10766 else
10767   cat > conftest.$ac_ext <<EOF
10768 #line 10769 "configure"
10769 #include "confdefs.h"
10770 /* System header to define __stub macros and hopefully few prototypes,
10771     which can conflict with char $ac_func(); below.  */
10772 #include <assert.h>
10773 /* Override any gcc2 internal prototype to avoid an error.  */
10774 /* We use char because int might match the return type of a gcc2
10775     builtin and then its argument prototype would still apply.  */
10776 char $ac_func();
10777
10778 int main() {
10779
10780 /* The GNU C library defines this for functions which it implements
10781     to always fail with ENOSYS.  Some functions are actually named
10782     something starting with __ and the normal name is an alias.  */
10783 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10784 choke me
10785 #else
10786 $ac_func();
10787 #endif
10788
10789 ; return 0; }
10790 EOF
10791 if { (eval echo configure:10792: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10792   rm -rf conftest*
10793   eval "ac_cv_func_$ac_func=yes"
10794 else
10795   echo "configure: failed program was:" >&5
10796   cat conftest.$ac_ext >&5
10797   rm -rf conftest*
10798   eval "ac_cv_func_$ac_func=no"
10799 fi
10800 rm -f conftest*
10801 fi
10802
10803 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10804   echo "$ac_t""yes" 1>&6
10805     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10806   cat >> confdefs.h <<EOF
10807 #define $ac_tr_func 1
10808 EOF
10809
10810 else
10811   echo "$ac_t""no" 1>&6
10812 fi
10813 done
10814
10815   fi
10816
10817
10818   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
10819 echo "configure:10820: checking for finitel declaration" >&5
10820   if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
10821   echo $ac_n "(cached) $ac_c" 1>&6
10822 else
10823
10824
10825     ac_ext=C
10826 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10827 ac_cpp='$CXXCPP $CPPFLAGS'
10828 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10829 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10830 cross_compiling=$ac_cv_prog_cxx_cross
10831
10832     cat > conftest.$ac_ext <<EOF
10833 #line 10834 "configure"
10834 #include "confdefs.h"
10835 #include <math.h>
10836 int main() {
10837  finitel(0);
10838 ; return 0; }
10839 EOF
10840 if { (eval echo configure:10841: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10841   rm -rf conftest*
10842   glibcpp_cv_func_finitel_use=yes
10843 else
10844   echo "configure: failed program was:" >&5
10845   cat conftest.$ac_ext >&5
10846   rm -rf conftest*
10847   glibcpp_cv_func_finitel_use=no
10848 fi
10849 rm -f conftest*
10850     ac_ext=c
10851 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10852 ac_cpp='$CPP $CPPFLAGS'
10853 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10854 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10855 cross_compiling=$ac_cv_prog_cc_cross
10856
10857
10858 fi
10859
10860   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
10861   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
10862     for ac_func in finitel
10863 do
10864 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10865 echo "configure:10866: checking for $ac_func" >&5
10866 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10867   echo $ac_n "(cached) $ac_c" 1>&6
10868 else
10869   cat > conftest.$ac_ext <<EOF
10870 #line 10871 "configure"
10871 #include "confdefs.h"
10872 /* System header to define __stub macros and hopefully few prototypes,
10873     which can conflict with char $ac_func(); below.  */
10874 #include <assert.h>
10875 /* Override any gcc2 internal prototype to avoid an error.  */
10876 /* We use char because int might match the return type of a gcc2
10877     builtin and then its argument prototype would still apply.  */
10878 char $ac_func();
10879
10880 int main() {
10881
10882 /* The GNU C library defines this for functions which it implements
10883     to always fail with ENOSYS.  Some functions are actually named
10884     something starting with __ and the normal name is an alias.  */
10885 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10886 choke me
10887 #else
10888 $ac_func();
10889 #endif
10890
10891 ; return 0; }
10892 EOF
10893 if { (eval echo configure:10894: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10894   rm -rf conftest*
10895   eval "ac_cv_func_$ac_func=yes"
10896 else
10897   echo "configure: failed program was:" >&5
10898   cat conftest.$ac_ext >&5
10899   rm -rf conftest*
10900   eval "ac_cv_func_$ac_func=no"
10901 fi
10902 rm -f conftest*
10903 fi
10904
10905 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10906   echo "$ac_t""yes" 1>&6
10907     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10908   cat >> confdefs.h <<EOF
10909 #define $ac_tr_func 1
10910 EOF
10911
10912 else
10913   echo "$ac_t""no" 1>&6
10914 fi
10915 done
10916
10917   fi
10918
10919
10920
10921   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
10922 echo "configure:10923: checking for _isinf declaration" >&5
10923   if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
10924   echo $ac_n "(cached) $ac_c" 1>&6
10925 else
10926
10927
10928     ac_ext=C
10929 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10930 ac_cpp='$CXXCPP $CPPFLAGS'
10931 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10932 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10933 cross_compiling=$ac_cv_prog_cxx_cross
10934
10935     cat > conftest.$ac_ext <<EOF
10936 #line 10937 "configure"
10937 #include "confdefs.h"
10938 #include <math.h>
10939 int main() {
10940  _isinf(0);
10941 ; return 0; }
10942 EOF
10943 if { (eval echo configure:10944: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10944   rm -rf conftest*
10945   glibcpp_cv_func__isinf_use=yes
10946 else
10947   echo "configure: failed program was:" >&5
10948   cat conftest.$ac_ext >&5
10949   rm -rf conftest*
10950   glibcpp_cv_func__isinf_use=no
10951 fi
10952 rm -f conftest*
10953     ac_ext=c
10954 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10955 ac_cpp='$CPP $CPPFLAGS'
10956 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10957 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10958 cross_compiling=$ac_cv_prog_cc_cross
10959
10960
10961 fi
10962
10963   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
10964   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
10965     for ac_func in _isinf
10966 do
10967 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10968 echo "configure:10969: checking for $ac_func" >&5
10969 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10970   echo $ac_n "(cached) $ac_c" 1>&6
10971 else
10972   cat > conftest.$ac_ext <<EOF
10973 #line 10974 "configure"
10974 #include "confdefs.h"
10975 /* System header to define __stub macros and hopefully few prototypes,
10976     which can conflict with char $ac_func(); below.  */
10977 #include <assert.h>
10978 /* Override any gcc2 internal prototype to avoid an error.  */
10979 /* We use char because int might match the return type of a gcc2
10980     builtin and then its argument prototype would still apply.  */
10981 char $ac_func();
10982
10983 int main() {
10984
10985 /* The GNU C library defines this for functions which it implements
10986     to always fail with ENOSYS.  Some functions are actually named
10987     something starting with __ and the normal name is an alias.  */
10988 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10989 choke me
10990 #else
10991 $ac_func();
10992 #endif
10993
10994 ; return 0; }
10995 EOF
10996 if { (eval echo configure:10997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10997   rm -rf conftest*
10998   eval "ac_cv_func_$ac_func=yes"
10999 else
11000   echo "configure: failed program was:" >&5
11001   cat conftest.$ac_ext >&5
11002   rm -rf conftest*
11003   eval "ac_cv_func_$ac_func=no"
11004 fi
11005 rm -f conftest*
11006 fi
11007
11008 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11009   echo "$ac_t""yes" 1>&6
11010     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11011   cat >> confdefs.h <<EOF
11012 #define $ac_tr_func 1
11013 EOF
11014
11015 else
11016   echo "$ac_t""no" 1>&6
11017 fi
11018 done
11019
11020   fi
11021
11022
11023   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
11024 echo "configure:11025: checking for _isnan declaration" >&5
11025   if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
11026   echo $ac_n "(cached) $ac_c" 1>&6
11027 else
11028
11029
11030     ac_ext=C
11031 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11032 ac_cpp='$CXXCPP $CPPFLAGS'
11033 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11034 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11035 cross_compiling=$ac_cv_prog_cxx_cross
11036
11037     cat > conftest.$ac_ext <<EOF
11038 #line 11039 "configure"
11039 #include "confdefs.h"
11040 #include <math.h>
11041 int main() {
11042  _isnan(0);
11043 ; return 0; }
11044 EOF
11045 if { (eval echo configure:11046: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11046   rm -rf conftest*
11047   glibcpp_cv_func__isnan_use=yes
11048 else
11049   echo "configure: failed program was:" >&5
11050   cat conftest.$ac_ext >&5
11051   rm -rf conftest*
11052   glibcpp_cv_func__isnan_use=no
11053 fi
11054 rm -f conftest*
11055     ac_ext=c
11056 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11057 ac_cpp='$CPP $CPPFLAGS'
11058 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11059 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11060 cross_compiling=$ac_cv_prog_cc_cross
11061
11062
11063 fi
11064
11065   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
11066   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
11067     for ac_func in _isnan
11068 do
11069 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11070 echo "configure:11071: checking for $ac_func" >&5
11071 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11072   echo $ac_n "(cached) $ac_c" 1>&6
11073 else
11074   cat > conftest.$ac_ext <<EOF
11075 #line 11076 "configure"
11076 #include "confdefs.h"
11077 /* System header to define __stub macros and hopefully few prototypes,
11078     which can conflict with char $ac_func(); below.  */
11079 #include <assert.h>
11080 /* Override any gcc2 internal prototype to avoid an error.  */
11081 /* We use char because int might match the return type of a gcc2
11082     builtin and then its argument prototype would still apply.  */
11083 char $ac_func();
11084
11085 int main() {
11086
11087 /* The GNU C library defines this for functions which it implements
11088     to always fail with ENOSYS.  Some functions are actually named
11089     something starting with __ and the normal name is an alias.  */
11090 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11091 choke me
11092 #else
11093 $ac_func();
11094 #endif
11095
11096 ; return 0; }
11097 EOF
11098 if { (eval echo configure:11099: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11099   rm -rf conftest*
11100   eval "ac_cv_func_$ac_func=yes"
11101 else
11102   echo "configure: failed program was:" >&5
11103   cat conftest.$ac_ext >&5
11104   rm -rf conftest*
11105   eval "ac_cv_func_$ac_func=no"
11106 fi
11107 rm -f conftest*
11108 fi
11109
11110 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11111   echo "$ac_t""yes" 1>&6
11112     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11113   cat >> confdefs.h <<EOF
11114 #define $ac_tr_func 1
11115 EOF
11116
11117 else
11118   echo "$ac_t""no" 1>&6
11119 fi
11120 done
11121
11122   fi
11123
11124
11125   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
11126 echo "configure:11127: checking for _finite declaration" >&5
11127   if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
11128   echo $ac_n "(cached) $ac_c" 1>&6
11129 else
11130
11131
11132     ac_ext=C
11133 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11134 ac_cpp='$CXXCPP $CPPFLAGS'
11135 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11136 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11137 cross_compiling=$ac_cv_prog_cxx_cross
11138
11139     cat > conftest.$ac_ext <<EOF
11140 #line 11141 "configure"
11141 #include "confdefs.h"
11142 #include <math.h>
11143 int main() {
11144  _finite(0);
11145 ; return 0; }
11146 EOF
11147 if { (eval echo configure:11148: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11148   rm -rf conftest*
11149   glibcpp_cv_func__finite_use=yes
11150 else
11151   echo "configure: failed program was:" >&5
11152   cat conftest.$ac_ext >&5
11153   rm -rf conftest*
11154   glibcpp_cv_func__finite_use=no
11155 fi
11156 rm -f conftest*
11157     ac_ext=c
11158 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11159 ac_cpp='$CPP $CPPFLAGS'
11160 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11161 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11162 cross_compiling=$ac_cv_prog_cc_cross
11163
11164
11165 fi
11166
11167   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
11168   if test x$glibcpp_cv_func__finite_use = x"yes"; then
11169     for ac_func in _finite
11170 do
11171 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11172 echo "configure:11173: checking for $ac_func" >&5
11173 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11174   echo $ac_n "(cached) $ac_c" 1>&6
11175 else
11176   cat > conftest.$ac_ext <<EOF
11177 #line 11178 "configure"
11178 #include "confdefs.h"
11179 /* System header to define __stub macros and hopefully few prototypes,
11180     which can conflict with char $ac_func(); below.  */
11181 #include <assert.h>
11182 /* Override any gcc2 internal prototype to avoid an error.  */
11183 /* We use char because int might match the return type of a gcc2
11184     builtin and then its argument prototype would still apply.  */
11185 char $ac_func();
11186
11187 int main() {
11188
11189 /* The GNU C library defines this for functions which it implements
11190     to always fail with ENOSYS.  Some functions are actually named
11191     something starting with __ and the normal name is an alias.  */
11192 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11193 choke me
11194 #else
11195 $ac_func();
11196 #endif
11197
11198 ; return 0; }
11199 EOF
11200 if { (eval echo configure:11201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11201   rm -rf conftest*
11202   eval "ac_cv_func_$ac_func=yes"
11203 else
11204   echo "configure: failed program was:" >&5
11205   cat conftest.$ac_ext >&5
11206   rm -rf conftest*
11207   eval "ac_cv_func_$ac_func=no"
11208 fi
11209 rm -f conftest*
11210 fi
11211
11212 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11213   echo "$ac_t""yes" 1>&6
11214     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11215   cat >> confdefs.h <<EOF
11216 #define $ac_tr_func 1
11217 EOF
11218
11219 else
11220   echo "$ac_t""no" 1>&6
11221 fi
11222 done
11223
11224   fi
11225
11226
11227   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
11228 echo "configure:11229: checking for _copysign declaration" >&5
11229   if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
11230   echo $ac_n "(cached) $ac_c" 1>&6
11231 else
11232
11233
11234     ac_ext=C
11235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11236 ac_cpp='$CXXCPP $CPPFLAGS'
11237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11239 cross_compiling=$ac_cv_prog_cxx_cross
11240
11241     cat > conftest.$ac_ext <<EOF
11242 #line 11243 "configure"
11243 #include "confdefs.h"
11244 #include <math.h>
11245 int main() {
11246  _copysign(0, 0);
11247 ; return 0; }
11248 EOF
11249 if { (eval echo configure:11250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11250   rm -rf conftest*
11251   glibcpp_cv_func__copysign_use=yes
11252 else
11253   echo "configure: failed program was:" >&5
11254   cat conftest.$ac_ext >&5
11255   rm -rf conftest*
11256   glibcpp_cv_func__copysign_use=no
11257 fi
11258 rm -f conftest*
11259     ac_ext=c
11260 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11261 ac_cpp='$CPP $CPPFLAGS'
11262 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11263 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11264 cross_compiling=$ac_cv_prog_cc_cross
11265
11266
11267 fi
11268
11269   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
11270   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
11271     for ac_func in _copysign
11272 do
11273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11274 echo "configure:11275: checking for $ac_func" >&5
11275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11276   echo $ac_n "(cached) $ac_c" 1>&6
11277 else
11278   cat > conftest.$ac_ext <<EOF
11279 #line 11280 "configure"
11280 #include "confdefs.h"
11281 /* System header to define __stub macros and hopefully few prototypes,
11282     which can conflict with char $ac_func(); below.  */
11283 #include <assert.h>
11284 /* Override any gcc2 internal prototype to avoid an error.  */
11285 /* We use char because int might match the return type of a gcc2
11286     builtin and then its argument prototype would still apply.  */
11287 char $ac_func();
11288
11289 int main() {
11290
11291 /* The GNU C library defines this for functions which it implements
11292     to always fail with ENOSYS.  Some functions are actually named
11293     something starting with __ and the normal name is an alias.  */
11294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11295 choke me
11296 #else
11297 $ac_func();
11298 #endif
11299
11300 ; return 0; }
11301 EOF
11302 if { (eval echo configure:11303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11303   rm -rf conftest*
11304   eval "ac_cv_func_$ac_func=yes"
11305 else
11306   echo "configure: failed program was:" >&5
11307   cat conftest.$ac_ext >&5
11308   rm -rf conftest*
11309   eval "ac_cv_func_$ac_func=no"
11310 fi
11311 rm -f conftest*
11312 fi
11313
11314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11315   echo "$ac_t""yes" 1>&6
11316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11317   cat >> confdefs.h <<EOF
11318 #define $ac_tr_func 1
11319 EOF
11320
11321 else
11322   echo "$ac_t""no" 1>&6
11323 fi
11324 done
11325
11326   fi
11327
11328
11329   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
11330 echo "configure:11331: checking for _sincos declaration" >&5
11331   if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
11332   echo $ac_n "(cached) $ac_c" 1>&6
11333 else
11334
11335
11336     ac_ext=C
11337 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11338 ac_cpp='$CXXCPP $CPPFLAGS'
11339 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11340 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11341 cross_compiling=$ac_cv_prog_cxx_cross
11342
11343     cat > conftest.$ac_ext <<EOF
11344 #line 11345 "configure"
11345 #include "confdefs.h"
11346 #include <math.h>
11347 int main() {
11348  _sincos(0, 0, 0);
11349 ; return 0; }
11350 EOF
11351 if { (eval echo configure:11352: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11352   rm -rf conftest*
11353   glibcpp_cv_func__sincos_use=yes
11354 else
11355   echo "configure: failed program was:" >&5
11356   cat conftest.$ac_ext >&5
11357   rm -rf conftest*
11358   glibcpp_cv_func__sincos_use=no
11359 fi
11360 rm -f conftest*
11361     ac_ext=c
11362 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11363 ac_cpp='$CPP $CPPFLAGS'
11364 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11365 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11366 cross_compiling=$ac_cv_prog_cc_cross
11367
11368
11369 fi
11370
11371   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
11372   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
11373     for ac_func in _sincos
11374 do
11375 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11376 echo "configure:11377: checking for $ac_func" >&5
11377 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11378   echo $ac_n "(cached) $ac_c" 1>&6
11379 else
11380   cat > conftest.$ac_ext <<EOF
11381 #line 11382 "configure"
11382 #include "confdefs.h"
11383 /* System header to define __stub macros and hopefully few prototypes,
11384     which can conflict with char $ac_func(); below.  */
11385 #include <assert.h>
11386 /* Override any gcc2 internal prototype to avoid an error.  */
11387 /* We use char because int might match the return type of a gcc2
11388     builtin and then its argument prototype would still apply.  */
11389 char $ac_func();
11390
11391 int main() {
11392
11393 /* The GNU C library defines this for functions which it implements
11394     to always fail with ENOSYS.  Some functions are actually named
11395     something starting with __ and the normal name is an alias.  */
11396 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11397 choke me
11398 #else
11399 $ac_func();
11400 #endif
11401
11402 ; return 0; }
11403 EOF
11404 if { (eval echo configure:11405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11405   rm -rf conftest*
11406   eval "ac_cv_func_$ac_func=yes"
11407 else
11408   echo "configure: failed program was:" >&5
11409   cat conftest.$ac_ext >&5
11410   rm -rf conftest*
11411   eval "ac_cv_func_$ac_func=no"
11412 fi
11413 rm -f conftest*
11414 fi
11415
11416 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11417   echo "$ac_t""yes" 1>&6
11418     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11419   cat >> confdefs.h <<EOF
11420 #define $ac_tr_func 1
11421 EOF
11422
11423 else
11424   echo "$ac_t""no" 1>&6
11425 fi
11426 done
11427
11428   fi
11429
11430
11431   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
11432 echo "configure:11433: checking for _fpclass declaration" >&5
11433   if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
11434   echo $ac_n "(cached) $ac_c" 1>&6
11435 else
11436
11437
11438     ac_ext=C
11439 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11440 ac_cpp='$CXXCPP $CPPFLAGS'
11441 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11442 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11443 cross_compiling=$ac_cv_prog_cxx_cross
11444
11445     cat > conftest.$ac_ext <<EOF
11446 #line 11447 "configure"
11447 #include "confdefs.h"
11448 #include <math.h>
11449 int main() {
11450  _fpclass(0);
11451 ; return 0; }
11452 EOF
11453 if { (eval echo configure:11454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11454   rm -rf conftest*
11455   glibcpp_cv_func__fpclass_use=yes
11456 else
11457   echo "configure: failed program was:" >&5
11458   cat conftest.$ac_ext >&5
11459   rm -rf conftest*
11460   glibcpp_cv_func__fpclass_use=no
11461 fi
11462 rm -f conftest*
11463     ac_ext=c
11464 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11465 ac_cpp='$CPP $CPPFLAGS'
11466 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11467 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11468 cross_compiling=$ac_cv_prog_cc_cross
11469
11470
11471 fi
11472
11473   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
11474   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
11475     for ac_func in _fpclass
11476 do
11477 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11478 echo "configure:11479: checking for $ac_func" >&5
11479 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11480   echo $ac_n "(cached) $ac_c" 1>&6
11481 else
11482   cat > conftest.$ac_ext <<EOF
11483 #line 11484 "configure"
11484 #include "confdefs.h"
11485 /* System header to define __stub macros and hopefully few prototypes,
11486     which can conflict with char $ac_func(); below.  */
11487 #include <assert.h>
11488 /* Override any gcc2 internal prototype to avoid an error.  */
11489 /* We use char because int might match the return type of a gcc2
11490     builtin and then its argument prototype would still apply.  */
11491 char $ac_func();
11492
11493 int main() {
11494
11495 /* The GNU C library defines this for functions which it implements
11496     to always fail with ENOSYS.  Some functions are actually named
11497     something starting with __ and the normal name is an alias.  */
11498 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11499 choke me
11500 #else
11501 $ac_func();
11502 #endif
11503
11504 ; return 0; }
11505 EOF
11506 if { (eval echo configure:11507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11507   rm -rf conftest*
11508   eval "ac_cv_func_$ac_func=yes"
11509 else
11510   echo "configure: failed program was:" >&5
11511   cat conftest.$ac_ext >&5
11512   rm -rf conftest*
11513   eval "ac_cv_func_$ac_func=no"
11514 fi
11515 rm -f conftest*
11516 fi
11517
11518 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11519   echo "$ac_t""yes" 1>&6
11520     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11521   cat >> confdefs.h <<EOF
11522 #define $ac_tr_func 1
11523 EOF
11524
11525 else
11526   echo "$ac_t""no" 1>&6
11527 fi
11528 done
11529
11530   fi
11531
11532
11533   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
11534 echo "configure:11535: checking for _qfpclass declaration" >&5
11535   if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
11536   echo $ac_n "(cached) $ac_c" 1>&6
11537 else
11538
11539
11540     ac_ext=C
11541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11542 ac_cpp='$CXXCPP $CPPFLAGS'
11543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11545 cross_compiling=$ac_cv_prog_cxx_cross
11546
11547     cat > conftest.$ac_ext <<EOF
11548 #line 11549 "configure"
11549 #include "confdefs.h"
11550 #include <math.h>
11551 int main() {
11552  _qfpclass(0);
11553 ; return 0; }
11554 EOF
11555 if { (eval echo configure:11556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11556   rm -rf conftest*
11557   glibcpp_cv_func__qfpclass_use=yes
11558 else
11559   echo "configure: failed program was:" >&5
11560   cat conftest.$ac_ext >&5
11561   rm -rf conftest*
11562   glibcpp_cv_func__qfpclass_use=no
11563 fi
11564 rm -f conftest*
11565     ac_ext=c
11566 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11567 ac_cpp='$CPP $CPPFLAGS'
11568 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11569 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11570 cross_compiling=$ac_cv_prog_cc_cross
11571
11572
11573 fi
11574
11575   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
11576   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
11577     for ac_func in _qfpclass
11578 do
11579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11580 echo "configure:11581: checking for $ac_func" >&5
11581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11582   echo $ac_n "(cached) $ac_c" 1>&6
11583 else
11584   cat > conftest.$ac_ext <<EOF
11585 #line 11586 "configure"
11586 #include "confdefs.h"
11587 /* System header to define __stub macros and hopefully few prototypes,
11588     which can conflict with char $ac_func(); below.  */
11589 #include <assert.h>
11590 /* Override any gcc2 internal prototype to avoid an error.  */
11591 /* We use char because int might match the return type of a gcc2
11592     builtin and then its argument prototype would still apply.  */
11593 char $ac_func();
11594
11595 int main() {
11596
11597 /* The GNU C library defines this for functions which it implements
11598     to always fail with ENOSYS.  Some functions are actually named
11599     something starting with __ and the normal name is an alias.  */
11600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11601 choke me
11602 #else
11603 $ac_func();
11604 #endif
11605
11606 ; return 0; }
11607 EOF
11608 if { (eval echo configure:11609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11609   rm -rf conftest*
11610   eval "ac_cv_func_$ac_func=yes"
11611 else
11612   echo "configure: failed program was:" >&5
11613   cat conftest.$ac_ext >&5
11614   rm -rf conftest*
11615   eval "ac_cv_func_$ac_func=no"
11616 fi
11617 rm -f conftest*
11618 fi
11619
11620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11621   echo "$ac_t""yes" 1>&6
11622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11623   cat >> confdefs.h <<EOF
11624 #define $ac_tr_func 1
11625 EOF
11626
11627 else
11628   echo "$ac_t""no" 1>&6
11629 fi
11630 done
11631
11632   fi
11633
11634
11635
11636   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
11637 echo "configure:11638: checking for _isnanf declaration" >&5
11638   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
11639   echo $ac_n "(cached) $ac_c" 1>&6
11640 else
11641
11642
11643     ac_ext=C
11644 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11645 ac_cpp='$CXXCPP $CPPFLAGS'
11646 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11647 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11648 cross_compiling=$ac_cv_prog_cxx_cross
11649
11650     cat > conftest.$ac_ext <<EOF
11651 #line 11652 "configure"
11652 #include "confdefs.h"
11653 #include <math.h>
11654 int main() {
11655  _isnanf(0);
11656 ; return 0; }
11657 EOF
11658 if { (eval echo configure:11659: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11659   rm -rf conftest*
11660   glibcpp_cv_func__isnanf_use=yes
11661 else
11662   echo "configure: failed program was:" >&5
11663   cat conftest.$ac_ext >&5
11664   rm -rf conftest*
11665   glibcpp_cv_func__isnanf_use=no
11666 fi
11667 rm -f conftest*
11668     ac_ext=c
11669 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11670 ac_cpp='$CPP $CPPFLAGS'
11671 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11672 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11673 cross_compiling=$ac_cv_prog_cc_cross
11674
11675
11676 fi
11677
11678   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
11679   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
11680     for ac_func in _isnanf
11681 do
11682 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11683 echo "configure:11684: checking for $ac_func" >&5
11684 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11685   echo $ac_n "(cached) $ac_c" 1>&6
11686 else
11687   cat > conftest.$ac_ext <<EOF
11688 #line 11689 "configure"
11689 #include "confdefs.h"
11690 /* System header to define __stub macros and hopefully few prototypes,
11691     which can conflict with char $ac_func(); below.  */
11692 #include <assert.h>
11693 /* Override any gcc2 internal prototype to avoid an error.  */
11694 /* We use char because int might match the return type of a gcc2
11695     builtin and then its argument prototype would still apply.  */
11696 char $ac_func();
11697
11698 int main() {
11699
11700 /* The GNU C library defines this for functions which it implements
11701     to always fail with ENOSYS.  Some functions are actually named
11702     something starting with __ and the normal name is an alias.  */
11703 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11704 choke me
11705 #else
11706 $ac_func();
11707 #endif
11708
11709 ; return 0; }
11710 EOF
11711 if { (eval echo configure:11712: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11712   rm -rf conftest*
11713   eval "ac_cv_func_$ac_func=yes"
11714 else
11715   echo "configure: failed program was:" >&5
11716   cat conftest.$ac_ext >&5
11717   rm -rf conftest*
11718   eval "ac_cv_func_$ac_func=no"
11719 fi
11720 rm -f conftest*
11721 fi
11722
11723 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11724   echo "$ac_t""yes" 1>&6
11725     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11726   cat >> confdefs.h <<EOF
11727 #define $ac_tr_func 1
11728 EOF
11729
11730 else
11731   echo "$ac_t""no" 1>&6
11732 fi
11733 done
11734
11735   fi
11736
11737
11738   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
11739 echo "configure:11740: checking for _isinff declaration" >&5
11740   if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
11741   echo $ac_n "(cached) $ac_c" 1>&6
11742 else
11743
11744
11745     ac_ext=C
11746 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11747 ac_cpp='$CXXCPP $CPPFLAGS'
11748 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11749 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11750 cross_compiling=$ac_cv_prog_cxx_cross
11751
11752     cat > conftest.$ac_ext <<EOF
11753 #line 11754 "configure"
11754 #include "confdefs.h"
11755 #include <math.h>
11756 int main() {
11757  _isinff(0);
11758 ; return 0; }
11759 EOF
11760 if { (eval echo configure:11761: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11761   rm -rf conftest*
11762   glibcpp_cv_func__isinff_use=yes
11763 else
11764   echo "configure: failed program was:" >&5
11765   cat conftest.$ac_ext >&5
11766   rm -rf conftest*
11767   glibcpp_cv_func__isinff_use=no
11768 fi
11769 rm -f conftest*
11770     ac_ext=c
11771 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11772 ac_cpp='$CPP $CPPFLAGS'
11773 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11774 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11775 cross_compiling=$ac_cv_prog_cc_cross
11776
11777
11778 fi
11779
11780   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
11781   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
11782     for ac_func in _isinff
11783 do
11784 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11785 echo "configure:11786: checking for $ac_func" >&5
11786 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11787   echo $ac_n "(cached) $ac_c" 1>&6
11788 else
11789   cat > conftest.$ac_ext <<EOF
11790 #line 11791 "configure"
11791 #include "confdefs.h"
11792 /* System header to define __stub macros and hopefully few prototypes,
11793     which can conflict with char $ac_func(); below.  */
11794 #include <assert.h>
11795 /* Override any gcc2 internal prototype to avoid an error.  */
11796 /* We use char because int might match the return type of a gcc2
11797     builtin and then its argument prototype would still apply.  */
11798 char $ac_func();
11799
11800 int main() {
11801
11802 /* The GNU C library defines this for functions which it implements
11803     to always fail with ENOSYS.  Some functions are actually named
11804     something starting with __ and the normal name is an alias.  */
11805 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11806 choke me
11807 #else
11808 $ac_func();
11809 #endif
11810
11811 ; return 0; }
11812 EOF
11813 if { (eval echo configure:11814: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11814   rm -rf conftest*
11815   eval "ac_cv_func_$ac_func=yes"
11816 else
11817   echo "configure: failed program was:" >&5
11818   cat conftest.$ac_ext >&5
11819   rm -rf conftest*
11820   eval "ac_cv_func_$ac_func=no"
11821 fi
11822 rm -f conftest*
11823 fi
11824
11825 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11826   echo "$ac_t""yes" 1>&6
11827     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11828   cat >> confdefs.h <<EOF
11829 #define $ac_tr_func 1
11830 EOF
11831
11832 else
11833   echo "$ac_t""no" 1>&6
11834 fi
11835 done
11836
11837   fi
11838
11839
11840   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
11841 echo "configure:11842: checking for _acosf declaration" >&5
11842   if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
11843   echo $ac_n "(cached) $ac_c" 1>&6
11844 else
11845
11846
11847     ac_ext=C
11848 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11849 ac_cpp='$CXXCPP $CPPFLAGS'
11850 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11851 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11852 cross_compiling=$ac_cv_prog_cxx_cross
11853
11854     cat > conftest.$ac_ext <<EOF
11855 #line 11856 "configure"
11856 #include "confdefs.h"
11857 #include <math.h>
11858 int main() {
11859  _acosf(0);
11860 ; return 0; }
11861 EOF
11862 if { (eval echo configure:11863: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11863   rm -rf conftest*
11864   glibcpp_cv_func__acosf_use=yes
11865 else
11866   echo "configure: failed program was:" >&5
11867   cat conftest.$ac_ext >&5
11868   rm -rf conftest*
11869   glibcpp_cv_func__acosf_use=no
11870 fi
11871 rm -f conftest*
11872     ac_ext=c
11873 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11874 ac_cpp='$CPP $CPPFLAGS'
11875 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11876 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11877 cross_compiling=$ac_cv_prog_cc_cross
11878
11879
11880 fi
11881
11882   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
11883   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
11884     for ac_func in _acosf
11885 do
11886 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11887 echo "configure:11888: checking for $ac_func" >&5
11888 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11889   echo $ac_n "(cached) $ac_c" 1>&6
11890 else
11891   cat > conftest.$ac_ext <<EOF
11892 #line 11893 "configure"
11893 #include "confdefs.h"
11894 /* System header to define __stub macros and hopefully few prototypes,
11895     which can conflict with char $ac_func(); below.  */
11896 #include <assert.h>
11897 /* Override any gcc2 internal prototype to avoid an error.  */
11898 /* We use char because int might match the return type of a gcc2
11899     builtin and then its argument prototype would still apply.  */
11900 char $ac_func();
11901
11902 int main() {
11903
11904 /* The GNU C library defines this for functions which it implements
11905     to always fail with ENOSYS.  Some functions are actually named
11906     something starting with __ and the normal name is an alias.  */
11907 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11908 choke me
11909 #else
11910 $ac_func();
11911 #endif
11912
11913 ; return 0; }
11914 EOF
11915 if { (eval echo configure:11916: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11916   rm -rf conftest*
11917   eval "ac_cv_func_$ac_func=yes"
11918 else
11919   echo "configure: failed program was:" >&5
11920   cat conftest.$ac_ext >&5
11921   rm -rf conftest*
11922   eval "ac_cv_func_$ac_func=no"
11923 fi
11924 rm -f conftest*
11925 fi
11926
11927 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11928   echo "$ac_t""yes" 1>&6
11929     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11930   cat >> confdefs.h <<EOF
11931 #define $ac_tr_func 1
11932 EOF
11933
11934 else
11935   echo "$ac_t""no" 1>&6
11936 fi
11937 done
11938
11939   fi
11940
11941
11942   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
11943 echo "configure:11944: checking for _asinf declaration" >&5
11944   if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
11945   echo $ac_n "(cached) $ac_c" 1>&6
11946 else
11947
11948
11949     ac_ext=C
11950 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11951 ac_cpp='$CXXCPP $CPPFLAGS'
11952 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11953 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11954 cross_compiling=$ac_cv_prog_cxx_cross
11955
11956     cat > conftest.$ac_ext <<EOF
11957 #line 11958 "configure"
11958 #include "confdefs.h"
11959 #include <math.h>
11960 int main() {
11961  _asinf(0);
11962 ; return 0; }
11963 EOF
11964 if { (eval echo configure:11965: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11965   rm -rf conftest*
11966   glibcpp_cv_func__asinf_use=yes
11967 else
11968   echo "configure: failed program was:" >&5
11969   cat conftest.$ac_ext >&5
11970   rm -rf conftest*
11971   glibcpp_cv_func__asinf_use=no
11972 fi
11973 rm -f conftest*
11974     ac_ext=c
11975 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11976 ac_cpp='$CPP $CPPFLAGS'
11977 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11978 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11979 cross_compiling=$ac_cv_prog_cc_cross
11980
11981
11982 fi
11983
11984   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
11985   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
11986     for ac_func in _asinf
11987 do
11988 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11989 echo "configure:11990: checking for $ac_func" >&5
11990 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11991   echo $ac_n "(cached) $ac_c" 1>&6
11992 else
11993   cat > conftest.$ac_ext <<EOF
11994 #line 11995 "configure"
11995 #include "confdefs.h"
11996 /* System header to define __stub macros and hopefully few prototypes,
11997     which can conflict with char $ac_func(); below.  */
11998 #include <assert.h>
11999 /* Override any gcc2 internal prototype to avoid an error.  */
12000 /* We use char because int might match the return type of a gcc2
12001     builtin and then its argument prototype would still apply.  */
12002 char $ac_func();
12003
12004 int main() {
12005
12006 /* The GNU C library defines this for functions which it implements
12007     to always fail with ENOSYS.  Some functions are actually named
12008     something starting with __ and the normal name is an alias.  */
12009 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12010 choke me
12011 #else
12012 $ac_func();
12013 #endif
12014
12015 ; return 0; }
12016 EOF
12017 if { (eval echo configure:12018: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12018   rm -rf conftest*
12019   eval "ac_cv_func_$ac_func=yes"
12020 else
12021   echo "configure: failed program was:" >&5
12022   cat conftest.$ac_ext >&5
12023   rm -rf conftest*
12024   eval "ac_cv_func_$ac_func=no"
12025 fi
12026 rm -f conftest*
12027 fi
12028
12029 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12030   echo "$ac_t""yes" 1>&6
12031     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12032   cat >> confdefs.h <<EOF
12033 #define $ac_tr_func 1
12034 EOF
12035
12036 else
12037   echo "$ac_t""no" 1>&6
12038 fi
12039 done
12040
12041   fi
12042
12043
12044   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
12045 echo "configure:12046: checking for _atanf declaration" >&5
12046   if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
12047   echo $ac_n "(cached) $ac_c" 1>&6
12048 else
12049
12050
12051     ac_ext=C
12052 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12053 ac_cpp='$CXXCPP $CPPFLAGS'
12054 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12055 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12056 cross_compiling=$ac_cv_prog_cxx_cross
12057
12058     cat > conftest.$ac_ext <<EOF
12059 #line 12060 "configure"
12060 #include "confdefs.h"
12061 #include <math.h>
12062 int main() {
12063  _atanf(0);
12064 ; return 0; }
12065 EOF
12066 if { (eval echo configure:12067: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12067   rm -rf conftest*
12068   glibcpp_cv_func__atanf_use=yes
12069 else
12070   echo "configure: failed program was:" >&5
12071   cat conftest.$ac_ext >&5
12072   rm -rf conftest*
12073   glibcpp_cv_func__atanf_use=no
12074 fi
12075 rm -f conftest*
12076     ac_ext=c
12077 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12078 ac_cpp='$CPP $CPPFLAGS'
12079 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12080 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12081 cross_compiling=$ac_cv_prog_cc_cross
12082
12083
12084 fi
12085
12086   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
12087   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
12088     for ac_func in _atanf
12089 do
12090 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12091 echo "configure:12092: checking for $ac_func" >&5
12092 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12093   echo $ac_n "(cached) $ac_c" 1>&6
12094 else
12095   cat > conftest.$ac_ext <<EOF
12096 #line 12097 "configure"
12097 #include "confdefs.h"
12098 /* System header to define __stub macros and hopefully few prototypes,
12099     which can conflict with char $ac_func(); below.  */
12100 #include <assert.h>
12101 /* Override any gcc2 internal prototype to avoid an error.  */
12102 /* We use char because int might match the return type of a gcc2
12103     builtin and then its argument prototype would still apply.  */
12104 char $ac_func();
12105
12106 int main() {
12107
12108 /* The GNU C library defines this for functions which it implements
12109     to always fail with ENOSYS.  Some functions are actually named
12110     something starting with __ and the normal name is an alias.  */
12111 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12112 choke me
12113 #else
12114 $ac_func();
12115 #endif
12116
12117 ; return 0; }
12118 EOF
12119 if { (eval echo configure:12120: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12120   rm -rf conftest*
12121   eval "ac_cv_func_$ac_func=yes"
12122 else
12123   echo "configure: failed program was:" >&5
12124   cat conftest.$ac_ext >&5
12125   rm -rf conftest*
12126   eval "ac_cv_func_$ac_func=no"
12127 fi
12128 rm -f conftest*
12129 fi
12130
12131 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12132   echo "$ac_t""yes" 1>&6
12133     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12134   cat >> confdefs.h <<EOF
12135 #define $ac_tr_func 1
12136 EOF
12137
12138 else
12139   echo "$ac_t""no" 1>&6
12140 fi
12141 done
12142
12143   fi
12144
12145
12146   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
12147 echo "configure:12148: checking for _atan2f declaration" >&5
12148   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
12149   echo $ac_n "(cached) $ac_c" 1>&6
12150 else
12151
12152
12153     ac_ext=C
12154 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12155 ac_cpp='$CXXCPP $CPPFLAGS'
12156 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12157 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12158 cross_compiling=$ac_cv_prog_cxx_cross
12159
12160     cat > conftest.$ac_ext <<EOF
12161 #line 12162 "configure"
12162 #include "confdefs.h"
12163 #include <math.h>
12164 int main() {
12165  _atan2f(0, 0);
12166 ; return 0; }
12167 EOF
12168 if { (eval echo configure:12169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12169   rm -rf conftest*
12170   glibcpp_cv_func__atan2f_use=yes
12171 else
12172   echo "configure: failed program was:" >&5
12173   cat conftest.$ac_ext >&5
12174   rm -rf conftest*
12175   glibcpp_cv_func__atan2f_use=no
12176 fi
12177 rm -f conftest*
12178     ac_ext=c
12179 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12180 ac_cpp='$CPP $CPPFLAGS'
12181 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12182 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12183 cross_compiling=$ac_cv_prog_cc_cross
12184
12185
12186 fi
12187
12188   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
12189   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
12190     for ac_func in _atan2f
12191 do
12192 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12193 echo "configure:12194: checking for $ac_func" >&5
12194 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12195   echo $ac_n "(cached) $ac_c" 1>&6
12196 else
12197   cat > conftest.$ac_ext <<EOF
12198 #line 12199 "configure"
12199 #include "confdefs.h"
12200 /* System header to define __stub macros and hopefully few prototypes,
12201     which can conflict with char $ac_func(); below.  */
12202 #include <assert.h>
12203 /* Override any gcc2 internal prototype to avoid an error.  */
12204 /* We use char because int might match the return type of a gcc2
12205     builtin and then its argument prototype would still apply.  */
12206 char $ac_func();
12207
12208 int main() {
12209
12210 /* The GNU C library defines this for functions which it implements
12211     to always fail with ENOSYS.  Some functions are actually named
12212     something starting with __ and the normal name is an alias.  */
12213 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12214 choke me
12215 #else
12216 $ac_func();
12217 #endif
12218
12219 ; return 0; }
12220 EOF
12221 if { (eval echo configure:12222: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12222   rm -rf conftest*
12223   eval "ac_cv_func_$ac_func=yes"
12224 else
12225   echo "configure: failed program was:" >&5
12226   cat conftest.$ac_ext >&5
12227   rm -rf conftest*
12228   eval "ac_cv_func_$ac_func=no"
12229 fi
12230 rm -f conftest*
12231 fi
12232
12233 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12234   echo "$ac_t""yes" 1>&6
12235     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12236   cat >> confdefs.h <<EOF
12237 #define $ac_tr_func 1
12238 EOF
12239
12240 else
12241   echo "$ac_t""no" 1>&6
12242 fi
12243 done
12244
12245   fi
12246
12247
12248   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
12249 echo "configure:12250: checking for _ceilf declaration" >&5
12250   if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
12251   echo $ac_n "(cached) $ac_c" 1>&6
12252 else
12253
12254
12255     ac_ext=C
12256 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12257 ac_cpp='$CXXCPP $CPPFLAGS'
12258 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12259 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12260 cross_compiling=$ac_cv_prog_cxx_cross
12261
12262     cat > conftest.$ac_ext <<EOF
12263 #line 12264 "configure"
12264 #include "confdefs.h"
12265 #include <math.h>
12266 int main() {
12267  _ceilf(0);
12268 ; return 0; }
12269 EOF
12270 if { (eval echo configure:12271: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12271   rm -rf conftest*
12272   glibcpp_cv_func__ceilf_use=yes
12273 else
12274   echo "configure: failed program was:" >&5
12275   cat conftest.$ac_ext >&5
12276   rm -rf conftest*
12277   glibcpp_cv_func__ceilf_use=no
12278 fi
12279 rm -f conftest*
12280     ac_ext=c
12281 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12282 ac_cpp='$CPP $CPPFLAGS'
12283 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12284 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12285 cross_compiling=$ac_cv_prog_cc_cross
12286
12287
12288 fi
12289
12290   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
12291   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
12292     for ac_func in _ceilf
12293 do
12294 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12295 echo "configure:12296: checking for $ac_func" >&5
12296 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12297   echo $ac_n "(cached) $ac_c" 1>&6
12298 else
12299   cat > conftest.$ac_ext <<EOF
12300 #line 12301 "configure"
12301 #include "confdefs.h"
12302 /* System header to define __stub macros and hopefully few prototypes,
12303     which can conflict with char $ac_func(); below.  */
12304 #include <assert.h>
12305 /* Override any gcc2 internal prototype to avoid an error.  */
12306 /* We use char because int might match the return type of a gcc2
12307     builtin and then its argument prototype would still apply.  */
12308 char $ac_func();
12309
12310 int main() {
12311
12312 /* The GNU C library defines this for functions which it implements
12313     to always fail with ENOSYS.  Some functions are actually named
12314     something starting with __ and the normal name is an alias.  */
12315 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12316 choke me
12317 #else
12318 $ac_func();
12319 #endif
12320
12321 ; return 0; }
12322 EOF
12323 if { (eval echo configure:12324: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12324   rm -rf conftest*
12325   eval "ac_cv_func_$ac_func=yes"
12326 else
12327   echo "configure: failed program was:" >&5
12328   cat conftest.$ac_ext >&5
12329   rm -rf conftest*
12330   eval "ac_cv_func_$ac_func=no"
12331 fi
12332 rm -f conftest*
12333 fi
12334
12335 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12336   echo "$ac_t""yes" 1>&6
12337     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12338   cat >> confdefs.h <<EOF
12339 #define $ac_tr_func 1
12340 EOF
12341
12342 else
12343   echo "$ac_t""no" 1>&6
12344 fi
12345 done
12346
12347   fi
12348
12349
12350   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
12351 echo "configure:12352: checking for _cosf declaration" >&5
12352   if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
12353   echo $ac_n "(cached) $ac_c" 1>&6
12354 else
12355
12356
12357     ac_ext=C
12358 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12359 ac_cpp='$CXXCPP $CPPFLAGS'
12360 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12361 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12362 cross_compiling=$ac_cv_prog_cxx_cross
12363
12364     cat > conftest.$ac_ext <<EOF
12365 #line 12366 "configure"
12366 #include "confdefs.h"
12367 #include <math.h>
12368 int main() {
12369  _cosf(0);
12370 ; return 0; }
12371 EOF
12372 if { (eval echo configure:12373: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12373   rm -rf conftest*
12374   glibcpp_cv_func__cosf_use=yes
12375 else
12376   echo "configure: failed program was:" >&5
12377   cat conftest.$ac_ext >&5
12378   rm -rf conftest*
12379   glibcpp_cv_func__cosf_use=no
12380 fi
12381 rm -f conftest*
12382     ac_ext=c
12383 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12384 ac_cpp='$CPP $CPPFLAGS'
12385 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12386 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12387 cross_compiling=$ac_cv_prog_cc_cross
12388
12389
12390 fi
12391
12392   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
12393   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
12394     for ac_func in _cosf
12395 do
12396 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12397 echo "configure:12398: checking for $ac_func" >&5
12398 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12399   echo $ac_n "(cached) $ac_c" 1>&6
12400 else
12401   cat > conftest.$ac_ext <<EOF
12402 #line 12403 "configure"
12403 #include "confdefs.h"
12404 /* System header to define __stub macros and hopefully few prototypes,
12405     which can conflict with char $ac_func(); below.  */
12406 #include <assert.h>
12407 /* Override any gcc2 internal prototype to avoid an error.  */
12408 /* We use char because int might match the return type of a gcc2
12409     builtin and then its argument prototype would still apply.  */
12410 char $ac_func();
12411
12412 int main() {
12413
12414 /* The GNU C library defines this for functions which it implements
12415     to always fail with ENOSYS.  Some functions are actually named
12416     something starting with __ and the normal name is an alias.  */
12417 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12418 choke me
12419 #else
12420 $ac_func();
12421 #endif
12422
12423 ; return 0; }
12424 EOF
12425 if { (eval echo configure:12426: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12426   rm -rf conftest*
12427   eval "ac_cv_func_$ac_func=yes"
12428 else
12429   echo "configure: failed program was:" >&5
12430   cat conftest.$ac_ext >&5
12431   rm -rf conftest*
12432   eval "ac_cv_func_$ac_func=no"
12433 fi
12434 rm -f conftest*
12435 fi
12436
12437 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12438   echo "$ac_t""yes" 1>&6
12439     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12440   cat >> confdefs.h <<EOF
12441 #define $ac_tr_func 1
12442 EOF
12443
12444 else
12445   echo "$ac_t""no" 1>&6
12446 fi
12447 done
12448
12449   fi
12450
12451
12452   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
12453 echo "configure:12454: checking for _coshf declaration" >&5
12454   if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
12455   echo $ac_n "(cached) $ac_c" 1>&6
12456 else
12457
12458
12459     ac_ext=C
12460 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12461 ac_cpp='$CXXCPP $CPPFLAGS'
12462 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12463 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12464 cross_compiling=$ac_cv_prog_cxx_cross
12465
12466     cat > conftest.$ac_ext <<EOF
12467 #line 12468 "configure"
12468 #include "confdefs.h"
12469 #include <math.h>
12470 int main() {
12471  _coshf(0);
12472 ; return 0; }
12473 EOF
12474 if { (eval echo configure:12475: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12475   rm -rf conftest*
12476   glibcpp_cv_func__coshf_use=yes
12477 else
12478   echo "configure: failed program was:" >&5
12479   cat conftest.$ac_ext >&5
12480   rm -rf conftest*
12481   glibcpp_cv_func__coshf_use=no
12482 fi
12483 rm -f conftest*
12484     ac_ext=c
12485 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12486 ac_cpp='$CPP $CPPFLAGS'
12487 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12488 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12489 cross_compiling=$ac_cv_prog_cc_cross
12490
12491
12492 fi
12493
12494   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
12495   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
12496     for ac_func in _coshf
12497 do
12498 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12499 echo "configure:12500: checking for $ac_func" >&5
12500 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12501   echo $ac_n "(cached) $ac_c" 1>&6
12502 else
12503   cat > conftest.$ac_ext <<EOF
12504 #line 12505 "configure"
12505 #include "confdefs.h"
12506 /* System header to define __stub macros and hopefully few prototypes,
12507     which can conflict with char $ac_func(); below.  */
12508 #include <assert.h>
12509 /* Override any gcc2 internal prototype to avoid an error.  */
12510 /* We use char because int might match the return type of a gcc2
12511     builtin and then its argument prototype would still apply.  */
12512 char $ac_func();
12513
12514 int main() {
12515
12516 /* The GNU C library defines this for functions which it implements
12517     to always fail with ENOSYS.  Some functions are actually named
12518     something starting with __ and the normal name is an alias.  */
12519 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12520 choke me
12521 #else
12522 $ac_func();
12523 #endif
12524
12525 ; return 0; }
12526 EOF
12527 if { (eval echo configure:12528: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12528   rm -rf conftest*
12529   eval "ac_cv_func_$ac_func=yes"
12530 else
12531   echo "configure: failed program was:" >&5
12532   cat conftest.$ac_ext >&5
12533   rm -rf conftest*
12534   eval "ac_cv_func_$ac_func=no"
12535 fi
12536 rm -f conftest*
12537 fi
12538
12539 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12540   echo "$ac_t""yes" 1>&6
12541     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12542   cat >> confdefs.h <<EOF
12543 #define $ac_tr_func 1
12544 EOF
12545
12546 else
12547   echo "$ac_t""no" 1>&6
12548 fi
12549 done
12550
12551   fi
12552
12553
12554   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
12555 echo "configure:12556: checking for _expf declaration" >&5
12556   if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
12557   echo $ac_n "(cached) $ac_c" 1>&6
12558 else
12559
12560
12561     ac_ext=C
12562 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12563 ac_cpp='$CXXCPP $CPPFLAGS'
12564 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12565 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12566 cross_compiling=$ac_cv_prog_cxx_cross
12567
12568     cat > conftest.$ac_ext <<EOF
12569 #line 12570 "configure"
12570 #include "confdefs.h"
12571 #include <math.h>
12572 int main() {
12573  _expf(0);
12574 ; return 0; }
12575 EOF
12576 if { (eval echo configure:12577: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12577   rm -rf conftest*
12578   glibcpp_cv_func__expf_use=yes
12579 else
12580   echo "configure: failed program was:" >&5
12581   cat conftest.$ac_ext >&5
12582   rm -rf conftest*
12583   glibcpp_cv_func__expf_use=no
12584 fi
12585 rm -f conftest*
12586     ac_ext=c
12587 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12588 ac_cpp='$CPP $CPPFLAGS'
12589 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12590 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12591 cross_compiling=$ac_cv_prog_cc_cross
12592
12593
12594 fi
12595
12596   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
12597   if test x$glibcpp_cv_func__expf_use = x"yes"; then
12598     for ac_func in _expf
12599 do
12600 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12601 echo "configure:12602: checking for $ac_func" >&5
12602 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12603   echo $ac_n "(cached) $ac_c" 1>&6
12604 else
12605   cat > conftest.$ac_ext <<EOF
12606 #line 12607 "configure"
12607 #include "confdefs.h"
12608 /* System header to define __stub macros and hopefully few prototypes,
12609     which can conflict with char $ac_func(); below.  */
12610 #include <assert.h>
12611 /* Override any gcc2 internal prototype to avoid an error.  */
12612 /* We use char because int might match the return type of a gcc2
12613     builtin and then its argument prototype would still apply.  */
12614 char $ac_func();
12615
12616 int main() {
12617
12618 /* The GNU C library defines this for functions which it implements
12619     to always fail with ENOSYS.  Some functions are actually named
12620     something starting with __ and the normal name is an alias.  */
12621 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12622 choke me
12623 #else
12624 $ac_func();
12625 #endif
12626
12627 ; return 0; }
12628 EOF
12629 if { (eval echo configure:12630: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12630   rm -rf conftest*
12631   eval "ac_cv_func_$ac_func=yes"
12632 else
12633   echo "configure: failed program was:" >&5
12634   cat conftest.$ac_ext >&5
12635   rm -rf conftest*
12636   eval "ac_cv_func_$ac_func=no"
12637 fi
12638 rm -f conftest*
12639 fi
12640
12641 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12642   echo "$ac_t""yes" 1>&6
12643     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12644   cat >> confdefs.h <<EOF
12645 #define $ac_tr_func 1
12646 EOF
12647
12648 else
12649   echo "$ac_t""no" 1>&6
12650 fi
12651 done
12652
12653   fi
12654
12655
12656   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
12657 echo "configure:12658: checking for _fabsf declaration" >&5
12658   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
12659   echo $ac_n "(cached) $ac_c" 1>&6
12660 else
12661
12662
12663     ac_ext=C
12664 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12665 ac_cpp='$CXXCPP $CPPFLAGS'
12666 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12667 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12668 cross_compiling=$ac_cv_prog_cxx_cross
12669
12670     cat > conftest.$ac_ext <<EOF
12671 #line 12672 "configure"
12672 #include "confdefs.h"
12673 #include <math.h>
12674 int main() {
12675  _fabsf(0);
12676 ; return 0; }
12677 EOF
12678 if { (eval echo configure:12679: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12679   rm -rf conftest*
12680   glibcpp_cv_func__fabsf_use=yes
12681 else
12682   echo "configure: failed program was:" >&5
12683   cat conftest.$ac_ext >&5
12684   rm -rf conftest*
12685   glibcpp_cv_func__fabsf_use=no
12686 fi
12687 rm -f conftest*
12688     ac_ext=c
12689 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12690 ac_cpp='$CPP $CPPFLAGS'
12691 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12692 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12693 cross_compiling=$ac_cv_prog_cc_cross
12694
12695
12696 fi
12697
12698   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
12699   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
12700     for ac_func in _fabsf
12701 do
12702 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12703 echo "configure:12704: checking for $ac_func" >&5
12704 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12705   echo $ac_n "(cached) $ac_c" 1>&6
12706 else
12707   cat > conftest.$ac_ext <<EOF
12708 #line 12709 "configure"
12709 #include "confdefs.h"
12710 /* System header to define __stub macros and hopefully few prototypes,
12711     which can conflict with char $ac_func(); below.  */
12712 #include <assert.h>
12713 /* Override any gcc2 internal prototype to avoid an error.  */
12714 /* We use char because int might match the return type of a gcc2
12715     builtin and then its argument prototype would still apply.  */
12716 char $ac_func();
12717
12718 int main() {
12719
12720 /* The GNU C library defines this for functions which it implements
12721     to always fail with ENOSYS.  Some functions are actually named
12722     something starting with __ and the normal name is an alias.  */
12723 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12724 choke me
12725 #else
12726 $ac_func();
12727 #endif
12728
12729 ; return 0; }
12730 EOF
12731 if { (eval echo configure:12732: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12732   rm -rf conftest*
12733   eval "ac_cv_func_$ac_func=yes"
12734 else
12735   echo "configure: failed program was:" >&5
12736   cat conftest.$ac_ext >&5
12737   rm -rf conftest*
12738   eval "ac_cv_func_$ac_func=no"
12739 fi
12740 rm -f conftest*
12741 fi
12742
12743 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12744   echo "$ac_t""yes" 1>&6
12745     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12746   cat >> confdefs.h <<EOF
12747 #define $ac_tr_func 1
12748 EOF
12749
12750 else
12751   echo "$ac_t""no" 1>&6
12752 fi
12753 done
12754
12755   fi
12756
12757
12758   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
12759 echo "configure:12760: checking for _floorf declaration" >&5
12760   if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
12761   echo $ac_n "(cached) $ac_c" 1>&6
12762 else
12763
12764
12765     ac_ext=C
12766 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12767 ac_cpp='$CXXCPP $CPPFLAGS'
12768 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12769 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12770 cross_compiling=$ac_cv_prog_cxx_cross
12771
12772     cat > conftest.$ac_ext <<EOF
12773 #line 12774 "configure"
12774 #include "confdefs.h"
12775 #include <math.h>
12776 int main() {
12777  _floorf(0);
12778 ; return 0; }
12779 EOF
12780 if { (eval echo configure:12781: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12781   rm -rf conftest*
12782   glibcpp_cv_func__floorf_use=yes
12783 else
12784   echo "configure: failed program was:" >&5
12785   cat conftest.$ac_ext >&5
12786   rm -rf conftest*
12787   glibcpp_cv_func__floorf_use=no
12788 fi
12789 rm -f conftest*
12790     ac_ext=c
12791 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12792 ac_cpp='$CPP $CPPFLAGS'
12793 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12794 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12795 cross_compiling=$ac_cv_prog_cc_cross
12796
12797
12798 fi
12799
12800   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
12801   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
12802     for ac_func in _floorf
12803 do
12804 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12805 echo "configure:12806: checking for $ac_func" >&5
12806 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12807   echo $ac_n "(cached) $ac_c" 1>&6
12808 else
12809   cat > conftest.$ac_ext <<EOF
12810 #line 12811 "configure"
12811 #include "confdefs.h"
12812 /* System header to define __stub macros and hopefully few prototypes,
12813     which can conflict with char $ac_func(); below.  */
12814 #include <assert.h>
12815 /* Override any gcc2 internal prototype to avoid an error.  */
12816 /* We use char because int might match the return type of a gcc2
12817     builtin and then its argument prototype would still apply.  */
12818 char $ac_func();
12819
12820 int main() {
12821
12822 /* The GNU C library defines this for functions which it implements
12823     to always fail with ENOSYS.  Some functions are actually named
12824     something starting with __ and the normal name is an alias.  */
12825 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12826 choke me
12827 #else
12828 $ac_func();
12829 #endif
12830
12831 ; return 0; }
12832 EOF
12833 if { (eval echo configure:12834: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12834   rm -rf conftest*
12835   eval "ac_cv_func_$ac_func=yes"
12836 else
12837   echo "configure: failed program was:" >&5
12838   cat conftest.$ac_ext >&5
12839   rm -rf conftest*
12840   eval "ac_cv_func_$ac_func=no"
12841 fi
12842 rm -f conftest*
12843 fi
12844
12845 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12846   echo "$ac_t""yes" 1>&6
12847     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12848   cat >> confdefs.h <<EOF
12849 #define $ac_tr_func 1
12850 EOF
12851
12852 else
12853   echo "$ac_t""no" 1>&6
12854 fi
12855 done
12856
12857   fi
12858
12859
12860   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
12861 echo "configure:12862: checking for _fmodf declaration" >&5
12862   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
12863   echo $ac_n "(cached) $ac_c" 1>&6
12864 else
12865
12866
12867     ac_ext=C
12868 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12869 ac_cpp='$CXXCPP $CPPFLAGS'
12870 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12871 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12872 cross_compiling=$ac_cv_prog_cxx_cross
12873
12874     cat > conftest.$ac_ext <<EOF
12875 #line 12876 "configure"
12876 #include "confdefs.h"
12877 #include <math.h>
12878 int main() {
12879  _fmodf(0, 0);
12880 ; return 0; }
12881 EOF
12882 if { (eval echo configure:12883: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12883   rm -rf conftest*
12884   glibcpp_cv_func__fmodf_use=yes
12885 else
12886   echo "configure: failed program was:" >&5
12887   cat conftest.$ac_ext >&5
12888   rm -rf conftest*
12889   glibcpp_cv_func__fmodf_use=no
12890 fi
12891 rm -f conftest*
12892     ac_ext=c
12893 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12894 ac_cpp='$CPP $CPPFLAGS'
12895 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12896 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12897 cross_compiling=$ac_cv_prog_cc_cross
12898
12899
12900 fi
12901
12902   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
12903   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
12904     for ac_func in _fmodf
12905 do
12906 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12907 echo "configure:12908: checking for $ac_func" >&5
12908 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12909   echo $ac_n "(cached) $ac_c" 1>&6
12910 else
12911   cat > conftest.$ac_ext <<EOF
12912 #line 12913 "configure"
12913 #include "confdefs.h"
12914 /* System header to define __stub macros and hopefully few prototypes,
12915     which can conflict with char $ac_func(); below.  */
12916 #include <assert.h>
12917 /* Override any gcc2 internal prototype to avoid an error.  */
12918 /* We use char because int might match the return type of a gcc2
12919     builtin and then its argument prototype would still apply.  */
12920 char $ac_func();
12921
12922 int main() {
12923
12924 /* The GNU C library defines this for functions which it implements
12925     to always fail with ENOSYS.  Some functions are actually named
12926     something starting with __ and the normal name is an alias.  */
12927 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12928 choke me
12929 #else
12930 $ac_func();
12931 #endif
12932
12933 ; return 0; }
12934 EOF
12935 if { (eval echo configure:12936: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12936   rm -rf conftest*
12937   eval "ac_cv_func_$ac_func=yes"
12938 else
12939   echo "configure: failed program was:" >&5
12940   cat conftest.$ac_ext >&5
12941   rm -rf conftest*
12942   eval "ac_cv_func_$ac_func=no"
12943 fi
12944 rm -f conftest*
12945 fi
12946
12947 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12948   echo "$ac_t""yes" 1>&6
12949     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12950   cat >> confdefs.h <<EOF
12951 #define $ac_tr_func 1
12952 EOF
12953
12954 else
12955   echo "$ac_t""no" 1>&6
12956 fi
12957 done
12958
12959   fi
12960
12961
12962   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
12963 echo "configure:12964: checking for _frexpf declaration" >&5
12964   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
12965   echo $ac_n "(cached) $ac_c" 1>&6
12966 else
12967
12968
12969     ac_ext=C
12970 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12971 ac_cpp='$CXXCPP $CPPFLAGS'
12972 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12973 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12974 cross_compiling=$ac_cv_prog_cxx_cross
12975
12976     cat > conftest.$ac_ext <<EOF
12977 #line 12978 "configure"
12978 #include "confdefs.h"
12979 #include <math.h>
12980 int main() {
12981  _frexpf(0, 0);
12982 ; return 0; }
12983 EOF
12984 if { (eval echo configure:12985: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12985   rm -rf conftest*
12986   glibcpp_cv_func__frexpf_use=yes
12987 else
12988   echo "configure: failed program was:" >&5
12989   cat conftest.$ac_ext >&5
12990   rm -rf conftest*
12991   glibcpp_cv_func__frexpf_use=no
12992 fi
12993 rm -f conftest*
12994     ac_ext=c
12995 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12996 ac_cpp='$CPP $CPPFLAGS'
12997 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12998 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12999 cross_compiling=$ac_cv_prog_cc_cross
13000
13001
13002 fi
13003
13004   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
13005   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
13006     for ac_func in _frexpf
13007 do
13008 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13009 echo "configure:13010: checking for $ac_func" >&5
13010 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13011   echo $ac_n "(cached) $ac_c" 1>&6
13012 else
13013   cat > conftest.$ac_ext <<EOF
13014 #line 13015 "configure"
13015 #include "confdefs.h"
13016 /* System header to define __stub macros and hopefully few prototypes,
13017     which can conflict with char $ac_func(); below.  */
13018 #include <assert.h>
13019 /* Override any gcc2 internal prototype to avoid an error.  */
13020 /* We use char because int might match the return type of a gcc2
13021     builtin and then its argument prototype would still apply.  */
13022 char $ac_func();
13023
13024 int main() {
13025
13026 /* The GNU C library defines this for functions which it implements
13027     to always fail with ENOSYS.  Some functions are actually named
13028     something starting with __ and the normal name is an alias.  */
13029 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13030 choke me
13031 #else
13032 $ac_func();
13033 #endif
13034
13035 ; return 0; }
13036 EOF
13037 if { (eval echo configure:13038: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13038   rm -rf conftest*
13039   eval "ac_cv_func_$ac_func=yes"
13040 else
13041   echo "configure: failed program was:" >&5
13042   cat conftest.$ac_ext >&5
13043   rm -rf conftest*
13044   eval "ac_cv_func_$ac_func=no"
13045 fi
13046 rm -f conftest*
13047 fi
13048
13049 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13050   echo "$ac_t""yes" 1>&6
13051     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13052   cat >> confdefs.h <<EOF
13053 #define $ac_tr_func 1
13054 EOF
13055
13056 else
13057   echo "$ac_t""no" 1>&6
13058 fi
13059 done
13060
13061   fi
13062
13063
13064   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13065 echo "configure:13066: checking for _ldexpf declaration" >&5
13066   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13067   echo $ac_n "(cached) $ac_c" 1>&6
13068 else
13069
13070
13071     ac_ext=C
13072 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13073 ac_cpp='$CXXCPP $CPPFLAGS'
13074 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13075 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13076 cross_compiling=$ac_cv_prog_cxx_cross
13077
13078     cat > conftest.$ac_ext <<EOF
13079 #line 13080 "configure"
13080 #include "confdefs.h"
13081 #include <math.h>
13082 int main() {
13083  _ldexpf(0, 0);
13084 ; return 0; }
13085 EOF
13086 if { (eval echo configure:13087: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13087   rm -rf conftest*
13088   glibcpp_cv_func__ldexpf_use=yes
13089 else
13090   echo "configure: failed program was:" >&5
13091   cat conftest.$ac_ext >&5
13092   rm -rf conftest*
13093   glibcpp_cv_func__ldexpf_use=no
13094 fi
13095 rm -f conftest*
13096     ac_ext=c
13097 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13098 ac_cpp='$CPP $CPPFLAGS'
13099 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13100 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13101 cross_compiling=$ac_cv_prog_cc_cross
13102
13103
13104 fi
13105
13106   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13107   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13108     for ac_func in _ldexpf
13109 do
13110 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13111 echo "configure:13112: checking for $ac_func" >&5
13112 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13113   echo $ac_n "(cached) $ac_c" 1>&6
13114 else
13115   cat > conftest.$ac_ext <<EOF
13116 #line 13117 "configure"
13117 #include "confdefs.h"
13118 /* System header to define __stub macros and hopefully few prototypes,
13119     which can conflict with char $ac_func(); below.  */
13120 #include <assert.h>
13121 /* Override any gcc2 internal prototype to avoid an error.  */
13122 /* We use char because int might match the return type of a gcc2
13123     builtin and then its argument prototype would still apply.  */
13124 char $ac_func();
13125
13126 int main() {
13127
13128 /* The GNU C library defines this for functions which it implements
13129     to always fail with ENOSYS.  Some functions are actually named
13130     something starting with __ and the normal name is an alias.  */
13131 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13132 choke me
13133 #else
13134 $ac_func();
13135 #endif
13136
13137 ; return 0; }
13138 EOF
13139 if { (eval echo configure:13140: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13140   rm -rf conftest*
13141   eval "ac_cv_func_$ac_func=yes"
13142 else
13143   echo "configure: failed program was:" >&5
13144   cat conftest.$ac_ext >&5
13145   rm -rf conftest*
13146   eval "ac_cv_func_$ac_func=no"
13147 fi
13148 rm -f conftest*
13149 fi
13150
13151 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13152   echo "$ac_t""yes" 1>&6
13153     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13154   cat >> confdefs.h <<EOF
13155 #define $ac_tr_func 1
13156 EOF
13157
13158 else
13159   echo "$ac_t""no" 1>&6
13160 fi
13161 done
13162
13163   fi
13164
13165
13166   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
13167 echo "configure:13168: checking for _logf declaration" >&5
13168   if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
13169   echo $ac_n "(cached) $ac_c" 1>&6
13170 else
13171
13172
13173     ac_ext=C
13174 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13175 ac_cpp='$CXXCPP $CPPFLAGS'
13176 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13177 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13178 cross_compiling=$ac_cv_prog_cxx_cross
13179
13180     cat > conftest.$ac_ext <<EOF
13181 #line 13182 "configure"
13182 #include "confdefs.h"
13183 #include <math.h>
13184 int main() {
13185  _logf(0);
13186 ; return 0; }
13187 EOF
13188 if { (eval echo configure:13189: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13189   rm -rf conftest*
13190   glibcpp_cv_func__logf_use=yes
13191 else
13192   echo "configure: failed program was:" >&5
13193   cat conftest.$ac_ext >&5
13194   rm -rf conftest*
13195   glibcpp_cv_func__logf_use=no
13196 fi
13197 rm -f conftest*
13198     ac_ext=c
13199 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13200 ac_cpp='$CPP $CPPFLAGS'
13201 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13202 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13203 cross_compiling=$ac_cv_prog_cc_cross
13204
13205
13206 fi
13207
13208   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
13209   if test x$glibcpp_cv_func__logf_use = x"yes"; then
13210     for ac_func in _logf
13211 do
13212 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13213 echo "configure:13214: checking for $ac_func" >&5
13214 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13215   echo $ac_n "(cached) $ac_c" 1>&6
13216 else
13217   cat > conftest.$ac_ext <<EOF
13218 #line 13219 "configure"
13219 #include "confdefs.h"
13220 /* System header to define __stub macros and hopefully few prototypes,
13221     which can conflict with char $ac_func(); below.  */
13222 #include <assert.h>
13223 /* Override any gcc2 internal prototype to avoid an error.  */
13224 /* We use char because int might match the return type of a gcc2
13225     builtin and then its argument prototype would still apply.  */
13226 char $ac_func();
13227
13228 int main() {
13229
13230 /* The GNU C library defines this for functions which it implements
13231     to always fail with ENOSYS.  Some functions are actually named
13232     something starting with __ and the normal name is an alias.  */
13233 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13234 choke me
13235 #else
13236 $ac_func();
13237 #endif
13238
13239 ; return 0; }
13240 EOF
13241 if { (eval echo configure:13242: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13242   rm -rf conftest*
13243   eval "ac_cv_func_$ac_func=yes"
13244 else
13245   echo "configure: failed program was:" >&5
13246   cat conftest.$ac_ext >&5
13247   rm -rf conftest*
13248   eval "ac_cv_func_$ac_func=no"
13249 fi
13250 rm -f conftest*
13251 fi
13252
13253 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13254   echo "$ac_t""yes" 1>&6
13255     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13256   cat >> confdefs.h <<EOF
13257 #define $ac_tr_func 1
13258 EOF
13259
13260 else
13261   echo "$ac_t""no" 1>&6
13262 fi
13263 done
13264
13265   fi
13266
13267
13268   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
13269 echo "configure:13270: checking for _log10f declaration" >&5
13270   if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
13271   echo $ac_n "(cached) $ac_c" 1>&6
13272 else
13273
13274
13275     ac_ext=C
13276 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13277 ac_cpp='$CXXCPP $CPPFLAGS'
13278 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13279 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13280 cross_compiling=$ac_cv_prog_cxx_cross
13281
13282     cat > conftest.$ac_ext <<EOF
13283 #line 13284 "configure"
13284 #include "confdefs.h"
13285 #include <math.h>
13286 int main() {
13287  _log10f(0);
13288 ; return 0; }
13289 EOF
13290 if { (eval echo configure:13291: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13291   rm -rf conftest*
13292   glibcpp_cv_func__log10f_use=yes
13293 else
13294   echo "configure: failed program was:" >&5
13295   cat conftest.$ac_ext >&5
13296   rm -rf conftest*
13297   glibcpp_cv_func__log10f_use=no
13298 fi
13299 rm -f conftest*
13300     ac_ext=c
13301 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13302 ac_cpp='$CPP $CPPFLAGS'
13303 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13304 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13305 cross_compiling=$ac_cv_prog_cc_cross
13306
13307
13308 fi
13309
13310   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
13311   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
13312     for ac_func in _log10f
13313 do
13314 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13315 echo "configure:13316: checking for $ac_func" >&5
13316 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13317   echo $ac_n "(cached) $ac_c" 1>&6
13318 else
13319   cat > conftest.$ac_ext <<EOF
13320 #line 13321 "configure"
13321 #include "confdefs.h"
13322 /* System header to define __stub macros and hopefully few prototypes,
13323     which can conflict with char $ac_func(); below.  */
13324 #include <assert.h>
13325 /* Override any gcc2 internal prototype to avoid an error.  */
13326 /* We use char because int might match the return type of a gcc2
13327     builtin and then its argument prototype would still apply.  */
13328 char $ac_func();
13329
13330 int main() {
13331
13332 /* The GNU C library defines this for functions which it implements
13333     to always fail with ENOSYS.  Some functions are actually named
13334     something starting with __ and the normal name is an alias.  */
13335 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13336 choke me
13337 #else
13338 $ac_func();
13339 #endif
13340
13341 ; return 0; }
13342 EOF
13343 if { (eval echo configure:13344: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13344   rm -rf conftest*
13345   eval "ac_cv_func_$ac_func=yes"
13346 else
13347   echo "configure: failed program was:" >&5
13348   cat conftest.$ac_ext >&5
13349   rm -rf conftest*
13350   eval "ac_cv_func_$ac_func=no"
13351 fi
13352 rm -f conftest*
13353 fi
13354
13355 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13356   echo "$ac_t""yes" 1>&6
13357     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13358   cat >> confdefs.h <<EOF
13359 #define $ac_tr_func 1
13360 EOF
13361
13362 else
13363   echo "$ac_t""no" 1>&6
13364 fi
13365 done
13366
13367   fi
13368
13369
13370   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
13371 echo "configure:13372: checking for _modff declaration" >&5
13372   if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
13373   echo $ac_n "(cached) $ac_c" 1>&6
13374 else
13375
13376
13377     ac_ext=C
13378 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13379 ac_cpp='$CXXCPP $CPPFLAGS'
13380 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13381 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13382 cross_compiling=$ac_cv_prog_cxx_cross
13383
13384     cat > conftest.$ac_ext <<EOF
13385 #line 13386 "configure"
13386 #include "confdefs.h"
13387 #include <math.h>
13388 int main() {
13389  _modff(0, 0);
13390 ; return 0; }
13391 EOF
13392 if { (eval echo configure:13393: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13393   rm -rf conftest*
13394   glibcpp_cv_func__modff_use=yes
13395 else
13396   echo "configure: failed program was:" >&5
13397   cat conftest.$ac_ext >&5
13398   rm -rf conftest*
13399   glibcpp_cv_func__modff_use=no
13400 fi
13401 rm -f conftest*
13402     ac_ext=c
13403 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13404 ac_cpp='$CPP $CPPFLAGS'
13405 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13406 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13407 cross_compiling=$ac_cv_prog_cc_cross
13408
13409
13410 fi
13411
13412   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
13413   if test x$glibcpp_cv_func__modff_use = x"yes"; then
13414     for ac_func in _modff
13415 do
13416 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13417 echo "configure:13418: checking for $ac_func" >&5
13418 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13419   echo $ac_n "(cached) $ac_c" 1>&6
13420 else
13421   cat > conftest.$ac_ext <<EOF
13422 #line 13423 "configure"
13423 #include "confdefs.h"
13424 /* System header to define __stub macros and hopefully few prototypes,
13425     which can conflict with char $ac_func(); below.  */
13426 #include <assert.h>
13427 /* Override any gcc2 internal prototype to avoid an error.  */
13428 /* We use char because int might match the return type of a gcc2
13429     builtin and then its argument prototype would still apply.  */
13430 char $ac_func();
13431
13432 int main() {
13433
13434 /* The GNU C library defines this for functions which it implements
13435     to always fail with ENOSYS.  Some functions are actually named
13436     something starting with __ and the normal name is an alias.  */
13437 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13438 choke me
13439 #else
13440 $ac_func();
13441 #endif
13442
13443 ; return 0; }
13444 EOF
13445 if { (eval echo configure:13446: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13446   rm -rf conftest*
13447   eval "ac_cv_func_$ac_func=yes"
13448 else
13449   echo "configure: failed program was:" >&5
13450   cat conftest.$ac_ext >&5
13451   rm -rf conftest*
13452   eval "ac_cv_func_$ac_func=no"
13453 fi
13454 rm -f conftest*
13455 fi
13456
13457 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13458   echo "$ac_t""yes" 1>&6
13459     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13460   cat >> confdefs.h <<EOF
13461 #define $ac_tr_func 1
13462 EOF
13463
13464 else
13465   echo "$ac_t""no" 1>&6
13466 fi
13467 done
13468
13469   fi
13470
13471
13472   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
13473 echo "configure:13474: checking for _powf declaration" >&5
13474   if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
13475   echo $ac_n "(cached) $ac_c" 1>&6
13476 else
13477
13478
13479     ac_ext=C
13480 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13481 ac_cpp='$CXXCPP $CPPFLAGS'
13482 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13483 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13484 cross_compiling=$ac_cv_prog_cxx_cross
13485
13486     cat > conftest.$ac_ext <<EOF
13487 #line 13488 "configure"
13488 #include "confdefs.h"
13489 #include <math.h>
13490 int main() {
13491  _powf(0, 0);
13492 ; return 0; }
13493 EOF
13494 if { (eval echo configure:13495: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13495   rm -rf conftest*
13496   glibcpp_cv_func__powf_use=yes
13497 else
13498   echo "configure: failed program was:" >&5
13499   cat conftest.$ac_ext >&5
13500   rm -rf conftest*
13501   glibcpp_cv_func__powf_use=no
13502 fi
13503 rm -f conftest*
13504     ac_ext=c
13505 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13506 ac_cpp='$CPP $CPPFLAGS'
13507 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13508 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13509 cross_compiling=$ac_cv_prog_cc_cross
13510
13511
13512 fi
13513
13514   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
13515   if test x$glibcpp_cv_func__powf_use = x"yes"; then
13516     for ac_func in _powf
13517 do
13518 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13519 echo "configure:13520: checking for $ac_func" >&5
13520 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13521   echo $ac_n "(cached) $ac_c" 1>&6
13522 else
13523   cat > conftest.$ac_ext <<EOF
13524 #line 13525 "configure"
13525 #include "confdefs.h"
13526 /* System header to define __stub macros and hopefully few prototypes,
13527     which can conflict with char $ac_func(); below.  */
13528 #include <assert.h>
13529 /* Override any gcc2 internal prototype to avoid an error.  */
13530 /* We use char because int might match the return type of a gcc2
13531     builtin and then its argument prototype would still apply.  */
13532 char $ac_func();
13533
13534 int main() {
13535
13536 /* The GNU C library defines this for functions which it implements
13537     to always fail with ENOSYS.  Some functions are actually named
13538     something starting with __ and the normal name is an alias.  */
13539 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13540 choke me
13541 #else
13542 $ac_func();
13543 #endif
13544
13545 ; return 0; }
13546 EOF
13547 if { (eval echo configure:13548: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13548   rm -rf conftest*
13549   eval "ac_cv_func_$ac_func=yes"
13550 else
13551   echo "configure: failed program was:" >&5
13552   cat conftest.$ac_ext >&5
13553   rm -rf conftest*
13554   eval "ac_cv_func_$ac_func=no"
13555 fi
13556 rm -f conftest*
13557 fi
13558
13559 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13560   echo "$ac_t""yes" 1>&6
13561     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13562   cat >> confdefs.h <<EOF
13563 #define $ac_tr_func 1
13564 EOF
13565
13566 else
13567   echo "$ac_t""no" 1>&6
13568 fi
13569 done
13570
13571   fi
13572
13573
13574   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
13575 echo "configure:13576: checking for _sinf declaration" >&5
13576   if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
13577   echo $ac_n "(cached) $ac_c" 1>&6
13578 else
13579
13580
13581     ac_ext=C
13582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13583 ac_cpp='$CXXCPP $CPPFLAGS'
13584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13586 cross_compiling=$ac_cv_prog_cxx_cross
13587
13588     cat > conftest.$ac_ext <<EOF
13589 #line 13590 "configure"
13590 #include "confdefs.h"
13591 #include <math.h>
13592 int main() {
13593  _sinf(0);
13594 ; return 0; }
13595 EOF
13596 if { (eval echo configure:13597: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13597   rm -rf conftest*
13598   glibcpp_cv_func__sinf_use=yes
13599 else
13600   echo "configure: failed program was:" >&5
13601   cat conftest.$ac_ext >&5
13602   rm -rf conftest*
13603   glibcpp_cv_func__sinf_use=no
13604 fi
13605 rm -f conftest*
13606     ac_ext=c
13607 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13608 ac_cpp='$CPP $CPPFLAGS'
13609 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13610 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13611 cross_compiling=$ac_cv_prog_cc_cross
13612
13613
13614 fi
13615
13616   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
13617   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
13618     for ac_func in _sinf
13619 do
13620 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13621 echo "configure:13622: checking for $ac_func" >&5
13622 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13623   echo $ac_n "(cached) $ac_c" 1>&6
13624 else
13625   cat > conftest.$ac_ext <<EOF
13626 #line 13627 "configure"
13627 #include "confdefs.h"
13628 /* System header to define __stub macros and hopefully few prototypes,
13629     which can conflict with char $ac_func(); below.  */
13630 #include <assert.h>
13631 /* Override any gcc2 internal prototype to avoid an error.  */
13632 /* We use char because int might match the return type of a gcc2
13633     builtin and then its argument prototype would still apply.  */
13634 char $ac_func();
13635
13636 int main() {
13637
13638 /* The GNU C library defines this for functions which it implements
13639     to always fail with ENOSYS.  Some functions are actually named
13640     something starting with __ and the normal name is an alias.  */
13641 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13642 choke me
13643 #else
13644 $ac_func();
13645 #endif
13646
13647 ; return 0; }
13648 EOF
13649 if { (eval echo configure:13650: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13650   rm -rf conftest*
13651   eval "ac_cv_func_$ac_func=yes"
13652 else
13653   echo "configure: failed program was:" >&5
13654   cat conftest.$ac_ext >&5
13655   rm -rf conftest*
13656   eval "ac_cv_func_$ac_func=no"
13657 fi
13658 rm -f conftest*
13659 fi
13660
13661 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13662   echo "$ac_t""yes" 1>&6
13663     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13664   cat >> confdefs.h <<EOF
13665 #define $ac_tr_func 1
13666 EOF
13667
13668 else
13669   echo "$ac_t""no" 1>&6
13670 fi
13671 done
13672
13673   fi
13674
13675
13676   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
13677 echo "configure:13678: checking for _sinhf declaration" >&5
13678   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
13679   echo $ac_n "(cached) $ac_c" 1>&6
13680 else
13681
13682
13683     ac_ext=C
13684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13685 ac_cpp='$CXXCPP $CPPFLAGS'
13686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13688 cross_compiling=$ac_cv_prog_cxx_cross
13689
13690     cat > conftest.$ac_ext <<EOF
13691 #line 13692 "configure"
13692 #include "confdefs.h"
13693 #include <math.h>
13694 int main() {
13695  _sinhf(0);
13696 ; return 0; }
13697 EOF
13698 if { (eval echo configure:13699: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13699   rm -rf conftest*
13700   glibcpp_cv_func__sinhf_use=yes
13701 else
13702   echo "configure: failed program was:" >&5
13703   cat conftest.$ac_ext >&5
13704   rm -rf conftest*
13705   glibcpp_cv_func__sinhf_use=no
13706 fi
13707 rm -f conftest*
13708     ac_ext=c
13709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13710 ac_cpp='$CPP $CPPFLAGS'
13711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13713 cross_compiling=$ac_cv_prog_cc_cross
13714
13715
13716 fi
13717
13718   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
13719   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
13720     for ac_func in _sinhf
13721 do
13722 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13723 echo "configure:13724: checking for $ac_func" >&5
13724 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13725   echo $ac_n "(cached) $ac_c" 1>&6
13726 else
13727   cat > conftest.$ac_ext <<EOF
13728 #line 13729 "configure"
13729 #include "confdefs.h"
13730 /* System header to define __stub macros and hopefully few prototypes,
13731     which can conflict with char $ac_func(); below.  */
13732 #include <assert.h>
13733 /* Override any gcc2 internal prototype to avoid an error.  */
13734 /* We use char because int might match the return type of a gcc2
13735     builtin and then its argument prototype would still apply.  */
13736 char $ac_func();
13737
13738 int main() {
13739
13740 /* The GNU C library defines this for functions which it implements
13741     to always fail with ENOSYS.  Some functions are actually named
13742     something starting with __ and the normal name is an alias.  */
13743 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13744 choke me
13745 #else
13746 $ac_func();
13747 #endif
13748
13749 ; return 0; }
13750 EOF
13751 if { (eval echo configure:13752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13752   rm -rf conftest*
13753   eval "ac_cv_func_$ac_func=yes"
13754 else
13755   echo "configure: failed program was:" >&5
13756   cat conftest.$ac_ext >&5
13757   rm -rf conftest*
13758   eval "ac_cv_func_$ac_func=no"
13759 fi
13760 rm -f conftest*
13761 fi
13762
13763 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13764   echo "$ac_t""yes" 1>&6
13765     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13766   cat >> confdefs.h <<EOF
13767 #define $ac_tr_func 1
13768 EOF
13769
13770 else
13771   echo "$ac_t""no" 1>&6
13772 fi
13773 done
13774
13775   fi
13776
13777
13778   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
13779 echo "configure:13780: checking for _sqrtf declaration" >&5
13780   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
13781   echo $ac_n "(cached) $ac_c" 1>&6
13782 else
13783
13784
13785     ac_ext=C
13786 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13787 ac_cpp='$CXXCPP $CPPFLAGS'
13788 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13789 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13790 cross_compiling=$ac_cv_prog_cxx_cross
13791
13792     cat > conftest.$ac_ext <<EOF
13793 #line 13794 "configure"
13794 #include "confdefs.h"
13795 #include <math.h>
13796 int main() {
13797  _sqrtf(0);
13798 ; return 0; }
13799 EOF
13800 if { (eval echo configure:13801: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13801   rm -rf conftest*
13802   glibcpp_cv_func__sqrtf_use=yes
13803 else
13804   echo "configure: failed program was:" >&5
13805   cat conftest.$ac_ext >&5
13806   rm -rf conftest*
13807   glibcpp_cv_func__sqrtf_use=no
13808 fi
13809 rm -f conftest*
13810     ac_ext=c
13811 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13812 ac_cpp='$CPP $CPPFLAGS'
13813 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13814 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13815 cross_compiling=$ac_cv_prog_cc_cross
13816
13817
13818 fi
13819
13820   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
13821   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
13822     for ac_func in _sqrtf
13823 do
13824 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13825 echo "configure:13826: checking for $ac_func" >&5
13826 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13827   echo $ac_n "(cached) $ac_c" 1>&6
13828 else
13829   cat > conftest.$ac_ext <<EOF
13830 #line 13831 "configure"
13831 #include "confdefs.h"
13832 /* System header to define __stub macros and hopefully few prototypes,
13833     which can conflict with char $ac_func(); below.  */
13834 #include <assert.h>
13835 /* Override any gcc2 internal prototype to avoid an error.  */
13836 /* We use char because int might match the return type of a gcc2
13837     builtin and then its argument prototype would still apply.  */
13838 char $ac_func();
13839
13840 int main() {
13841
13842 /* The GNU C library defines this for functions which it implements
13843     to always fail with ENOSYS.  Some functions are actually named
13844     something starting with __ and the normal name is an alias.  */
13845 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13846 choke me
13847 #else
13848 $ac_func();
13849 #endif
13850
13851 ; return 0; }
13852 EOF
13853 if { (eval echo configure:13854: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13854   rm -rf conftest*
13855   eval "ac_cv_func_$ac_func=yes"
13856 else
13857   echo "configure: failed program was:" >&5
13858   cat conftest.$ac_ext >&5
13859   rm -rf conftest*
13860   eval "ac_cv_func_$ac_func=no"
13861 fi
13862 rm -f conftest*
13863 fi
13864
13865 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13866   echo "$ac_t""yes" 1>&6
13867     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13868   cat >> confdefs.h <<EOF
13869 #define $ac_tr_func 1
13870 EOF
13871
13872 else
13873   echo "$ac_t""no" 1>&6
13874 fi
13875 done
13876
13877   fi
13878
13879
13880   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
13881 echo "configure:13882: checking for _tanf declaration" >&5
13882   if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
13883   echo $ac_n "(cached) $ac_c" 1>&6
13884 else
13885
13886
13887     ac_ext=C
13888 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13889 ac_cpp='$CXXCPP $CPPFLAGS'
13890 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13891 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13892 cross_compiling=$ac_cv_prog_cxx_cross
13893
13894     cat > conftest.$ac_ext <<EOF
13895 #line 13896 "configure"
13896 #include "confdefs.h"
13897 #include <math.h>
13898 int main() {
13899  _tanf(0);
13900 ; return 0; }
13901 EOF
13902 if { (eval echo configure:13903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13903   rm -rf conftest*
13904   glibcpp_cv_func__tanf_use=yes
13905 else
13906   echo "configure: failed program was:" >&5
13907   cat conftest.$ac_ext >&5
13908   rm -rf conftest*
13909   glibcpp_cv_func__tanf_use=no
13910 fi
13911 rm -f conftest*
13912     ac_ext=c
13913 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13914 ac_cpp='$CPP $CPPFLAGS'
13915 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13916 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13917 cross_compiling=$ac_cv_prog_cc_cross
13918
13919
13920 fi
13921
13922   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
13923   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
13924     for ac_func in _tanf
13925 do
13926 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13927 echo "configure:13928: checking for $ac_func" >&5
13928 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13929   echo $ac_n "(cached) $ac_c" 1>&6
13930 else
13931   cat > conftest.$ac_ext <<EOF
13932 #line 13933 "configure"
13933 #include "confdefs.h"
13934 /* System header to define __stub macros and hopefully few prototypes,
13935     which can conflict with char $ac_func(); below.  */
13936 #include <assert.h>
13937 /* Override any gcc2 internal prototype to avoid an error.  */
13938 /* We use char because int might match the return type of a gcc2
13939     builtin and then its argument prototype would still apply.  */
13940 char $ac_func();
13941
13942 int main() {
13943
13944 /* The GNU C library defines this for functions which it implements
13945     to always fail with ENOSYS.  Some functions are actually named
13946     something starting with __ and the normal name is an alias.  */
13947 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13948 choke me
13949 #else
13950 $ac_func();
13951 #endif
13952
13953 ; return 0; }
13954 EOF
13955 if { (eval echo configure:13956: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13956   rm -rf conftest*
13957   eval "ac_cv_func_$ac_func=yes"
13958 else
13959   echo "configure: failed program was:" >&5
13960   cat conftest.$ac_ext >&5
13961   rm -rf conftest*
13962   eval "ac_cv_func_$ac_func=no"
13963 fi
13964 rm -f conftest*
13965 fi
13966
13967 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13968   echo "$ac_t""yes" 1>&6
13969     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13970   cat >> confdefs.h <<EOF
13971 #define $ac_tr_func 1
13972 EOF
13973
13974 else
13975   echo "$ac_t""no" 1>&6
13976 fi
13977 done
13978
13979   fi
13980
13981
13982   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
13983 echo "configure:13984: checking for _tanhf declaration" >&5
13984   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
13985   echo $ac_n "(cached) $ac_c" 1>&6
13986 else
13987
13988
13989     ac_ext=C
13990 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13991 ac_cpp='$CXXCPP $CPPFLAGS'
13992 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13993 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13994 cross_compiling=$ac_cv_prog_cxx_cross
13995
13996     cat > conftest.$ac_ext <<EOF
13997 #line 13998 "configure"
13998 #include "confdefs.h"
13999 #include <math.h>
14000 int main() {
14001  _tanhf(0);
14002 ; return 0; }
14003 EOF
14004 if { (eval echo configure:14005: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14005   rm -rf conftest*
14006   glibcpp_cv_func__tanhf_use=yes
14007 else
14008   echo "configure: failed program was:" >&5
14009   cat conftest.$ac_ext >&5
14010   rm -rf conftest*
14011   glibcpp_cv_func__tanhf_use=no
14012 fi
14013 rm -f conftest*
14014     ac_ext=c
14015 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14016 ac_cpp='$CPP $CPPFLAGS'
14017 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14018 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14019 cross_compiling=$ac_cv_prog_cc_cross
14020
14021
14022 fi
14023
14024   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
14025   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
14026     for ac_func in _tanhf
14027 do
14028 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14029 echo "configure:14030: checking for $ac_func" >&5
14030 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14031   echo $ac_n "(cached) $ac_c" 1>&6
14032 else
14033   cat > conftest.$ac_ext <<EOF
14034 #line 14035 "configure"
14035 #include "confdefs.h"
14036 /* System header to define __stub macros and hopefully few prototypes,
14037     which can conflict with char $ac_func(); below.  */
14038 #include <assert.h>
14039 /* Override any gcc2 internal prototype to avoid an error.  */
14040 /* We use char because int might match the return type of a gcc2
14041     builtin and then its argument prototype would still apply.  */
14042 char $ac_func();
14043
14044 int main() {
14045
14046 /* The GNU C library defines this for functions which it implements
14047     to always fail with ENOSYS.  Some functions are actually named
14048     something starting with __ and the normal name is an alias.  */
14049 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14050 choke me
14051 #else
14052 $ac_func();
14053 #endif
14054
14055 ; return 0; }
14056 EOF
14057 if { (eval echo configure:14058: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14058   rm -rf conftest*
14059   eval "ac_cv_func_$ac_func=yes"
14060 else
14061   echo "configure: failed program was:" >&5
14062   cat conftest.$ac_ext >&5
14063   rm -rf conftest*
14064   eval "ac_cv_func_$ac_func=no"
14065 fi
14066 rm -f conftest*
14067 fi
14068
14069 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14070   echo "$ac_t""yes" 1>&6
14071     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14072   cat >> confdefs.h <<EOF
14073 #define $ac_tr_func 1
14074 EOF
14075
14076 else
14077   echo "$ac_t""no" 1>&6
14078 fi
14079 done
14080
14081   fi
14082
14083
14084   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14085 echo "configure:14086: checking for _sincosf declaration" >&5
14086   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14087   echo $ac_n "(cached) $ac_c" 1>&6
14088 else
14089
14090
14091     ac_ext=C
14092 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14093 ac_cpp='$CXXCPP $CPPFLAGS'
14094 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14095 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14096 cross_compiling=$ac_cv_prog_cxx_cross
14097
14098     cat > conftest.$ac_ext <<EOF
14099 #line 14100 "configure"
14100 #include "confdefs.h"
14101 #include <math.h>
14102 int main() {
14103  _sincosf(0, 0, 0);
14104 ; return 0; }
14105 EOF
14106 if { (eval echo configure:14107: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14107   rm -rf conftest*
14108   glibcpp_cv_func__sincosf_use=yes
14109 else
14110   echo "configure: failed program was:" >&5
14111   cat conftest.$ac_ext >&5
14112   rm -rf conftest*
14113   glibcpp_cv_func__sincosf_use=no
14114 fi
14115 rm -f conftest*
14116     ac_ext=c
14117 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14118 ac_cpp='$CPP $CPPFLAGS'
14119 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14120 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14121 cross_compiling=$ac_cv_prog_cc_cross
14122
14123
14124 fi
14125
14126   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
14127   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
14128     for ac_func in _sincosf
14129 do
14130 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14131 echo "configure:14132: checking for $ac_func" >&5
14132 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14133   echo $ac_n "(cached) $ac_c" 1>&6
14134 else
14135   cat > conftest.$ac_ext <<EOF
14136 #line 14137 "configure"
14137 #include "confdefs.h"
14138 /* System header to define __stub macros and hopefully few prototypes,
14139     which can conflict with char $ac_func(); below.  */
14140 #include <assert.h>
14141 /* Override any gcc2 internal prototype to avoid an error.  */
14142 /* We use char because int might match the return type of a gcc2
14143     builtin and then its argument prototype would still apply.  */
14144 char $ac_func();
14145
14146 int main() {
14147
14148 /* The GNU C library defines this for functions which it implements
14149     to always fail with ENOSYS.  Some functions are actually named
14150     something starting with __ and the normal name is an alias.  */
14151 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14152 choke me
14153 #else
14154 $ac_func();
14155 #endif
14156
14157 ; return 0; }
14158 EOF
14159 if { (eval echo configure:14160: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14160   rm -rf conftest*
14161   eval "ac_cv_func_$ac_func=yes"
14162 else
14163   echo "configure: failed program was:" >&5
14164   cat conftest.$ac_ext >&5
14165   rm -rf conftest*
14166   eval "ac_cv_func_$ac_func=no"
14167 fi
14168 rm -f conftest*
14169 fi
14170
14171 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14172   echo "$ac_t""yes" 1>&6
14173     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14174   cat >> confdefs.h <<EOF
14175 #define $ac_tr_func 1
14176 EOF
14177
14178 else
14179   echo "$ac_t""no" 1>&6
14180 fi
14181 done
14182
14183   fi
14184
14185
14186   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
14187 echo "configure:14188: checking for _finitef declaration" >&5
14188   if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
14189   echo $ac_n "(cached) $ac_c" 1>&6
14190 else
14191
14192
14193     ac_ext=C
14194 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14195 ac_cpp='$CXXCPP $CPPFLAGS'
14196 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14197 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14198 cross_compiling=$ac_cv_prog_cxx_cross
14199
14200     cat > conftest.$ac_ext <<EOF
14201 #line 14202 "configure"
14202 #include "confdefs.h"
14203 #include <math.h>
14204 int main() {
14205  _finitef(0);
14206 ; return 0; }
14207 EOF
14208 if { (eval echo configure:14209: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14209   rm -rf conftest*
14210   glibcpp_cv_func__finitef_use=yes
14211 else
14212   echo "configure: failed program was:" >&5
14213   cat conftest.$ac_ext >&5
14214   rm -rf conftest*
14215   glibcpp_cv_func__finitef_use=no
14216 fi
14217 rm -f conftest*
14218     ac_ext=c
14219 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14220 ac_cpp='$CPP $CPPFLAGS'
14221 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14222 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14223 cross_compiling=$ac_cv_prog_cc_cross
14224
14225
14226 fi
14227
14228   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
14229   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
14230     for ac_func in _finitef
14231 do
14232 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14233 echo "configure:14234: checking for $ac_func" >&5
14234 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14235   echo $ac_n "(cached) $ac_c" 1>&6
14236 else
14237   cat > conftest.$ac_ext <<EOF
14238 #line 14239 "configure"
14239 #include "confdefs.h"
14240 /* System header to define __stub macros and hopefully few prototypes,
14241     which can conflict with char $ac_func(); below.  */
14242 #include <assert.h>
14243 /* Override any gcc2 internal prototype to avoid an error.  */
14244 /* We use char because int might match the return type of a gcc2
14245     builtin and then its argument prototype would still apply.  */
14246 char $ac_func();
14247
14248 int main() {
14249
14250 /* The GNU C library defines this for functions which it implements
14251     to always fail with ENOSYS.  Some functions are actually named
14252     something starting with __ and the normal name is an alias.  */
14253 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14254 choke me
14255 #else
14256 $ac_func();
14257 #endif
14258
14259 ; return 0; }
14260 EOF
14261 if { (eval echo configure:14262: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14262   rm -rf conftest*
14263   eval "ac_cv_func_$ac_func=yes"
14264 else
14265   echo "configure: failed program was:" >&5
14266   cat conftest.$ac_ext >&5
14267   rm -rf conftest*
14268   eval "ac_cv_func_$ac_func=no"
14269 fi
14270 rm -f conftest*
14271 fi
14272
14273 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14274   echo "$ac_t""yes" 1>&6
14275     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14276   cat >> confdefs.h <<EOF
14277 #define $ac_tr_func 1
14278 EOF
14279
14280 else
14281   echo "$ac_t""no" 1>&6
14282 fi
14283 done
14284
14285   fi
14286
14287
14288
14289   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
14290 echo "configure:14291: checking for _isnanl declaration" >&5
14291   if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
14292   echo $ac_n "(cached) $ac_c" 1>&6
14293 else
14294
14295
14296     ac_ext=C
14297 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14298 ac_cpp='$CXXCPP $CPPFLAGS'
14299 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14300 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14301 cross_compiling=$ac_cv_prog_cxx_cross
14302
14303     cat > conftest.$ac_ext <<EOF
14304 #line 14305 "configure"
14305 #include "confdefs.h"
14306 #include <math.h>
14307 int main() {
14308  _isnanl(0);
14309 ; return 0; }
14310 EOF
14311 if { (eval echo configure:14312: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14312   rm -rf conftest*
14313   glibcpp_cv_func__isnanl_use=yes
14314 else
14315   echo "configure: failed program was:" >&5
14316   cat conftest.$ac_ext >&5
14317   rm -rf conftest*
14318   glibcpp_cv_func__isnanl_use=no
14319 fi
14320 rm -f conftest*
14321     ac_ext=c
14322 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14323 ac_cpp='$CPP $CPPFLAGS'
14324 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14325 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14326 cross_compiling=$ac_cv_prog_cc_cross
14327
14328
14329 fi
14330
14331   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
14332   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
14333     for ac_func in _isnanl
14334 do
14335 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14336 echo "configure:14337: checking for $ac_func" >&5
14337 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14338   echo $ac_n "(cached) $ac_c" 1>&6
14339 else
14340   cat > conftest.$ac_ext <<EOF
14341 #line 14342 "configure"
14342 #include "confdefs.h"
14343 /* System header to define __stub macros and hopefully few prototypes,
14344     which can conflict with char $ac_func(); below.  */
14345 #include <assert.h>
14346 /* Override any gcc2 internal prototype to avoid an error.  */
14347 /* We use char because int might match the return type of a gcc2
14348     builtin and then its argument prototype would still apply.  */
14349 char $ac_func();
14350
14351 int main() {
14352
14353 /* The GNU C library defines this for functions which it implements
14354     to always fail with ENOSYS.  Some functions are actually named
14355     something starting with __ and the normal name is an alias.  */
14356 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14357 choke me
14358 #else
14359 $ac_func();
14360 #endif
14361
14362 ; return 0; }
14363 EOF
14364 if { (eval echo configure:14365: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14365   rm -rf conftest*
14366   eval "ac_cv_func_$ac_func=yes"
14367 else
14368   echo "configure: failed program was:" >&5
14369   cat conftest.$ac_ext >&5
14370   rm -rf conftest*
14371   eval "ac_cv_func_$ac_func=no"
14372 fi
14373 rm -f conftest*
14374 fi
14375
14376 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14377   echo "$ac_t""yes" 1>&6
14378     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14379   cat >> confdefs.h <<EOF
14380 #define $ac_tr_func 1
14381 EOF
14382
14383 else
14384   echo "$ac_t""no" 1>&6
14385 fi
14386 done
14387
14388   fi
14389
14390
14391   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
14392 echo "configure:14393: checking for _isinfl declaration" >&5
14393   if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
14394   echo $ac_n "(cached) $ac_c" 1>&6
14395 else
14396
14397
14398     ac_ext=C
14399 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14400 ac_cpp='$CXXCPP $CPPFLAGS'
14401 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14402 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14403 cross_compiling=$ac_cv_prog_cxx_cross
14404
14405     cat > conftest.$ac_ext <<EOF
14406 #line 14407 "configure"
14407 #include "confdefs.h"
14408 #include <math.h>
14409 int main() {
14410  _isinfl(0);
14411 ; return 0; }
14412 EOF
14413 if { (eval echo configure:14414: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14414   rm -rf conftest*
14415   glibcpp_cv_func__isinfl_use=yes
14416 else
14417   echo "configure: failed program was:" >&5
14418   cat conftest.$ac_ext >&5
14419   rm -rf conftest*
14420   glibcpp_cv_func__isinfl_use=no
14421 fi
14422 rm -f conftest*
14423     ac_ext=c
14424 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14425 ac_cpp='$CPP $CPPFLAGS'
14426 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14427 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14428 cross_compiling=$ac_cv_prog_cc_cross
14429
14430
14431 fi
14432
14433   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
14434   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
14435     for ac_func in _isinfl
14436 do
14437 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14438 echo "configure:14439: checking for $ac_func" >&5
14439 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14440   echo $ac_n "(cached) $ac_c" 1>&6
14441 else
14442   cat > conftest.$ac_ext <<EOF
14443 #line 14444 "configure"
14444 #include "confdefs.h"
14445 /* System header to define __stub macros and hopefully few prototypes,
14446     which can conflict with char $ac_func(); below.  */
14447 #include <assert.h>
14448 /* Override any gcc2 internal prototype to avoid an error.  */
14449 /* We use char because int might match the return type of a gcc2
14450     builtin and then its argument prototype would still apply.  */
14451 char $ac_func();
14452
14453 int main() {
14454
14455 /* The GNU C library defines this for functions which it implements
14456     to always fail with ENOSYS.  Some functions are actually named
14457     something starting with __ and the normal name is an alias.  */
14458 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14459 choke me
14460 #else
14461 $ac_func();
14462 #endif
14463
14464 ; return 0; }
14465 EOF
14466 if { (eval echo configure:14467: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14467   rm -rf conftest*
14468   eval "ac_cv_func_$ac_func=yes"
14469 else
14470   echo "configure: failed program was:" >&5
14471   cat conftest.$ac_ext >&5
14472   rm -rf conftest*
14473   eval "ac_cv_func_$ac_func=no"
14474 fi
14475 rm -f conftest*
14476 fi
14477
14478 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14479   echo "$ac_t""yes" 1>&6
14480     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14481   cat >> confdefs.h <<EOF
14482 #define $ac_tr_func 1
14483 EOF
14484
14485 else
14486   echo "$ac_t""no" 1>&6
14487 fi
14488 done
14489
14490   fi
14491
14492
14493   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
14494 echo "configure:14495: checking for _copysignl declaration" >&5
14495   if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
14496   echo $ac_n "(cached) $ac_c" 1>&6
14497 else
14498
14499
14500     ac_ext=C
14501 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14502 ac_cpp='$CXXCPP $CPPFLAGS'
14503 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14504 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14505 cross_compiling=$ac_cv_prog_cxx_cross
14506
14507     cat > conftest.$ac_ext <<EOF
14508 #line 14509 "configure"
14509 #include "confdefs.h"
14510 #include <math.h>
14511 int main() {
14512  _copysignl(0, 0);
14513 ; return 0; }
14514 EOF
14515 if { (eval echo configure:14516: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14516   rm -rf conftest*
14517   glibcpp_cv_func__copysignl_use=yes
14518 else
14519   echo "configure: failed program was:" >&5
14520   cat conftest.$ac_ext >&5
14521   rm -rf conftest*
14522   glibcpp_cv_func__copysignl_use=no
14523 fi
14524 rm -f conftest*
14525     ac_ext=c
14526 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14527 ac_cpp='$CPP $CPPFLAGS'
14528 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14529 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14530 cross_compiling=$ac_cv_prog_cc_cross
14531
14532
14533 fi
14534
14535   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
14536   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
14537     for ac_func in _copysignl
14538 do
14539 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14540 echo "configure:14541: checking for $ac_func" >&5
14541 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14542   echo $ac_n "(cached) $ac_c" 1>&6
14543 else
14544   cat > conftest.$ac_ext <<EOF
14545 #line 14546 "configure"
14546 #include "confdefs.h"
14547 /* System header to define __stub macros and hopefully few prototypes,
14548     which can conflict with char $ac_func(); below.  */
14549 #include <assert.h>
14550 /* Override any gcc2 internal prototype to avoid an error.  */
14551 /* We use char because int might match the return type of a gcc2
14552     builtin and then its argument prototype would still apply.  */
14553 char $ac_func();
14554
14555 int main() {
14556
14557 /* The GNU C library defines this for functions which it implements
14558     to always fail with ENOSYS.  Some functions are actually named
14559     something starting with __ and the normal name is an alias.  */
14560 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14561 choke me
14562 #else
14563 $ac_func();
14564 #endif
14565
14566 ; return 0; }
14567 EOF
14568 if { (eval echo configure:14569: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14569   rm -rf conftest*
14570   eval "ac_cv_func_$ac_func=yes"
14571 else
14572   echo "configure: failed program was:" >&5
14573   cat conftest.$ac_ext >&5
14574   rm -rf conftest*
14575   eval "ac_cv_func_$ac_func=no"
14576 fi
14577 rm -f conftest*
14578 fi
14579
14580 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14581   echo "$ac_t""yes" 1>&6
14582     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14583   cat >> confdefs.h <<EOF
14584 #define $ac_tr_func 1
14585 EOF
14586
14587 else
14588   echo "$ac_t""no" 1>&6
14589 fi
14590 done
14591
14592   fi
14593
14594
14595   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
14596 echo "configure:14597: checking for _acosl declaration" >&5
14597   if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
14598   echo $ac_n "(cached) $ac_c" 1>&6
14599 else
14600
14601
14602     ac_ext=C
14603 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14604 ac_cpp='$CXXCPP $CPPFLAGS'
14605 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14606 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14607 cross_compiling=$ac_cv_prog_cxx_cross
14608
14609     cat > conftest.$ac_ext <<EOF
14610 #line 14611 "configure"
14611 #include "confdefs.h"
14612 #include <math.h>
14613 int main() {
14614  _acosl(0);
14615 ; return 0; }
14616 EOF
14617 if { (eval echo configure:14618: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14618   rm -rf conftest*
14619   glibcpp_cv_func__acosl_use=yes
14620 else
14621   echo "configure: failed program was:" >&5
14622   cat conftest.$ac_ext >&5
14623   rm -rf conftest*
14624   glibcpp_cv_func__acosl_use=no
14625 fi
14626 rm -f conftest*
14627     ac_ext=c
14628 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14629 ac_cpp='$CPP $CPPFLAGS'
14630 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14631 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14632 cross_compiling=$ac_cv_prog_cc_cross
14633
14634
14635 fi
14636
14637   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
14638   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
14639     for ac_func in _acosl
14640 do
14641 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14642 echo "configure:14643: checking for $ac_func" >&5
14643 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14644   echo $ac_n "(cached) $ac_c" 1>&6
14645 else
14646   cat > conftest.$ac_ext <<EOF
14647 #line 14648 "configure"
14648 #include "confdefs.h"
14649 /* System header to define __stub macros and hopefully few prototypes,
14650     which can conflict with char $ac_func(); below.  */
14651 #include <assert.h>
14652 /* Override any gcc2 internal prototype to avoid an error.  */
14653 /* We use char because int might match the return type of a gcc2
14654     builtin and then its argument prototype would still apply.  */
14655 char $ac_func();
14656
14657 int main() {
14658
14659 /* The GNU C library defines this for functions which it implements
14660     to always fail with ENOSYS.  Some functions are actually named
14661     something starting with __ and the normal name is an alias.  */
14662 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14663 choke me
14664 #else
14665 $ac_func();
14666 #endif
14667
14668 ; return 0; }
14669 EOF
14670 if { (eval echo configure:14671: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14671   rm -rf conftest*
14672   eval "ac_cv_func_$ac_func=yes"
14673 else
14674   echo "configure: failed program was:" >&5
14675   cat conftest.$ac_ext >&5
14676   rm -rf conftest*
14677   eval "ac_cv_func_$ac_func=no"
14678 fi
14679 rm -f conftest*
14680 fi
14681
14682 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14683   echo "$ac_t""yes" 1>&6
14684     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14685   cat >> confdefs.h <<EOF
14686 #define $ac_tr_func 1
14687 EOF
14688
14689 else
14690   echo "$ac_t""no" 1>&6
14691 fi
14692 done
14693
14694   fi
14695
14696
14697   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
14698 echo "configure:14699: checking for _asinl declaration" >&5
14699   if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
14700   echo $ac_n "(cached) $ac_c" 1>&6
14701 else
14702
14703
14704     ac_ext=C
14705 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14706 ac_cpp='$CXXCPP $CPPFLAGS'
14707 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14708 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14709 cross_compiling=$ac_cv_prog_cxx_cross
14710
14711     cat > conftest.$ac_ext <<EOF
14712 #line 14713 "configure"
14713 #include "confdefs.h"
14714 #include <math.h>
14715 int main() {
14716  _asinl(0);
14717 ; return 0; }
14718 EOF
14719 if { (eval echo configure:14720: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14720   rm -rf conftest*
14721   glibcpp_cv_func__asinl_use=yes
14722 else
14723   echo "configure: failed program was:" >&5
14724   cat conftest.$ac_ext >&5
14725   rm -rf conftest*
14726   glibcpp_cv_func__asinl_use=no
14727 fi
14728 rm -f conftest*
14729     ac_ext=c
14730 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14731 ac_cpp='$CPP $CPPFLAGS'
14732 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14733 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14734 cross_compiling=$ac_cv_prog_cc_cross
14735
14736
14737 fi
14738
14739   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
14740   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
14741     for ac_func in _asinl
14742 do
14743 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14744 echo "configure:14745: checking for $ac_func" >&5
14745 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14746   echo $ac_n "(cached) $ac_c" 1>&6
14747 else
14748   cat > conftest.$ac_ext <<EOF
14749 #line 14750 "configure"
14750 #include "confdefs.h"
14751 /* System header to define __stub macros and hopefully few prototypes,
14752     which can conflict with char $ac_func(); below.  */
14753 #include <assert.h>
14754 /* Override any gcc2 internal prototype to avoid an error.  */
14755 /* We use char because int might match the return type of a gcc2
14756     builtin and then its argument prototype would still apply.  */
14757 char $ac_func();
14758
14759 int main() {
14760
14761 /* The GNU C library defines this for functions which it implements
14762     to always fail with ENOSYS.  Some functions are actually named
14763     something starting with __ and the normal name is an alias.  */
14764 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14765 choke me
14766 #else
14767 $ac_func();
14768 #endif
14769
14770 ; return 0; }
14771 EOF
14772 if { (eval echo configure:14773: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14773   rm -rf conftest*
14774   eval "ac_cv_func_$ac_func=yes"
14775 else
14776   echo "configure: failed program was:" >&5
14777   cat conftest.$ac_ext >&5
14778   rm -rf conftest*
14779   eval "ac_cv_func_$ac_func=no"
14780 fi
14781 rm -f conftest*
14782 fi
14783
14784 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14785   echo "$ac_t""yes" 1>&6
14786     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14787   cat >> confdefs.h <<EOF
14788 #define $ac_tr_func 1
14789 EOF
14790
14791 else
14792   echo "$ac_t""no" 1>&6
14793 fi
14794 done
14795
14796   fi
14797
14798
14799   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
14800 echo "configure:14801: checking for _atanl declaration" >&5
14801   if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
14802   echo $ac_n "(cached) $ac_c" 1>&6
14803 else
14804
14805
14806     ac_ext=C
14807 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14808 ac_cpp='$CXXCPP $CPPFLAGS'
14809 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14810 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14811 cross_compiling=$ac_cv_prog_cxx_cross
14812
14813     cat > conftest.$ac_ext <<EOF
14814 #line 14815 "configure"
14815 #include "confdefs.h"
14816 #include <math.h>
14817 int main() {
14818  _atanl(0);
14819 ; return 0; }
14820 EOF
14821 if { (eval echo configure:14822: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14822   rm -rf conftest*
14823   glibcpp_cv_func__atanl_use=yes
14824 else
14825   echo "configure: failed program was:" >&5
14826   cat conftest.$ac_ext >&5
14827   rm -rf conftest*
14828   glibcpp_cv_func__atanl_use=no
14829 fi
14830 rm -f conftest*
14831     ac_ext=c
14832 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14833 ac_cpp='$CPP $CPPFLAGS'
14834 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14835 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14836 cross_compiling=$ac_cv_prog_cc_cross
14837
14838
14839 fi
14840
14841   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
14842   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
14843     for ac_func in _atanl
14844 do
14845 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14846 echo "configure:14847: checking for $ac_func" >&5
14847 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14848   echo $ac_n "(cached) $ac_c" 1>&6
14849 else
14850   cat > conftest.$ac_ext <<EOF
14851 #line 14852 "configure"
14852 #include "confdefs.h"
14853 /* System header to define __stub macros and hopefully few prototypes,
14854     which can conflict with char $ac_func(); below.  */
14855 #include <assert.h>
14856 /* Override any gcc2 internal prototype to avoid an error.  */
14857 /* We use char because int might match the return type of a gcc2
14858     builtin and then its argument prototype would still apply.  */
14859 char $ac_func();
14860
14861 int main() {
14862
14863 /* The GNU C library defines this for functions which it implements
14864     to always fail with ENOSYS.  Some functions are actually named
14865     something starting with __ and the normal name is an alias.  */
14866 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14867 choke me
14868 #else
14869 $ac_func();
14870 #endif
14871
14872 ; return 0; }
14873 EOF
14874 if { (eval echo configure:14875: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14875   rm -rf conftest*
14876   eval "ac_cv_func_$ac_func=yes"
14877 else
14878   echo "configure: failed program was:" >&5
14879   cat conftest.$ac_ext >&5
14880   rm -rf conftest*
14881   eval "ac_cv_func_$ac_func=no"
14882 fi
14883 rm -f conftest*
14884 fi
14885
14886 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14887   echo "$ac_t""yes" 1>&6
14888     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14889   cat >> confdefs.h <<EOF
14890 #define $ac_tr_func 1
14891 EOF
14892
14893 else
14894   echo "$ac_t""no" 1>&6
14895 fi
14896 done
14897
14898   fi
14899
14900
14901   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
14902 echo "configure:14903: checking for _atan2l declaration" >&5
14903   if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
14904   echo $ac_n "(cached) $ac_c" 1>&6
14905 else
14906
14907
14908     ac_ext=C
14909 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14910 ac_cpp='$CXXCPP $CPPFLAGS'
14911 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14912 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14913 cross_compiling=$ac_cv_prog_cxx_cross
14914
14915     cat > conftest.$ac_ext <<EOF
14916 #line 14917 "configure"
14917 #include "confdefs.h"
14918 #include <math.h>
14919 int main() {
14920  _atan2l(0, 0);
14921 ; return 0; }
14922 EOF
14923 if { (eval echo configure:14924: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14924   rm -rf conftest*
14925   glibcpp_cv_func__atan2l_use=yes
14926 else
14927   echo "configure: failed program was:" >&5
14928   cat conftest.$ac_ext >&5
14929   rm -rf conftest*
14930   glibcpp_cv_func__atan2l_use=no
14931 fi
14932 rm -f conftest*
14933     ac_ext=c
14934 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14935 ac_cpp='$CPP $CPPFLAGS'
14936 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14937 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14938 cross_compiling=$ac_cv_prog_cc_cross
14939
14940
14941 fi
14942
14943   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
14944   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
14945     for ac_func in _atan2l
14946 do
14947 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14948 echo "configure:14949: checking for $ac_func" >&5
14949 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14950   echo $ac_n "(cached) $ac_c" 1>&6
14951 else
14952   cat > conftest.$ac_ext <<EOF
14953 #line 14954 "configure"
14954 #include "confdefs.h"
14955 /* System header to define __stub macros and hopefully few prototypes,
14956     which can conflict with char $ac_func(); below.  */
14957 #include <assert.h>
14958 /* Override any gcc2 internal prototype to avoid an error.  */
14959 /* We use char because int might match the return type of a gcc2
14960     builtin and then its argument prototype would still apply.  */
14961 char $ac_func();
14962
14963 int main() {
14964
14965 /* The GNU C library defines this for functions which it implements
14966     to always fail with ENOSYS.  Some functions are actually named
14967     something starting with __ and the normal name is an alias.  */
14968 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14969 choke me
14970 #else
14971 $ac_func();
14972 #endif
14973
14974 ; return 0; }
14975 EOF
14976 if { (eval echo configure:14977: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14977   rm -rf conftest*
14978   eval "ac_cv_func_$ac_func=yes"
14979 else
14980   echo "configure: failed program was:" >&5
14981   cat conftest.$ac_ext >&5
14982   rm -rf conftest*
14983   eval "ac_cv_func_$ac_func=no"
14984 fi
14985 rm -f conftest*
14986 fi
14987
14988 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14989   echo "$ac_t""yes" 1>&6
14990     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14991   cat >> confdefs.h <<EOF
14992 #define $ac_tr_func 1
14993 EOF
14994
14995 else
14996   echo "$ac_t""no" 1>&6
14997 fi
14998 done
14999
15000   fi
15001
15002
15003   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
15004 echo "configure:15005: checking for _ceill declaration" >&5
15005   if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
15006   echo $ac_n "(cached) $ac_c" 1>&6
15007 else
15008
15009
15010     ac_ext=C
15011 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15012 ac_cpp='$CXXCPP $CPPFLAGS'
15013 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15014 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15015 cross_compiling=$ac_cv_prog_cxx_cross
15016
15017     cat > conftest.$ac_ext <<EOF
15018 #line 15019 "configure"
15019 #include "confdefs.h"
15020 #include <math.h>
15021 int main() {
15022  _ceill(0);
15023 ; return 0; }
15024 EOF
15025 if { (eval echo configure:15026: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15026   rm -rf conftest*
15027   glibcpp_cv_func__ceill_use=yes
15028 else
15029   echo "configure: failed program was:" >&5
15030   cat conftest.$ac_ext >&5
15031   rm -rf conftest*
15032   glibcpp_cv_func__ceill_use=no
15033 fi
15034 rm -f conftest*
15035     ac_ext=c
15036 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15037 ac_cpp='$CPP $CPPFLAGS'
15038 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15039 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15040 cross_compiling=$ac_cv_prog_cc_cross
15041
15042
15043 fi
15044
15045   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
15046   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
15047     for ac_func in _ceill
15048 do
15049 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15050 echo "configure:15051: checking for $ac_func" >&5
15051 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15052   echo $ac_n "(cached) $ac_c" 1>&6
15053 else
15054   cat > conftest.$ac_ext <<EOF
15055 #line 15056 "configure"
15056 #include "confdefs.h"
15057 /* System header to define __stub macros and hopefully few prototypes,
15058     which can conflict with char $ac_func(); below.  */
15059 #include <assert.h>
15060 /* Override any gcc2 internal prototype to avoid an error.  */
15061 /* We use char because int might match the return type of a gcc2
15062     builtin and then its argument prototype would still apply.  */
15063 char $ac_func();
15064
15065 int main() {
15066
15067 /* The GNU C library defines this for functions which it implements
15068     to always fail with ENOSYS.  Some functions are actually named
15069     something starting with __ and the normal name is an alias.  */
15070 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15071 choke me
15072 #else
15073 $ac_func();
15074 #endif
15075
15076 ; return 0; }
15077 EOF
15078 if { (eval echo configure:15079: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15079   rm -rf conftest*
15080   eval "ac_cv_func_$ac_func=yes"
15081 else
15082   echo "configure: failed program was:" >&5
15083   cat conftest.$ac_ext >&5
15084   rm -rf conftest*
15085   eval "ac_cv_func_$ac_func=no"
15086 fi
15087 rm -f conftest*
15088 fi
15089
15090 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15091   echo "$ac_t""yes" 1>&6
15092     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15093   cat >> confdefs.h <<EOF
15094 #define $ac_tr_func 1
15095 EOF
15096
15097 else
15098   echo "$ac_t""no" 1>&6
15099 fi
15100 done
15101
15102   fi
15103
15104
15105   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
15106 echo "configure:15107: checking for _cosl declaration" >&5
15107   if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
15108   echo $ac_n "(cached) $ac_c" 1>&6
15109 else
15110
15111
15112     ac_ext=C
15113 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15114 ac_cpp='$CXXCPP $CPPFLAGS'
15115 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15116 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15117 cross_compiling=$ac_cv_prog_cxx_cross
15118
15119     cat > conftest.$ac_ext <<EOF
15120 #line 15121 "configure"
15121 #include "confdefs.h"
15122 #include <math.h>
15123 int main() {
15124  _cosl(0);
15125 ; return 0; }
15126 EOF
15127 if { (eval echo configure:15128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15128   rm -rf conftest*
15129   glibcpp_cv_func__cosl_use=yes
15130 else
15131   echo "configure: failed program was:" >&5
15132   cat conftest.$ac_ext >&5
15133   rm -rf conftest*
15134   glibcpp_cv_func__cosl_use=no
15135 fi
15136 rm -f conftest*
15137     ac_ext=c
15138 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15139 ac_cpp='$CPP $CPPFLAGS'
15140 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15141 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15142 cross_compiling=$ac_cv_prog_cc_cross
15143
15144
15145 fi
15146
15147   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
15148   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
15149     for ac_func in _cosl
15150 do
15151 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15152 echo "configure:15153: checking for $ac_func" >&5
15153 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15154   echo $ac_n "(cached) $ac_c" 1>&6
15155 else
15156   cat > conftest.$ac_ext <<EOF
15157 #line 15158 "configure"
15158 #include "confdefs.h"
15159 /* System header to define __stub macros and hopefully few prototypes,
15160     which can conflict with char $ac_func(); below.  */
15161 #include <assert.h>
15162 /* Override any gcc2 internal prototype to avoid an error.  */
15163 /* We use char because int might match the return type of a gcc2
15164     builtin and then its argument prototype would still apply.  */
15165 char $ac_func();
15166
15167 int main() {
15168
15169 /* The GNU C library defines this for functions which it implements
15170     to always fail with ENOSYS.  Some functions are actually named
15171     something starting with __ and the normal name is an alias.  */
15172 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15173 choke me
15174 #else
15175 $ac_func();
15176 #endif
15177
15178 ; return 0; }
15179 EOF
15180 if { (eval echo configure:15181: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15181   rm -rf conftest*
15182   eval "ac_cv_func_$ac_func=yes"
15183 else
15184   echo "configure: failed program was:" >&5
15185   cat conftest.$ac_ext >&5
15186   rm -rf conftest*
15187   eval "ac_cv_func_$ac_func=no"
15188 fi
15189 rm -f conftest*
15190 fi
15191
15192 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15193   echo "$ac_t""yes" 1>&6
15194     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15195   cat >> confdefs.h <<EOF
15196 #define $ac_tr_func 1
15197 EOF
15198
15199 else
15200   echo "$ac_t""no" 1>&6
15201 fi
15202 done
15203
15204   fi
15205
15206
15207   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
15208 echo "configure:15209: checking for _coshl declaration" >&5
15209   if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
15210   echo $ac_n "(cached) $ac_c" 1>&6
15211 else
15212
15213
15214     ac_ext=C
15215 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15216 ac_cpp='$CXXCPP $CPPFLAGS'
15217 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15218 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15219 cross_compiling=$ac_cv_prog_cxx_cross
15220
15221     cat > conftest.$ac_ext <<EOF
15222 #line 15223 "configure"
15223 #include "confdefs.h"
15224 #include <math.h>
15225 int main() {
15226  _coshl(0);
15227 ; return 0; }
15228 EOF
15229 if { (eval echo configure:15230: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15230   rm -rf conftest*
15231   glibcpp_cv_func__coshl_use=yes
15232 else
15233   echo "configure: failed program was:" >&5
15234   cat conftest.$ac_ext >&5
15235   rm -rf conftest*
15236   glibcpp_cv_func__coshl_use=no
15237 fi
15238 rm -f conftest*
15239     ac_ext=c
15240 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15241 ac_cpp='$CPP $CPPFLAGS'
15242 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15243 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15244 cross_compiling=$ac_cv_prog_cc_cross
15245
15246
15247 fi
15248
15249   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
15250   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
15251     for ac_func in _coshl
15252 do
15253 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15254 echo "configure:15255: checking for $ac_func" >&5
15255 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15256   echo $ac_n "(cached) $ac_c" 1>&6
15257 else
15258   cat > conftest.$ac_ext <<EOF
15259 #line 15260 "configure"
15260 #include "confdefs.h"
15261 /* System header to define __stub macros and hopefully few prototypes,
15262     which can conflict with char $ac_func(); below.  */
15263 #include <assert.h>
15264 /* Override any gcc2 internal prototype to avoid an error.  */
15265 /* We use char because int might match the return type of a gcc2
15266     builtin and then its argument prototype would still apply.  */
15267 char $ac_func();
15268
15269 int main() {
15270
15271 /* The GNU C library defines this for functions which it implements
15272     to always fail with ENOSYS.  Some functions are actually named
15273     something starting with __ and the normal name is an alias.  */
15274 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15275 choke me
15276 #else
15277 $ac_func();
15278 #endif
15279
15280 ; return 0; }
15281 EOF
15282 if { (eval echo configure:15283: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15283   rm -rf conftest*
15284   eval "ac_cv_func_$ac_func=yes"
15285 else
15286   echo "configure: failed program was:" >&5
15287   cat conftest.$ac_ext >&5
15288   rm -rf conftest*
15289   eval "ac_cv_func_$ac_func=no"
15290 fi
15291 rm -f conftest*
15292 fi
15293
15294 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15295   echo "$ac_t""yes" 1>&6
15296     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15297   cat >> confdefs.h <<EOF
15298 #define $ac_tr_func 1
15299 EOF
15300
15301 else
15302   echo "$ac_t""no" 1>&6
15303 fi
15304 done
15305
15306   fi
15307
15308
15309   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
15310 echo "configure:15311: checking for _expl declaration" >&5
15311   if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
15312   echo $ac_n "(cached) $ac_c" 1>&6
15313 else
15314
15315
15316     ac_ext=C
15317 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15318 ac_cpp='$CXXCPP $CPPFLAGS'
15319 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15320 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15321 cross_compiling=$ac_cv_prog_cxx_cross
15322
15323     cat > conftest.$ac_ext <<EOF
15324 #line 15325 "configure"
15325 #include "confdefs.h"
15326 #include <math.h>
15327 int main() {
15328  _expl(0);
15329 ; return 0; }
15330 EOF
15331 if { (eval echo configure:15332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15332   rm -rf conftest*
15333   glibcpp_cv_func__expl_use=yes
15334 else
15335   echo "configure: failed program was:" >&5
15336   cat conftest.$ac_ext >&5
15337   rm -rf conftest*
15338   glibcpp_cv_func__expl_use=no
15339 fi
15340 rm -f conftest*
15341     ac_ext=c
15342 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15343 ac_cpp='$CPP $CPPFLAGS'
15344 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15345 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15346 cross_compiling=$ac_cv_prog_cc_cross
15347
15348
15349 fi
15350
15351   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
15352   if test x$glibcpp_cv_func__expl_use = x"yes"; then
15353     for ac_func in _expl
15354 do
15355 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15356 echo "configure:15357: checking for $ac_func" >&5
15357 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15358   echo $ac_n "(cached) $ac_c" 1>&6
15359 else
15360   cat > conftest.$ac_ext <<EOF
15361 #line 15362 "configure"
15362 #include "confdefs.h"
15363 /* System header to define __stub macros and hopefully few prototypes,
15364     which can conflict with char $ac_func(); below.  */
15365 #include <assert.h>
15366 /* Override any gcc2 internal prototype to avoid an error.  */
15367 /* We use char because int might match the return type of a gcc2
15368     builtin and then its argument prototype would still apply.  */
15369 char $ac_func();
15370
15371 int main() {
15372
15373 /* The GNU C library defines this for functions which it implements
15374     to always fail with ENOSYS.  Some functions are actually named
15375     something starting with __ and the normal name is an alias.  */
15376 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15377 choke me
15378 #else
15379 $ac_func();
15380 #endif
15381
15382 ; return 0; }
15383 EOF
15384 if { (eval echo configure:15385: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15385   rm -rf conftest*
15386   eval "ac_cv_func_$ac_func=yes"
15387 else
15388   echo "configure: failed program was:" >&5
15389   cat conftest.$ac_ext >&5
15390   rm -rf conftest*
15391   eval "ac_cv_func_$ac_func=no"
15392 fi
15393 rm -f conftest*
15394 fi
15395
15396 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15397   echo "$ac_t""yes" 1>&6
15398     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15399   cat >> confdefs.h <<EOF
15400 #define $ac_tr_func 1
15401 EOF
15402
15403 else
15404   echo "$ac_t""no" 1>&6
15405 fi
15406 done
15407
15408   fi
15409
15410
15411   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
15412 echo "configure:15413: checking for _fabsl declaration" >&5
15413   if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
15414   echo $ac_n "(cached) $ac_c" 1>&6
15415 else
15416
15417
15418     ac_ext=C
15419 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15420 ac_cpp='$CXXCPP $CPPFLAGS'
15421 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15422 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15423 cross_compiling=$ac_cv_prog_cxx_cross
15424
15425     cat > conftest.$ac_ext <<EOF
15426 #line 15427 "configure"
15427 #include "confdefs.h"
15428 #include <math.h>
15429 int main() {
15430  _fabsl(0);
15431 ; return 0; }
15432 EOF
15433 if { (eval echo configure:15434: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15434   rm -rf conftest*
15435   glibcpp_cv_func__fabsl_use=yes
15436 else
15437   echo "configure: failed program was:" >&5
15438   cat conftest.$ac_ext >&5
15439   rm -rf conftest*
15440   glibcpp_cv_func__fabsl_use=no
15441 fi
15442 rm -f conftest*
15443     ac_ext=c
15444 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15445 ac_cpp='$CPP $CPPFLAGS'
15446 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15447 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15448 cross_compiling=$ac_cv_prog_cc_cross
15449
15450
15451 fi
15452
15453   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
15454   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
15455     for ac_func in _fabsl
15456 do
15457 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15458 echo "configure:15459: checking for $ac_func" >&5
15459 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15460   echo $ac_n "(cached) $ac_c" 1>&6
15461 else
15462   cat > conftest.$ac_ext <<EOF
15463 #line 15464 "configure"
15464 #include "confdefs.h"
15465 /* System header to define __stub macros and hopefully few prototypes,
15466     which can conflict with char $ac_func(); below.  */
15467 #include <assert.h>
15468 /* Override any gcc2 internal prototype to avoid an error.  */
15469 /* We use char because int might match the return type of a gcc2
15470     builtin and then its argument prototype would still apply.  */
15471 char $ac_func();
15472
15473 int main() {
15474
15475 /* The GNU C library defines this for functions which it implements
15476     to always fail with ENOSYS.  Some functions are actually named
15477     something starting with __ and the normal name is an alias.  */
15478 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15479 choke me
15480 #else
15481 $ac_func();
15482 #endif
15483
15484 ; return 0; }
15485 EOF
15486 if { (eval echo configure:15487: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15487   rm -rf conftest*
15488   eval "ac_cv_func_$ac_func=yes"
15489 else
15490   echo "configure: failed program was:" >&5
15491   cat conftest.$ac_ext >&5
15492   rm -rf conftest*
15493   eval "ac_cv_func_$ac_func=no"
15494 fi
15495 rm -f conftest*
15496 fi
15497
15498 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15499   echo "$ac_t""yes" 1>&6
15500     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15501   cat >> confdefs.h <<EOF
15502 #define $ac_tr_func 1
15503 EOF
15504
15505 else
15506   echo "$ac_t""no" 1>&6
15507 fi
15508 done
15509
15510   fi
15511
15512
15513   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
15514 echo "configure:15515: checking for _floorl declaration" >&5
15515   if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
15516   echo $ac_n "(cached) $ac_c" 1>&6
15517 else
15518
15519
15520     ac_ext=C
15521 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15522 ac_cpp='$CXXCPP $CPPFLAGS'
15523 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15524 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15525 cross_compiling=$ac_cv_prog_cxx_cross
15526
15527     cat > conftest.$ac_ext <<EOF
15528 #line 15529 "configure"
15529 #include "confdefs.h"
15530 #include <math.h>
15531 int main() {
15532  _floorl(0);
15533 ; return 0; }
15534 EOF
15535 if { (eval echo configure:15536: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15536   rm -rf conftest*
15537   glibcpp_cv_func__floorl_use=yes
15538 else
15539   echo "configure: failed program was:" >&5
15540   cat conftest.$ac_ext >&5
15541   rm -rf conftest*
15542   glibcpp_cv_func__floorl_use=no
15543 fi
15544 rm -f conftest*
15545     ac_ext=c
15546 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15547 ac_cpp='$CPP $CPPFLAGS'
15548 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15549 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15550 cross_compiling=$ac_cv_prog_cc_cross
15551
15552
15553 fi
15554
15555   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
15556   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
15557     for ac_func in _floorl
15558 do
15559 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15560 echo "configure:15561: checking for $ac_func" >&5
15561 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15562   echo $ac_n "(cached) $ac_c" 1>&6
15563 else
15564   cat > conftest.$ac_ext <<EOF
15565 #line 15566 "configure"
15566 #include "confdefs.h"
15567 /* System header to define __stub macros and hopefully few prototypes,
15568     which can conflict with char $ac_func(); below.  */
15569 #include <assert.h>
15570 /* Override any gcc2 internal prototype to avoid an error.  */
15571 /* We use char because int might match the return type of a gcc2
15572     builtin and then its argument prototype would still apply.  */
15573 char $ac_func();
15574
15575 int main() {
15576
15577 /* The GNU C library defines this for functions which it implements
15578     to always fail with ENOSYS.  Some functions are actually named
15579     something starting with __ and the normal name is an alias.  */
15580 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15581 choke me
15582 #else
15583 $ac_func();
15584 #endif
15585
15586 ; return 0; }
15587 EOF
15588 if { (eval echo configure:15589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15589   rm -rf conftest*
15590   eval "ac_cv_func_$ac_func=yes"
15591 else
15592   echo "configure: failed program was:" >&5
15593   cat conftest.$ac_ext >&5
15594   rm -rf conftest*
15595   eval "ac_cv_func_$ac_func=no"
15596 fi
15597 rm -f conftest*
15598 fi
15599
15600 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15601   echo "$ac_t""yes" 1>&6
15602     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15603   cat >> confdefs.h <<EOF
15604 #define $ac_tr_func 1
15605 EOF
15606
15607 else
15608   echo "$ac_t""no" 1>&6
15609 fi
15610 done
15611
15612   fi
15613
15614
15615   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
15616 echo "configure:15617: checking for _fmodl declaration" >&5
15617   if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
15618   echo $ac_n "(cached) $ac_c" 1>&6
15619 else
15620
15621
15622     ac_ext=C
15623 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15624 ac_cpp='$CXXCPP $CPPFLAGS'
15625 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15626 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15627 cross_compiling=$ac_cv_prog_cxx_cross
15628
15629     cat > conftest.$ac_ext <<EOF
15630 #line 15631 "configure"
15631 #include "confdefs.h"
15632 #include <math.h>
15633 int main() {
15634  _fmodl(0, 0);
15635 ; return 0; }
15636 EOF
15637 if { (eval echo configure:15638: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15638   rm -rf conftest*
15639   glibcpp_cv_func__fmodl_use=yes
15640 else
15641   echo "configure: failed program was:" >&5
15642   cat conftest.$ac_ext >&5
15643   rm -rf conftest*
15644   glibcpp_cv_func__fmodl_use=no
15645 fi
15646 rm -f conftest*
15647     ac_ext=c
15648 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15649 ac_cpp='$CPP $CPPFLAGS'
15650 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15651 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15652 cross_compiling=$ac_cv_prog_cc_cross
15653
15654
15655 fi
15656
15657   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
15658   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
15659     for ac_func in _fmodl
15660 do
15661 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15662 echo "configure:15663: checking for $ac_func" >&5
15663 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15664   echo $ac_n "(cached) $ac_c" 1>&6
15665 else
15666   cat > conftest.$ac_ext <<EOF
15667 #line 15668 "configure"
15668 #include "confdefs.h"
15669 /* System header to define __stub macros and hopefully few prototypes,
15670     which can conflict with char $ac_func(); below.  */
15671 #include <assert.h>
15672 /* Override any gcc2 internal prototype to avoid an error.  */
15673 /* We use char because int might match the return type of a gcc2
15674     builtin and then its argument prototype would still apply.  */
15675 char $ac_func();
15676
15677 int main() {
15678
15679 /* The GNU C library defines this for functions which it implements
15680     to always fail with ENOSYS.  Some functions are actually named
15681     something starting with __ and the normal name is an alias.  */
15682 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15683 choke me
15684 #else
15685 $ac_func();
15686 #endif
15687
15688 ; return 0; }
15689 EOF
15690 if { (eval echo configure:15691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15691   rm -rf conftest*
15692   eval "ac_cv_func_$ac_func=yes"
15693 else
15694   echo "configure: failed program was:" >&5
15695   cat conftest.$ac_ext >&5
15696   rm -rf conftest*
15697   eval "ac_cv_func_$ac_func=no"
15698 fi
15699 rm -f conftest*
15700 fi
15701
15702 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15703   echo "$ac_t""yes" 1>&6
15704     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15705   cat >> confdefs.h <<EOF
15706 #define $ac_tr_func 1
15707 EOF
15708
15709 else
15710   echo "$ac_t""no" 1>&6
15711 fi
15712 done
15713
15714   fi
15715
15716
15717   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
15718 echo "configure:15719: checking for _frexpl declaration" >&5
15719   if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
15720   echo $ac_n "(cached) $ac_c" 1>&6
15721 else
15722
15723
15724     ac_ext=C
15725 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15726 ac_cpp='$CXXCPP $CPPFLAGS'
15727 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15728 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15729 cross_compiling=$ac_cv_prog_cxx_cross
15730
15731     cat > conftest.$ac_ext <<EOF
15732 #line 15733 "configure"
15733 #include "confdefs.h"
15734 #include <math.h>
15735 int main() {
15736  _frexpl(0, 0);
15737 ; return 0; }
15738 EOF
15739 if { (eval echo configure:15740: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15740   rm -rf conftest*
15741   glibcpp_cv_func__frexpl_use=yes
15742 else
15743   echo "configure: failed program was:" >&5
15744   cat conftest.$ac_ext >&5
15745   rm -rf conftest*
15746   glibcpp_cv_func__frexpl_use=no
15747 fi
15748 rm -f conftest*
15749     ac_ext=c
15750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15751 ac_cpp='$CPP $CPPFLAGS'
15752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15754 cross_compiling=$ac_cv_prog_cc_cross
15755
15756
15757 fi
15758
15759   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
15760   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
15761     for ac_func in _frexpl
15762 do
15763 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15764 echo "configure:15765: checking for $ac_func" >&5
15765 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15766   echo $ac_n "(cached) $ac_c" 1>&6
15767 else
15768   cat > conftest.$ac_ext <<EOF
15769 #line 15770 "configure"
15770 #include "confdefs.h"
15771 /* System header to define __stub macros and hopefully few prototypes,
15772     which can conflict with char $ac_func(); below.  */
15773 #include <assert.h>
15774 /* Override any gcc2 internal prototype to avoid an error.  */
15775 /* We use char because int might match the return type of a gcc2
15776     builtin and then its argument prototype would still apply.  */
15777 char $ac_func();
15778
15779 int main() {
15780
15781 /* The GNU C library defines this for functions which it implements
15782     to always fail with ENOSYS.  Some functions are actually named
15783     something starting with __ and the normal name is an alias.  */
15784 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15785 choke me
15786 #else
15787 $ac_func();
15788 #endif
15789
15790 ; return 0; }
15791 EOF
15792 if { (eval echo configure:15793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15793   rm -rf conftest*
15794   eval "ac_cv_func_$ac_func=yes"
15795 else
15796   echo "configure: failed program was:" >&5
15797   cat conftest.$ac_ext >&5
15798   rm -rf conftest*
15799   eval "ac_cv_func_$ac_func=no"
15800 fi
15801 rm -f conftest*
15802 fi
15803
15804 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15805   echo "$ac_t""yes" 1>&6
15806     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15807   cat >> confdefs.h <<EOF
15808 #define $ac_tr_func 1
15809 EOF
15810
15811 else
15812   echo "$ac_t""no" 1>&6
15813 fi
15814 done
15815
15816   fi
15817
15818
15819   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
15820 echo "configure:15821: checking for _ldexpl declaration" >&5
15821   if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
15822   echo $ac_n "(cached) $ac_c" 1>&6
15823 else
15824
15825
15826     ac_ext=C
15827 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15828 ac_cpp='$CXXCPP $CPPFLAGS'
15829 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15830 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15831 cross_compiling=$ac_cv_prog_cxx_cross
15832
15833     cat > conftest.$ac_ext <<EOF
15834 #line 15835 "configure"
15835 #include "confdefs.h"
15836 #include <math.h>
15837 int main() {
15838  _ldexpl(0, 0);
15839 ; return 0; }
15840 EOF
15841 if { (eval echo configure:15842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15842   rm -rf conftest*
15843   glibcpp_cv_func__ldexpl_use=yes
15844 else
15845   echo "configure: failed program was:" >&5
15846   cat conftest.$ac_ext >&5
15847   rm -rf conftest*
15848   glibcpp_cv_func__ldexpl_use=no
15849 fi
15850 rm -f conftest*
15851     ac_ext=c
15852 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15853 ac_cpp='$CPP $CPPFLAGS'
15854 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15855 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15856 cross_compiling=$ac_cv_prog_cc_cross
15857
15858
15859 fi
15860
15861   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
15862   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
15863     for ac_func in _ldexpl
15864 do
15865 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15866 echo "configure:15867: checking for $ac_func" >&5
15867 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15868   echo $ac_n "(cached) $ac_c" 1>&6
15869 else
15870   cat > conftest.$ac_ext <<EOF
15871 #line 15872 "configure"
15872 #include "confdefs.h"
15873 /* System header to define __stub macros and hopefully few prototypes,
15874     which can conflict with char $ac_func(); below.  */
15875 #include <assert.h>
15876 /* Override any gcc2 internal prototype to avoid an error.  */
15877 /* We use char because int might match the return type of a gcc2
15878     builtin and then its argument prototype would still apply.  */
15879 char $ac_func();
15880
15881 int main() {
15882
15883 /* The GNU C library defines this for functions which it implements
15884     to always fail with ENOSYS.  Some functions are actually named
15885     something starting with __ and the normal name is an alias.  */
15886 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15887 choke me
15888 #else
15889 $ac_func();
15890 #endif
15891
15892 ; return 0; }
15893 EOF
15894 if { (eval echo configure:15895: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15895   rm -rf conftest*
15896   eval "ac_cv_func_$ac_func=yes"
15897 else
15898   echo "configure: failed program was:" >&5
15899   cat conftest.$ac_ext >&5
15900   rm -rf conftest*
15901   eval "ac_cv_func_$ac_func=no"
15902 fi
15903 rm -f conftest*
15904 fi
15905
15906 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15907   echo "$ac_t""yes" 1>&6
15908     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15909   cat >> confdefs.h <<EOF
15910 #define $ac_tr_func 1
15911 EOF
15912
15913 else
15914   echo "$ac_t""no" 1>&6
15915 fi
15916 done
15917
15918   fi
15919
15920
15921   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
15922 echo "configure:15923: checking for _logl declaration" >&5
15923   if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
15924   echo $ac_n "(cached) $ac_c" 1>&6
15925 else
15926
15927
15928     ac_ext=C
15929 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15930 ac_cpp='$CXXCPP $CPPFLAGS'
15931 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15932 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15933 cross_compiling=$ac_cv_prog_cxx_cross
15934
15935     cat > conftest.$ac_ext <<EOF
15936 #line 15937 "configure"
15937 #include "confdefs.h"
15938 #include <math.h>
15939 int main() {
15940  _logl(0);
15941 ; return 0; }
15942 EOF
15943 if { (eval echo configure:15944: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15944   rm -rf conftest*
15945   glibcpp_cv_func__logl_use=yes
15946 else
15947   echo "configure: failed program was:" >&5
15948   cat conftest.$ac_ext >&5
15949   rm -rf conftest*
15950   glibcpp_cv_func__logl_use=no
15951 fi
15952 rm -f conftest*
15953     ac_ext=c
15954 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15955 ac_cpp='$CPP $CPPFLAGS'
15956 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15957 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15958 cross_compiling=$ac_cv_prog_cc_cross
15959
15960
15961 fi
15962
15963   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
15964   if test x$glibcpp_cv_func__logl_use = x"yes"; then
15965     for ac_func in _logl
15966 do
15967 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15968 echo "configure:15969: checking for $ac_func" >&5
15969 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15970   echo $ac_n "(cached) $ac_c" 1>&6
15971 else
15972   cat > conftest.$ac_ext <<EOF
15973 #line 15974 "configure"
15974 #include "confdefs.h"
15975 /* System header to define __stub macros and hopefully few prototypes,
15976     which can conflict with char $ac_func(); below.  */
15977 #include <assert.h>
15978 /* Override any gcc2 internal prototype to avoid an error.  */
15979 /* We use char because int might match the return type of a gcc2
15980     builtin and then its argument prototype would still apply.  */
15981 char $ac_func();
15982
15983 int main() {
15984
15985 /* The GNU C library defines this for functions which it implements
15986     to always fail with ENOSYS.  Some functions are actually named
15987     something starting with __ and the normal name is an alias.  */
15988 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15989 choke me
15990 #else
15991 $ac_func();
15992 #endif
15993
15994 ; return 0; }
15995 EOF
15996 if { (eval echo configure:15997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15997   rm -rf conftest*
15998   eval "ac_cv_func_$ac_func=yes"
15999 else
16000   echo "configure: failed program was:" >&5
16001   cat conftest.$ac_ext >&5
16002   rm -rf conftest*
16003   eval "ac_cv_func_$ac_func=no"
16004 fi
16005 rm -f conftest*
16006 fi
16007
16008 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16009   echo "$ac_t""yes" 1>&6
16010     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16011   cat >> confdefs.h <<EOF
16012 #define $ac_tr_func 1
16013 EOF
16014
16015 else
16016   echo "$ac_t""no" 1>&6
16017 fi
16018 done
16019
16020   fi
16021
16022
16023   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
16024 echo "configure:16025: checking for _log10l declaration" >&5
16025   if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
16026   echo $ac_n "(cached) $ac_c" 1>&6
16027 else
16028
16029
16030     ac_ext=C
16031 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16032 ac_cpp='$CXXCPP $CPPFLAGS'
16033 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16034 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16035 cross_compiling=$ac_cv_prog_cxx_cross
16036
16037     cat > conftest.$ac_ext <<EOF
16038 #line 16039 "configure"
16039 #include "confdefs.h"
16040 #include <math.h>
16041 int main() {
16042  _log10l(0);
16043 ; return 0; }
16044 EOF
16045 if { (eval echo configure:16046: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16046   rm -rf conftest*
16047   glibcpp_cv_func__log10l_use=yes
16048 else
16049   echo "configure: failed program was:" >&5
16050   cat conftest.$ac_ext >&5
16051   rm -rf conftest*
16052   glibcpp_cv_func__log10l_use=no
16053 fi
16054 rm -f conftest*
16055     ac_ext=c
16056 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16057 ac_cpp='$CPP $CPPFLAGS'
16058 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16059 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16060 cross_compiling=$ac_cv_prog_cc_cross
16061
16062
16063 fi
16064
16065   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16066   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16067     for ac_func in _log10l
16068 do
16069 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16070 echo "configure:16071: checking for $ac_func" >&5
16071 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16072   echo $ac_n "(cached) $ac_c" 1>&6
16073 else
16074   cat > conftest.$ac_ext <<EOF
16075 #line 16076 "configure"
16076 #include "confdefs.h"
16077 /* System header to define __stub macros and hopefully few prototypes,
16078     which can conflict with char $ac_func(); below.  */
16079 #include <assert.h>
16080 /* Override any gcc2 internal prototype to avoid an error.  */
16081 /* We use char because int might match the return type of a gcc2
16082     builtin and then its argument prototype would still apply.  */
16083 char $ac_func();
16084
16085 int main() {
16086
16087 /* The GNU C library defines this for functions which it implements
16088     to always fail with ENOSYS.  Some functions are actually named
16089     something starting with __ and the normal name is an alias.  */
16090 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16091 choke me
16092 #else
16093 $ac_func();
16094 #endif
16095
16096 ; return 0; }
16097 EOF
16098 if { (eval echo configure:16099: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16099   rm -rf conftest*
16100   eval "ac_cv_func_$ac_func=yes"
16101 else
16102   echo "configure: failed program was:" >&5
16103   cat conftest.$ac_ext >&5
16104   rm -rf conftest*
16105   eval "ac_cv_func_$ac_func=no"
16106 fi
16107 rm -f conftest*
16108 fi
16109
16110 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16111   echo "$ac_t""yes" 1>&6
16112     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16113   cat >> confdefs.h <<EOF
16114 #define $ac_tr_func 1
16115 EOF
16116
16117 else
16118   echo "$ac_t""no" 1>&6
16119 fi
16120 done
16121
16122   fi
16123
16124
16125   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
16126 echo "configure:16127: checking for _modfl declaration" >&5
16127   if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
16128   echo $ac_n "(cached) $ac_c" 1>&6
16129 else
16130
16131
16132     ac_ext=C
16133 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16134 ac_cpp='$CXXCPP $CPPFLAGS'
16135 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16136 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16137 cross_compiling=$ac_cv_prog_cxx_cross
16138
16139     cat > conftest.$ac_ext <<EOF
16140 #line 16141 "configure"
16141 #include "confdefs.h"
16142 #include <math.h>
16143 int main() {
16144  _modfl(0, 0);
16145 ; return 0; }
16146 EOF
16147 if { (eval echo configure:16148: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16148   rm -rf conftest*
16149   glibcpp_cv_func__modfl_use=yes
16150 else
16151   echo "configure: failed program was:" >&5
16152   cat conftest.$ac_ext >&5
16153   rm -rf conftest*
16154   glibcpp_cv_func__modfl_use=no
16155 fi
16156 rm -f conftest*
16157     ac_ext=c
16158 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16159 ac_cpp='$CPP $CPPFLAGS'
16160 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16161 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16162 cross_compiling=$ac_cv_prog_cc_cross
16163
16164
16165 fi
16166
16167   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
16168   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
16169     for ac_func in _modfl
16170 do
16171 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16172 echo "configure:16173: checking for $ac_func" >&5
16173 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16174   echo $ac_n "(cached) $ac_c" 1>&6
16175 else
16176   cat > conftest.$ac_ext <<EOF
16177 #line 16178 "configure"
16178 #include "confdefs.h"
16179 /* System header to define __stub macros and hopefully few prototypes,
16180     which can conflict with char $ac_func(); below.  */
16181 #include <assert.h>
16182 /* Override any gcc2 internal prototype to avoid an error.  */
16183 /* We use char because int might match the return type of a gcc2
16184     builtin and then its argument prototype would still apply.  */
16185 char $ac_func();
16186
16187 int main() {
16188
16189 /* The GNU C library defines this for functions which it implements
16190     to always fail with ENOSYS.  Some functions are actually named
16191     something starting with __ and the normal name is an alias.  */
16192 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16193 choke me
16194 #else
16195 $ac_func();
16196 #endif
16197
16198 ; return 0; }
16199 EOF
16200 if { (eval echo configure:16201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16201   rm -rf conftest*
16202   eval "ac_cv_func_$ac_func=yes"
16203 else
16204   echo "configure: failed program was:" >&5
16205   cat conftest.$ac_ext >&5
16206   rm -rf conftest*
16207   eval "ac_cv_func_$ac_func=no"
16208 fi
16209 rm -f conftest*
16210 fi
16211
16212 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16213   echo "$ac_t""yes" 1>&6
16214     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16215   cat >> confdefs.h <<EOF
16216 #define $ac_tr_func 1
16217 EOF
16218
16219 else
16220   echo "$ac_t""no" 1>&6
16221 fi
16222 done
16223
16224   fi
16225
16226
16227   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
16228 echo "configure:16229: checking for _powl declaration" >&5
16229   if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
16230   echo $ac_n "(cached) $ac_c" 1>&6
16231 else
16232
16233
16234     ac_ext=C
16235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16236 ac_cpp='$CXXCPP $CPPFLAGS'
16237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16239 cross_compiling=$ac_cv_prog_cxx_cross
16240
16241     cat > conftest.$ac_ext <<EOF
16242 #line 16243 "configure"
16243 #include "confdefs.h"
16244 #include <math.h>
16245 int main() {
16246  _powl(0, 0);
16247 ; return 0; }
16248 EOF
16249 if { (eval echo configure:16250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16250   rm -rf conftest*
16251   glibcpp_cv_func__powl_use=yes
16252 else
16253   echo "configure: failed program was:" >&5
16254   cat conftest.$ac_ext >&5
16255   rm -rf conftest*
16256   glibcpp_cv_func__powl_use=no
16257 fi
16258 rm -f conftest*
16259     ac_ext=c
16260 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16261 ac_cpp='$CPP $CPPFLAGS'
16262 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16263 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16264 cross_compiling=$ac_cv_prog_cc_cross
16265
16266
16267 fi
16268
16269   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
16270   if test x$glibcpp_cv_func__powl_use = x"yes"; then
16271     for ac_func in _powl
16272 do
16273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16274 echo "configure:16275: checking for $ac_func" >&5
16275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16276   echo $ac_n "(cached) $ac_c" 1>&6
16277 else
16278   cat > conftest.$ac_ext <<EOF
16279 #line 16280 "configure"
16280 #include "confdefs.h"
16281 /* System header to define __stub macros and hopefully few prototypes,
16282     which can conflict with char $ac_func(); below.  */
16283 #include <assert.h>
16284 /* Override any gcc2 internal prototype to avoid an error.  */
16285 /* We use char because int might match the return type of a gcc2
16286     builtin and then its argument prototype would still apply.  */
16287 char $ac_func();
16288
16289 int main() {
16290
16291 /* The GNU C library defines this for functions which it implements
16292     to always fail with ENOSYS.  Some functions are actually named
16293     something starting with __ and the normal name is an alias.  */
16294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16295 choke me
16296 #else
16297 $ac_func();
16298 #endif
16299
16300 ; return 0; }
16301 EOF
16302 if { (eval echo configure:16303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16303   rm -rf conftest*
16304   eval "ac_cv_func_$ac_func=yes"
16305 else
16306   echo "configure: failed program was:" >&5
16307   cat conftest.$ac_ext >&5
16308   rm -rf conftest*
16309   eval "ac_cv_func_$ac_func=no"
16310 fi
16311 rm -f conftest*
16312 fi
16313
16314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16315   echo "$ac_t""yes" 1>&6
16316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16317   cat >> confdefs.h <<EOF
16318 #define $ac_tr_func 1
16319 EOF
16320
16321 else
16322   echo "$ac_t""no" 1>&6
16323 fi
16324 done
16325
16326   fi
16327
16328
16329   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
16330 echo "configure:16331: checking for _sinl declaration" >&5
16331   if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
16332   echo $ac_n "(cached) $ac_c" 1>&6
16333 else
16334
16335
16336     ac_ext=C
16337 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16338 ac_cpp='$CXXCPP $CPPFLAGS'
16339 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16340 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16341 cross_compiling=$ac_cv_prog_cxx_cross
16342
16343     cat > conftest.$ac_ext <<EOF
16344 #line 16345 "configure"
16345 #include "confdefs.h"
16346 #include <math.h>
16347 int main() {
16348  _sinl(0);
16349 ; return 0; }
16350 EOF
16351 if { (eval echo configure:16352: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16352   rm -rf conftest*
16353   glibcpp_cv_func__sinl_use=yes
16354 else
16355   echo "configure: failed program was:" >&5
16356   cat conftest.$ac_ext >&5
16357   rm -rf conftest*
16358   glibcpp_cv_func__sinl_use=no
16359 fi
16360 rm -f conftest*
16361     ac_ext=c
16362 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16363 ac_cpp='$CPP $CPPFLAGS'
16364 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16365 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16366 cross_compiling=$ac_cv_prog_cc_cross
16367
16368
16369 fi
16370
16371   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
16372   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
16373     for ac_func in _sinl
16374 do
16375 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16376 echo "configure:16377: checking for $ac_func" >&5
16377 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16378   echo $ac_n "(cached) $ac_c" 1>&6
16379 else
16380   cat > conftest.$ac_ext <<EOF
16381 #line 16382 "configure"
16382 #include "confdefs.h"
16383 /* System header to define __stub macros and hopefully few prototypes,
16384     which can conflict with char $ac_func(); below.  */
16385 #include <assert.h>
16386 /* Override any gcc2 internal prototype to avoid an error.  */
16387 /* We use char because int might match the return type of a gcc2
16388     builtin and then its argument prototype would still apply.  */
16389 char $ac_func();
16390
16391 int main() {
16392
16393 /* The GNU C library defines this for functions which it implements
16394     to always fail with ENOSYS.  Some functions are actually named
16395     something starting with __ and the normal name is an alias.  */
16396 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16397 choke me
16398 #else
16399 $ac_func();
16400 #endif
16401
16402 ; return 0; }
16403 EOF
16404 if { (eval echo configure:16405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16405   rm -rf conftest*
16406   eval "ac_cv_func_$ac_func=yes"
16407 else
16408   echo "configure: failed program was:" >&5
16409   cat conftest.$ac_ext >&5
16410   rm -rf conftest*
16411   eval "ac_cv_func_$ac_func=no"
16412 fi
16413 rm -f conftest*
16414 fi
16415
16416 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16417   echo "$ac_t""yes" 1>&6
16418     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16419   cat >> confdefs.h <<EOF
16420 #define $ac_tr_func 1
16421 EOF
16422
16423 else
16424   echo "$ac_t""no" 1>&6
16425 fi
16426 done
16427
16428   fi
16429
16430
16431   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
16432 echo "configure:16433: checking for _sinhl declaration" >&5
16433   if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
16434   echo $ac_n "(cached) $ac_c" 1>&6
16435 else
16436
16437
16438     ac_ext=C
16439 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16440 ac_cpp='$CXXCPP $CPPFLAGS'
16441 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16442 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16443 cross_compiling=$ac_cv_prog_cxx_cross
16444
16445     cat > conftest.$ac_ext <<EOF
16446 #line 16447 "configure"
16447 #include "confdefs.h"
16448 #include <math.h>
16449 int main() {
16450  _sinhl(0);
16451 ; return 0; }
16452 EOF
16453 if { (eval echo configure:16454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16454   rm -rf conftest*
16455   glibcpp_cv_func__sinhl_use=yes
16456 else
16457   echo "configure: failed program was:" >&5
16458   cat conftest.$ac_ext >&5
16459   rm -rf conftest*
16460   glibcpp_cv_func__sinhl_use=no
16461 fi
16462 rm -f conftest*
16463     ac_ext=c
16464 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16465 ac_cpp='$CPP $CPPFLAGS'
16466 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16467 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16468 cross_compiling=$ac_cv_prog_cc_cross
16469
16470
16471 fi
16472
16473   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
16474   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
16475     for ac_func in _sinhl
16476 do
16477 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16478 echo "configure:16479: checking for $ac_func" >&5
16479 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16480   echo $ac_n "(cached) $ac_c" 1>&6
16481 else
16482   cat > conftest.$ac_ext <<EOF
16483 #line 16484 "configure"
16484 #include "confdefs.h"
16485 /* System header to define __stub macros and hopefully few prototypes,
16486     which can conflict with char $ac_func(); below.  */
16487 #include <assert.h>
16488 /* Override any gcc2 internal prototype to avoid an error.  */
16489 /* We use char because int might match the return type of a gcc2
16490     builtin and then its argument prototype would still apply.  */
16491 char $ac_func();
16492
16493 int main() {
16494
16495 /* The GNU C library defines this for functions which it implements
16496     to always fail with ENOSYS.  Some functions are actually named
16497     something starting with __ and the normal name is an alias.  */
16498 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16499 choke me
16500 #else
16501 $ac_func();
16502 #endif
16503
16504 ; return 0; }
16505 EOF
16506 if { (eval echo configure:16507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16507   rm -rf conftest*
16508   eval "ac_cv_func_$ac_func=yes"
16509 else
16510   echo "configure: failed program was:" >&5
16511   cat conftest.$ac_ext >&5
16512   rm -rf conftest*
16513   eval "ac_cv_func_$ac_func=no"
16514 fi
16515 rm -f conftest*
16516 fi
16517
16518 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16519   echo "$ac_t""yes" 1>&6
16520     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16521   cat >> confdefs.h <<EOF
16522 #define $ac_tr_func 1
16523 EOF
16524
16525 else
16526   echo "$ac_t""no" 1>&6
16527 fi
16528 done
16529
16530   fi
16531
16532
16533   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
16534 echo "configure:16535: checking for _sqrtl declaration" >&5
16535   if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
16536   echo $ac_n "(cached) $ac_c" 1>&6
16537 else
16538
16539
16540     ac_ext=C
16541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16542 ac_cpp='$CXXCPP $CPPFLAGS'
16543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16545 cross_compiling=$ac_cv_prog_cxx_cross
16546
16547     cat > conftest.$ac_ext <<EOF
16548 #line 16549 "configure"
16549 #include "confdefs.h"
16550 #include <math.h>
16551 int main() {
16552  _sqrtl(0);
16553 ; return 0; }
16554 EOF
16555 if { (eval echo configure:16556: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16556   rm -rf conftest*
16557   glibcpp_cv_func__sqrtl_use=yes
16558 else
16559   echo "configure: failed program was:" >&5
16560   cat conftest.$ac_ext >&5
16561   rm -rf conftest*
16562   glibcpp_cv_func__sqrtl_use=no
16563 fi
16564 rm -f conftest*
16565     ac_ext=c
16566 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16567 ac_cpp='$CPP $CPPFLAGS'
16568 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16569 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16570 cross_compiling=$ac_cv_prog_cc_cross
16571
16572
16573 fi
16574
16575   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
16576   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
16577     for ac_func in _sqrtl
16578 do
16579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16580 echo "configure:16581: checking for $ac_func" >&5
16581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16582   echo $ac_n "(cached) $ac_c" 1>&6
16583 else
16584   cat > conftest.$ac_ext <<EOF
16585 #line 16586 "configure"
16586 #include "confdefs.h"
16587 /* System header to define __stub macros and hopefully few prototypes,
16588     which can conflict with char $ac_func(); below.  */
16589 #include <assert.h>
16590 /* Override any gcc2 internal prototype to avoid an error.  */
16591 /* We use char because int might match the return type of a gcc2
16592     builtin and then its argument prototype would still apply.  */
16593 char $ac_func();
16594
16595 int main() {
16596
16597 /* The GNU C library defines this for functions which it implements
16598     to always fail with ENOSYS.  Some functions are actually named
16599     something starting with __ and the normal name is an alias.  */
16600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16601 choke me
16602 #else
16603 $ac_func();
16604 #endif
16605
16606 ; return 0; }
16607 EOF
16608 if { (eval echo configure:16609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16609   rm -rf conftest*
16610   eval "ac_cv_func_$ac_func=yes"
16611 else
16612   echo "configure: failed program was:" >&5
16613   cat conftest.$ac_ext >&5
16614   rm -rf conftest*
16615   eval "ac_cv_func_$ac_func=no"
16616 fi
16617 rm -f conftest*
16618 fi
16619
16620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16621   echo "$ac_t""yes" 1>&6
16622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16623   cat >> confdefs.h <<EOF
16624 #define $ac_tr_func 1
16625 EOF
16626
16627 else
16628   echo "$ac_t""no" 1>&6
16629 fi
16630 done
16631
16632   fi
16633
16634
16635   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
16636 echo "configure:16637: checking for _tanl declaration" >&5
16637   if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
16638   echo $ac_n "(cached) $ac_c" 1>&6
16639 else
16640
16641
16642     ac_ext=C
16643 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16644 ac_cpp='$CXXCPP $CPPFLAGS'
16645 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16646 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16647 cross_compiling=$ac_cv_prog_cxx_cross
16648
16649     cat > conftest.$ac_ext <<EOF
16650 #line 16651 "configure"
16651 #include "confdefs.h"
16652 #include <math.h>
16653 int main() {
16654  _tanl(0);
16655 ; return 0; }
16656 EOF
16657 if { (eval echo configure:16658: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16658   rm -rf conftest*
16659   glibcpp_cv_func__tanl_use=yes
16660 else
16661   echo "configure: failed program was:" >&5
16662   cat conftest.$ac_ext >&5
16663   rm -rf conftest*
16664   glibcpp_cv_func__tanl_use=no
16665 fi
16666 rm -f conftest*
16667     ac_ext=c
16668 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16669 ac_cpp='$CPP $CPPFLAGS'
16670 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16671 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16672 cross_compiling=$ac_cv_prog_cc_cross
16673
16674
16675 fi
16676
16677   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
16678   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
16679     for ac_func in _tanl
16680 do
16681 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16682 echo "configure:16683: checking for $ac_func" >&5
16683 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16684   echo $ac_n "(cached) $ac_c" 1>&6
16685 else
16686   cat > conftest.$ac_ext <<EOF
16687 #line 16688 "configure"
16688 #include "confdefs.h"
16689 /* System header to define __stub macros and hopefully few prototypes,
16690     which can conflict with char $ac_func(); below.  */
16691 #include <assert.h>
16692 /* Override any gcc2 internal prototype to avoid an error.  */
16693 /* We use char because int might match the return type of a gcc2
16694     builtin and then its argument prototype would still apply.  */
16695 char $ac_func();
16696
16697 int main() {
16698
16699 /* The GNU C library defines this for functions which it implements
16700     to always fail with ENOSYS.  Some functions are actually named
16701     something starting with __ and the normal name is an alias.  */
16702 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16703 choke me
16704 #else
16705 $ac_func();
16706 #endif
16707
16708 ; return 0; }
16709 EOF
16710 if { (eval echo configure:16711: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16711   rm -rf conftest*
16712   eval "ac_cv_func_$ac_func=yes"
16713 else
16714   echo "configure: failed program was:" >&5
16715   cat conftest.$ac_ext >&5
16716   rm -rf conftest*
16717   eval "ac_cv_func_$ac_func=no"
16718 fi
16719 rm -f conftest*
16720 fi
16721
16722 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16723   echo "$ac_t""yes" 1>&6
16724     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16725   cat >> confdefs.h <<EOF
16726 #define $ac_tr_func 1
16727 EOF
16728
16729 else
16730   echo "$ac_t""no" 1>&6
16731 fi
16732 done
16733
16734   fi
16735
16736
16737   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
16738 echo "configure:16739: checking for _tanhl declaration" >&5
16739   if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
16740   echo $ac_n "(cached) $ac_c" 1>&6
16741 else
16742
16743
16744     ac_ext=C
16745 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16746 ac_cpp='$CXXCPP $CPPFLAGS'
16747 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16748 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16749 cross_compiling=$ac_cv_prog_cxx_cross
16750
16751     cat > conftest.$ac_ext <<EOF
16752 #line 16753 "configure"
16753 #include "confdefs.h"
16754 #include <math.h>
16755 int main() {
16756  _tanhl(0);
16757 ; return 0; }
16758 EOF
16759 if { (eval echo configure:16760: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16760   rm -rf conftest*
16761   glibcpp_cv_func__tanhl_use=yes
16762 else
16763   echo "configure: failed program was:" >&5
16764   cat conftest.$ac_ext >&5
16765   rm -rf conftest*
16766   glibcpp_cv_func__tanhl_use=no
16767 fi
16768 rm -f conftest*
16769     ac_ext=c
16770 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16771 ac_cpp='$CPP $CPPFLAGS'
16772 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16773 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16774 cross_compiling=$ac_cv_prog_cc_cross
16775
16776
16777 fi
16778
16779   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
16780   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
16781     for ac_func in _tanhl
16782 do
16783 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16784 echo "configure:16785: checking for $ac_func" >&5
16785 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16786   echo $ac_n "(cached) $ac_c" 1>&6
16787 else
16788   cat > conftest.$ac_ext <<EOF
16789 #line 16790 "configure"
16790 #include "confdefs.h"
16791 /* System header to define __stub macros and hopefully few prototypes,
16792     which can conflict with char $ac_func(); below.  */
16793 #include <assert.h>
16794 /* Override any gcc2 internal prototype to avoid an error.  */
16795 /* We use char because int might match the return type of a gcc2
16796     builtin and then its argument prototype would still apply.  */
16797 char $ac_func();
16798
16799 int main() {
16800
16801 /* The GNU C library defines this for functions which it implements
16802     to always fail with ENOSYS.  Some functions are actually named
16803     something starting with __ and the normal name is an alias.  */
16804 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16805 choke me
16806 #else
16807 $ac_func();
16808 #endif
16809
16810 ; return 0; }
16811 EOF
16812 if { (eval echo configure:16813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16813   rm -rf conftest*
16814   eval "ac_cv_func_$ac_func=yes"
16815 else
16816   echo "configure: failed program was:" >&5
16817   cat conftest.$ac_ext >&5
16818   rm -rf conftest*
16819   eval "ac_cv_func_$ac_func=no"
16820 fi
16821 rm -f conftest*
16822 fi
16823
16824 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16825   echo "$ac_t""yes" 1>&6
16826     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16827   cat >> confdefs.h <<EOF
16828 #define $ac_tr_func 1
16829 EOF
16830
16831 else
16832   echo "$ac_t""no" 1>&6
16833 fi
16834 done
16835
16836   fi
16837
16838
16839   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
16840 echo "configure:16841: checking for _sincosl declaration" >&5
16841   if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
16842   echo $ac_n "(cached) $ac_c" 1>&6
16843 else
16844
16845
16846     ac_ext=C
16847 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16848 ac_cpp='$CXXCPP $CPPFLAGS'
16849 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16850 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16851 cross_compiling=$ac_cv_prog_cxx_cross
16852
16853     cat > conftest.$ac_ext <<EOF
16854 #line 16855 "configure"
16855 #include "confdefs.h"
16856 #include <math.h>
16857 int main() {
16858  _sincosl(0, 0, 0);
16859 ; return 0; }
16860 EOF
16861 if { (eval echo configure:16862: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16862   rm -rf conftest*
16863   glibcpp_cv_func__sincosl_use=yes
16864 else
16865   echo "configure: failed program was:" >&5
16866   cat conftest.$ac_ext >&5
16867   rm -rf conftest*
16868   glibcpp_cv_func__sincosl_use=no
16869 fi
16870 rm -f conftest*
16871     ac_ext=c
16872 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16873 ac_cpp='$CPP $CPPFLAGS'
16874 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16875 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16876 cross_compiling=$ac_cv_prog_cc_cross
16877
16878
16879 fi
16880
16881   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
16882   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
16883     for ac_func in _sincosl
16884 do
16885 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16886 echo "configure:16887: checking for $ac_func" >&5
16887 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16888   echo $ac_n "(cached) $ac_c" 1>&6
16889 else
16890   cat > conftest.$ac_ext <<EOF
16891 #line 16892 "configure"
16892 #include "confdefs.h"
16893 /* System header to define __stub macros and hopefully few prototypes,
16894     which can conflict with char $ac_func(); below.  */
16895 #include <assert.h>
16896 /* Override any gcc2 internal prototype to avoid an error.  */
16897 /* We use char because int might match the return type of a gcc2
16898     builtin and then its argument prototype would still apply.  */
16899 char $ac_func();
16900
16901 int main() {
16902
16903 /* The GNU C library defines this for functions which it implements
16904     to always fail with ENOSYS.  Some functions are actually named
16905     something starting with __ and the normal name is an alias.  */
16906 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16907 choke me
16908 #else
16909 $ac_func();
16910 #endif
16911
16912 ; return 0; }
16913 EOF
16914 if { (eval echo configure:16915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16915   rm -rf conftest*
16916   eval "ac_cv_func_$ac_func=yes"
16917 else
16918   echo "configure: failed program was:" >&5
16919   cat conftest.$ac_ext >&5
16920   rm -rf conftest*
16921   eval "ac_cv_func_$ac_func=no"
16922 fi
16923 rm -f conftest*
16924 fi
16925
16926 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16927   echo "$ac_t""yes" 1>&6
16928     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16929   cat >> confdefs.h <<EOF
16930 #define $ac_tr_func 1
16931 EOF
16932
16933 else
16934   echo "$ac_t""no" 1>&6
16935 fi
16936 done
16937
16938   fi
16939
16940
16941   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
16942 echo "configure:16943: checking for _finitel declaration" >&5
16943   if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
16944   echo $ac_n "(cached) $ac_c" 1>&6
16945 else
16946
16947
16948     ac_ext=C
16949 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16950 ac_cpp='$CXXCPP $CPPFLAGS'
16951 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16952 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16953 cross_compiling=$ac_cv_prog_cxx_cross
16954
16955     cat > conftest.$ac_ext <<EOF
16956 #line 16957 "configure"
16957 #include "confdefs.h"
16958 #include <math.h>
16959 int main() {
16960  _finitel(0);
16961 ; return 0; }
16962 EOF
16963 if { (eval echo configure:16964: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16964   rm -rf conftest*
16965   glibcpp_cv_func__finitel_use=yes
16966 else
16967   echo "configure: failed program was:" >&5
16968   cat conftest.$ac_ext >&5
16969   rm -rf conftest*
16970   glibcpp_cv_func__finitel_use=no
16971 fi
16972 rm -f conftest*
16973     ac_ext=c
16974 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16975 ac_cpp='$CPP $CPPFLAGS'
16976 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16977 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16978 cross_compiling=$ac_cv_prog_cc_cross
16979
16980
16981 fi
16982
16983   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
16984   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
16985     for ac_func in _finitel
16986 do
16987 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16988 echo "configure:16989: checking for $ac_func" >&5
16989 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16990   echo $ac_n "(cached) $ac_c" 1>&6
16991 else
16992   cat > conftest.$ac_ext <<EOF
16993 #line 16994 "configure"
16994 #include "confdefs.h"
16995 /* System header to define __stub macros and hopefully few prototypes,
16996     which can conflict with char $ac_func(); below.  */
16997 #include <assert.h>
16998 /* Override any gcc2 internal prototype to avoid an error.  */
16999 /* We use char because int might match the return type of a gcc2
17000     builtin and then its argument prototype would still apply.  */
17001 char $ac_func();
17002
17003 int main() {
17004
17005 /* The GNU C library defines this for functions which it implements
17006     to always fail with ENOSYS.  Some functions are actually named
17007     something starting with __ and the normal name is an alias.  */
17008 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17009 choke me
17010 #else
17011 $ac_func();
17012 #endif
17013
17014 ; return 0; }
17015 EOF
17016 if { (eval echo configure:17017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17017   rm -rf conftest*
17018   eval "ac_cv_func_$ac_func=yes"
17019 else
17020   echo "configure: failed program was:" >&5
17021   cat conftest.$ac_ext >&5
17022   rm -rf conftest*
17023   eval "ac_cv_func_$ac_func=no"
17024 fi
17025 rm -f conftest*
17026 fi
17027
17028 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17029   echo "$ac_t""yes" 1>&6
17030     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17031   cat >> confdefs.h <<EOF
17032 #define $ac_tr_func 1
17033 EOF
17034
17035 else
17036   echo "$ac_t""no" 1>&6
17037 fi
17038 done
17039
17040   fi
17041
17042
17043   LIBS="$ac_save_LIBS"
17044   CXXFLAGS="$ac_save_CXXFLAGS"
17045
17046
17047     for ac_hdr in complex.h
17048 do
17049 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
17050 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
17051 echo "configure:17052: checking for $ac_hdr" >&5
17052 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17053   echo $ac_n "(cached) $ac_c" 1>&6
17054 else
17055   cat > conftest.$ac_ext <<EOF
17056 #line 17057 "configure"
17057 #include "confdefs.h"
17058 #include <$ac_hdr>
17059 EOF
17060 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17061 { (eval echo configure:17062: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17062 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17063 if test -z "$ac_err"; then
17064   rm -rf conftest*
17065   eval "ac_cv_header_$ac_safe=yes"
17066 else
17067   echo "$ac_err" >&5
17068   echo "configure: failed program was:" >&5
17069   cat conftest.$ac_ext >&5
17070   rm -rf conftest*
17071   eval "ac_cv_header_$ac_safe=no"
17072 fi
17073 rm -f conftest*
17074 fi
17075 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17076   echo "$ac_t""yes" 1>&6
17077     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
17078   cat >> confdefs.h <<EOF
17079 #define $ac_tr_hdr 1
17080 EOF
17081
17082 else
17083   echo "$ac_t""no" 1>&6
17084 fi
17085 done
17086
17087   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17088 echo "configure:17089: checking for main in -lm" >&5
17089 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17090 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17091   echo $ac_n "(cached) $ac_c" 1>&6
17092 else
17093   ac_save_LIBS="$LIBS"
17094 LIBS="-lm  $LIBS"
17095 cat > conftest.$ac_ext <<EOF
17096 #line 17097 "configure"
17097 #include "confdefs.h"
17098
17099 int main() {
17100 main()
17101 ; return 0; }
17102 EOF
17103 if { (eval echo configure:17104: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17104   rm -rf conftest*
17105   eval "ac_cv_lib_$ac_lib_var=yes"
17106 else
17107   echo "configure: failed program was:" >&5
17108   cat conftest.$ac_ext >&5
17109   rm -rf conftest*
17110   eval "ac_cv_lib_$ac_lib_var=no"
17111 fi
17112 rm -f conftest*
17113 LIBS="$ac_save_LIBS"
17114
17115 fi
17116 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
17117   echo "$ac_t""yes" 1>&6
17118     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
17119     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
17120   cat >> confdefs.h <<EOF
17121 #define $ac_tr_lib 1
17122 EOF
17123
17124   LIBS="-lm $LIBS"
17125
17126 else
17127   echo "$ac_t""no" 1>&6
17128 fi
17129
17130   for ac_func in cabs cabsf ccos ccosf ccosh ccoshf cexp cexpf \
17131   c_log c_logf clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt \
17132   csqrtf ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf \
17133   copysignf
17134 do
17135 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17136 echo "configure:17137: checking for $ac_func" >&5
17137 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17138   echo $ac_n "(cached) $ac_c" 1>&6
17139 else
17140   cat > conftest.$ac_ext <<EOF
17141 #line 17142 "configure"
17142 #include "confdefs.h"
17143 /* System header to define __stub macros and hopefully few prototypes,
17144     which can conflict with char $ac_func(); below.  */
17145 #include <assert.h>
17146 /* Override any gcc2 internal prototype to avoid an error.  */
17147 /* We use char because int might match the return type of a gcc2
17148     builtin and then its argument prototype would still apply.  */
17149 char $ac_func();
17150
17151 int main() {
17152
17153 /* The GNU C library defines this for functions which it implements
17154     to always fail with ENOSYS.  Some functions are actually named
17155     something starting with __ and the normal name is an alias.  */
17156 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17157 choke me
17158 #else
17159 $ac_func();
17160 #endif
17161
17162 ; return 0; }
17163 EOF
17164 if { (eval echo configure:17165: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17165   rm -rf conftest*
17166   eval "ac_cv_func_$ac_func=yes"
17167 else
17168   echo "configure: failed program was:" >&5
17169   cat conftest.$ac_ext >&5
17170   rm -rf conftest*
17171   eval "ac_cv_func_$ac_func=no"
17172 fi
17173 rm -f conftest*
17174 fi
17175
17176 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17177   echo "$ac_t""yes" 1>&6
17178     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17179   cat >> confdefs.h <<EOF
17180 #define $ac_tr_func 1
17181 EOF
17182
17183 else
17184   echo "$ac_t""no" 1>&6
17185 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17186 fi
17187 done
17188
17189
17190
17191           USE_COMPLEX_LONG_DOUBLE=no
17192   if test x$ac_cv_func_atan2l = x"yes" \
17193      && test x$ac_cv_func_copysignl = x"yes"; then
17194     USE_COMPLEX_LONG_DOUBLE=yes
17195     for ac_func in cabsl ccoshl ccosl cexpl cpowl csinhl csinl \
17196     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
17197 do
17198 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17199 echo "configure:17200: checking for $ac_func" >&5
17200 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17201   echo $ac_n "(cached) $ac_c" 1>&6
17202 else
17203   cat > conftest.$ac_ext <<EOF
17204 #line 17205 "configure"
17205 #include "confdefs.h"
17206 /* System header to define __stub macros and hopefully few prototypes,
17207     which can conflict with char $ac_func(); below.  */
17208 #include <assert.h>
17209 /* Override any gcc2 internal prototype to avoid an error.  */
17210 /* We use char because int might match the return type of a gcc2
17211     builtin and then its argument prototype would still apply.  */
17212 char $ac_func();
17213
17214 int main() {
17215
17216 /* The GNU C library defines this for functions which it implements
17217     to always fail with ENOSYS.  Some functions are actually named
17218     something starting with __ and the normal name is an alias.  */
17219 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17220 choke me
17221 #else
17222 $ac_func();
17223 #endif
17224
17225 ; return 0; }
17226 EOF
17227 if { (eval echo configure:17228: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17228   rm -rf conftest*
17229   eval "ac_cv_func_$ac_func=yes"
17230 else
17231   echo "configure: failed program was:" >&5
17232   cat conftest.$ac_ext >&5
17233   rm -rf conftest*
17234   eval "ac_cv_func_$ac_func=no"
17235 fi
17236 rm -f conftest*
17237 fi
17238
17239 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17240   echo "$ac_t""yes" 1>&6
17241     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17242   cat >> confdefs.h <<EOF
17243 #define $ac_tr_func 1
17244 EOF
17245
17246 else
17247   echo "$ac_t""no" 1>&6
17248 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
17249 fi
17250 done
17251
17252
17253   fi
17254
17255
17256
17257
17258
17259
17260   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
17261 echo "configure:17262: checking for GNU C++ __complex__ support" >&5
17262   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
17263   echo $ac_n "(cached) $ac_c" 1>&6
17264 else
17265
17266
17267     ac_ext=C
17268 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17269 ac_cpp='$CXXCPP $CPPFLAGS'
17270 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17271 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17272 cross_compiling=$ac_cv_prog_cxx_cross
17273
17274     cat > conftest.$ac_ext <<EOF
17275 #line 17276 "configure"
17276 #include "confdefs.h"
17277 struct dcomplex { __complex__ double x; }; \
17278                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
17279 int main() {
17280 \
17281                      dcomplex x; f(x);
17282 ; return 0; }
17283 EOF
17284 if { (eval echo configure:17285: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17285   rm -rf conftest*
17286   glibcpp_cv_complex=ok
17287 else
17288   echo "configure: failed program was:" >&5
17289   cat conftest.$ac_ext >&5
17290   rm -rf conftest*
17291   glibcpp_cv_complex=buggy
17292
17293 fi
17294 rm -f conftest*
17295     ac_ext=c
17296 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17297 ac_cpp='$CPP $CPPFLAGS'
17298 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17299 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17300 cross_compiling=$ac_cv_prog_cc_cross
17301
17302
17303 fi
17304
17305   echo "$ac_t""$glibcpp_cv_complex" 1>&6
17306   if test $glibcpp_cv_complex = buggy; then
17307     cat >> confdefs.h <<\EOF
17308 #define _GLIBCPP_BUGGY_COMPLEX 1
17309 EOF
17310
17311   fi
17312
17313   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
17314 echo "configure:17315: checking for GNU C++ __complex__ float support" >&5
17315   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
17316   echo $ac_n "(cached) $ac_c" 1>&6
17317 else
17318
17319
17320     ac_ext=C
17321 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17322 ac_cpp='$CXXCPP $CPPFLAGS'
17323 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17324 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17325 cross_compiling=$ac_cv_prog_cxx_cross
17326
17327     rm -f conftest.h
17328     cat > conftest.h <<EOB
17329       //
17330       // Check for buggy __complex__ that causes ICE in most versions of egcs
17331       // and gcc-2.95.x on certain platforms (eg., x86-win32).
17332       //
17333       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
17334       // more info on the bug itself.
17335       //
17336       struct
17337       float_complex
17338       {
17339        __complex__ float m_value;
17340        float_complex (float = 0.0f, float = 0.0f);
17341        float_complex (__complex__ float val) : m_value (val) {}
17342        float_complex foo (const float_complex &val)
17343          { return float_complex (~val.m_value); }
17344       };
17345 EOB
17346     cat > conftest.$ac_ext <<EOF
17347 #line 17348 "configure"
17348 #include "confdefs.h"
17349 #include "conftest.h"
17350 int main() {
17351
17352 ; return 0; }
17353 EOF
17354 if { (eval echo configure:17355: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17355   rm -rf conftest*
17356   glibcpp_cv_float_complex=ok
17357 else
17358   echo "configure: failed program was:" >&5
17359   cat conftest.$ac_ext >&5
17360   rm -rf conftest*
17361   glibcpp_cv_float_complex=buggy
17362
17363 fi
17364 rm -f conftest*
17365     ac_ext=c
17366 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17367 ac_cpp='$CPP $CPPFLAGS'
17368 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17369 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17370 cross_compiling=$ac_cv_prog_cc_cross
17371
17372
17373 fi
17374
17375   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
17376   if test $glibcpp_cv_float_complex = buggy; then
17377     cat >> confdefs.h <<\EOF
17378 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
17379 EOF
17380
17381   fi
17382
17383
17384   if test x$enable_c_mbchar != xno; then
17385
17386         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
17387 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
17388 echo "configure:17389: checking for wchar.h" >&5
17389 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17390   echo $ac_n "(cached) $ac_c" 1>&6
17391 else
17392   cat > conftest.$ac_ext <<EOF
17393 #line 17394 "configure"
17394 #include "confdefs.h"
17395 #include <wchar.h>
17396 EOF
17397 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17398 { (eval echo configure:17399: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17399 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17400 if test -z "$ac_err"; then
17401   rm -rf conftest*
17402   eval "ac_cv_header_$ac_safe=yes"
17403 else
17404   echo "$ac_err" >&5
17405   echo "configure: failed program was:" >&5
17406   cat conftest.$ac_ext >&5
17407   rm -rf conftest*
17408   eval "ac_cv_header_$ac_safe=no"
17409 fi
17410 rm -f conftest*
17411 fi
17412 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17413   echo "$ac_t""yes" 1>&6
17414   ac_has_wchar_h=yes
17415 else
17416   echo "$ac_t""no" 1>&6
17417 ac_has_wchar_h=no
17418 fi
17419
17420     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
17421 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
17422 echo "configure:17423: checking for wctype.h" >&5
17423 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17424   echo $ac_n "(cached) $ac_c" 1>&6
17425 else
17426   cat > conftest.$ac_ext <<EOF
17427 #line 17428 "configure"
17428 #include "confdefs.h"
17429 #include <wctype.h>
17430 EOF
17431 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17432 { (eval echo configure:17433: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17433 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17434 if test -z "$ac_err"; then
17435   rm -rf conftest*
17436   eval "ac_cv_header_$ac_safe=yes"
17437 else
17438   echo "$ac_err" >&5
17439   echo "configure: failed program was:" >&5
17440   cat conftest.$ac_ext >&5
17441   rm -rf conftest*
17442   eval "ac_cv_header_$ac_safe=no"
17443 fi
17444 rm -f conftest*
17445 fi
17446 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17447   echo "$ac_t""yes" 1>&6
17448   ac_has_wctype_h=yes
17449 else
17450   echo "$ac_t""no" 1>&6
17451 ac_has_wctype_h=no
17452 fi
17453
17454
17455         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
17456
17457                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
17458 echo "configure:17459: checking for mbstate_t" >&5
17459       cat > conftest.$ac_ext <<EOF
17460 #line 17461 "configure"
17461 #include "confdefs.h"
17462 #include <wchar.h>
17463 int main() {
17464 mbstate_t teststate;
17465 ; return 0; }
17466 EOF
17467 if { (eval echo configure:17468: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17468   rm -rf conftest*
17469   use_native_mbstatet=yes
17470 else
17471   echo "configure: failed program was:" >&5
17472   cat conftest.$ac_ext >&5
17473   rm -rf conftest*
17474   use_native_mbstatet=no
17475 fi
17476 rm -f conftest*
17477       echo "$ac_t""$use_native_mbstatet" 1>&6
17478       if test x"$use_native_mbstatet" = xno; then
17479         cat >> confdefs.h <<\EOF
17480 #define _GLIBCPP_NEED_MBSTATE_T 1
17481 EOF
17482
17483       fi
17484
17485                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
17486 echo "configure:17487: checking for WCHAR_MIN and WCHAR_MAX" >&5
17487       cat > conftest.$ac_ext <<EOF
17488 #line 17489 "configure"
17489 #include "confdefs.h"
17490 #include <wchar.h>
17491 int main() {
17492 int i = WCHAR_MIN; int j = WCHAR_MAX;
17493 ; return 0; }
17494 EOF
17495 if { (eval echo configure:17496: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17496   rm -rf conftest*
17497   has_wchar_minmax=yes
17498 else
17499   echo "configure: failed program was:" >&5
17500   cat conftest.$ac_ext >&5
17501   rm -rf conftest*
17502   has_wchar_minmax=no
17503 fi
17504 rm -f conftest*
17505       echo "$ac_t""$has_wchar_minmax" 1>&6
17506
17507                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
17508 echo "configure:17509: checking for WEOF" >&5
17509       cat > conftest.$ac_ext <<EOF
17510 #line 17511 "configure"
17511 #include "confdefs.h"
17512
17513         #include <wchar.h>
17514         #include <stddef.h>
17515 int main() {
17516 wint_t i = WEOF;
17517 ; return 0; }
17518 EOF
17519 if { (eval echo configure:17520: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17520   rm -rf conftest*
17521   has_weof=yes
17522 else
17523   echo "configure: failed program was:" >&5
17524   cat conftest.$ac_ext >&5
17525   rm -rf conftest*
17526   has_weof=no
17527 fi
17528 rm -f conftest*
17529       echo "$ac_t""$has_weof" 1>&6
17530
17531             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
17532       wcsrtombs mbsrtowcs
17533 do
17534 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17535 echo "configure:17536: checking for $ac_func" >&5
17536 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17537   echo $ac_n "(cached) $ac_c" 1>&6
17538 else
17539   cat > conftest.$ac_ext <<EOF
17540 #line 17541 "configure"
17541 #include "confdefs.h"
17542 /* System header to define __stub macros and hopefully few prototypes,
17543     which can conflict with char $ac_func(); below.  */
17544 #include <assert.h>
17545 /* Override any gcc2 internal prototype to avoid an error.  */
17546 /* We use char because int might match the return type of a gcc2
17547     builtin and then its argument prototype would still apply.  */
17548 char $ac_func();
17549
17550 int main() {
17551
17552 /* The GNU C library defines this for functions which it implements
17553     to always fail with ENOSYS.  Some functions are actually named
17554     something starting with __ and the normal name is an alias.  */
17555 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17556 choke me
17557 #else
17558 $ac_func();
17559 #endif
17560
17561 ; return 0; }
17562 EOF
17563 if { (eval echo configure:17564: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17564   rm -rf conftest*
17565   eval "ac_cv_func_$ac_func=yes"
17566 else
17567   echo "configure: failed program was:" >&5
17568   cat conftest.$ac_ext >&5
17569   rm -rf conftest*
17570   eval "ac_cv_func_$ac_func=no"
17571 fi
17572 rm -f conftest*
17573 fi
17574
17575 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17576   echo "$ac_t""yes" 1>&6
17577     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17578   cat >> confdefs.h <<EOF
17579 #define $ac_tr_func 1
17580 EOF
17581  ac_wfuncs=yes
17582 else
17583   echo "$ac_t""no" 1>&6
17584 ac_wfuncs=no
17585 fi
17586 done
17587
17588
17589       echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
17590 echo "configure:17591: checking for ISO C9X wchar_t support" >&5
17591       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
17592          && test x"$ac_wfuncs" = xyes; then
17593         ac_isoC9X_wchar_t=yes
17594       else
17595         ac_isoC9X_wchar_t=no
17596       fi
17597       echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
17598
17599                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
17600 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
17601 echo "configure:17602: checking for iconv.h" >&5
17602 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17603   echo $ac_n "(cached) $ac_c" 1>&6
17604 else
17605   cat > conftest.$ac_ext <<EOF
17606 #line 17607 "configure"
17607 #include "confdefs.h"
17608 #include <iconv.h>
17609 EOF
17610 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17611 { (eval echo configure:17612: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17612 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17613 if test -z "$ac_err"; then
17614   rm -rf conftest*
17615   eval "ac_cv_header_$ac_safe=yes"
17616 else
17617   echo "$ac_err" >&5
17618   echo "configure: failed program was:" >&5
17619   cat conftest.$ac_ext >&5
17620   rm -rf conftest*
17621   eval "ac_cv_header_$ac_safe=no"
17622 fi
17623 rm -f conftest*
17624 fi
17625 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17626   echo "$ac_t""yes" 1>&6
17627   ac_has_iconv_h=yes
17628 else
17629   echo "$ac_t""no" 1>&6
17630 ac_has_iconv_h=no
17631 fi
17632
17633       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
17634 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
17635 echo "configure:17636: checking for langinfo.h" >&5
17636 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17637   echo $ac_n "(cached) $ac_c" 1>&6
17638 else
17639   cat > conftest.$ac_ext <<EOF
17640 #line 17641 "configure"
17641 #include "confdefs.h"
17642 #include <langinfo.h>
17643 EOF
17644 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17645 { (eval echo configure:17646: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17646 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17647 if test -z "$ac_err"; then
17648   rm -rf conftest*
17649   eval "ac_cv_header_$ac_safe=yes"
17650 else
17651   echo "$ac_err" >&5
17652   echo "configure: failed program was:" >&5
17653   cat conftest.$ac_ext >&5
17654   rm -rf conftest*
17655   eval "ac_cv_header_$ac_safe=no"
17656 fi
17657 rm -f conftest*
17658 fi
17659 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17660   echo "$ac_t""yes" 1>&6
17661   ac_has_langinfo_h=yes
17662 else
17663   echo "$ac_t""no" 1>&6
17664 ac_has_langinfo_h=no
17665 fi
17666
17667       for ac_func in iconv_open iconv_close iconv nl_langinfo
17668 do
17669 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17670 echo "configure:17671: checking for $ac_func" >&5
17671 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17672   echo $ac_n "(cached) $ac_c" 1>&6
17673 else
17674   cat > conftest.$ac_ext <<EOF
17675 #line 17676 "configure"
17676 #include "confdefs.h"
17677 /* System header to define __stub macros and hopefully few prototypes,
17678     which can conflict with char $ac_func(); below.  */
17679 #include <assert.h>
17680 /* Override any gcc2 internal prototype to avoid an error.  */
17681 /* We use char because int might match the return type of a gcc2
17682     builtin and then its argument prototype would still apply.  */
17683 char $ac_func();
17684
17685 int main() {
17686
17687 /* The GNU C library defines this for functions which it implements
17688     to always fail with ENOSYS.  Some functions are actually named
17689     something starting with __ and the normal name is an alias.  */
17690 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17691 choke me
17692 #else
17693 $ac_func();
17694 #endif
17695
17696 ; return 0; }
17697 EOF
17698 if { (eval echo configure:17699: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17699   rm -rf conftest*
17700   eval "ac_cv_func_$ac_func=yes"
17701 else
17702   echo "configure: failed program was:" >&5
17703   cat conftest.$ac_ext >&5
17704   rm -rf conftest*
17705   eval "ac_cv_func_$ac_func=no"
17706 fi
17707 rm -f conftest*
17708 fi
17709
17710 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17711   echo "$ac_t""yes" 1>&6
17712     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17713   cat >> confdefs.h <<EOF
17714 #define $ac_tr_func 1
17715 EOF
17716  \
17717       ac_XPG2funcs=yes
17718 else
17719   echo "$ac_t""no" 1>&6
17720 ac_XPG2funcs=no
17721 fi
17722 done
17723
17724
17725       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
17726 echo "configure:17727: checking for XPG2 wchar_t support" >&5
17727       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
17728          && test x"$ac_XPG2funcs" = xyes; then
17729         ac_XPG2_wchar_t=yes
17730       else
17731         ac_XPG2_wchar_t=no
17732       fi
17733       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
17734
17735                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
17736 echo "configure:17737: checking for enabled wchar_t specializations" >&5
17737       if test x"$ac_isoC9X_wchar_t" = xyes \
17738          && test x"$ac_XPG2_wchar_t" = xyes; then
17739         libinst_wstring_la="libinst-wstring.la"
17740         cat >> confdefs.h <<\EOF
17741 #define _GLIBCPP_USE_WCHAR_T 1
17742 EOF
17743
17744         echo "$ac_t"""yes"" 1>&6
17745       else
17746         libinst_wstring_la=""
17747         echo "$ac_t"""no"" 1>&6
17748       fi
17749
17750
17751     else
17752       echo "configure: warning: <wchar.h> not found" 1>&2
17753       cat >> confdefs.h <<\EOF
17754 #define _GLIBCPP_NEED_MBSTATE_T 1
17755 EOF
17756
17757     fi
17758
17759   else
17760         :
17761   fi
17762
17763
17764   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
17765 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
17766 echo "configure:17767: checking for ctype.h" >&5
17767 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
17768   echo $ac_n "(cached) $ac_c" 1>&6
17769 else
17770   cat > conftest.$ac_ext <<EOF
17771 #line 17772 "configure"
17772 #include "confdefs.h"
17773 #include <ctype.h>
17774 EOF
17775 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
17776 { (eval echo configure:17777: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
17777 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
17778 if test -z "$ac_err"; then
17779   rm -rf conftest*
17780   eval "ac_cv_header_$ac_safe=yes"
17781 else
17782   echo "$ac_err" >&5
17783   echo "configure: failed program was:" >&5
17784   cat conftest.$ac_ext >&5
17785   rm -rf conftest*
17786   eval "ac_cv_header_$ac_safe=no"
17787 fi
17788 rm -f conftest*
17789 fi
17790 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
17791   echo "$ac_t""yes" 1>&6
17792
17793
17794         ctype_default=yes
17795
17796         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
17797 echo "configure:17798: checking <ctype> for GNU/Linux" >&5
17798     cat > conftest.$ac_ext <<EOF
17799 #line 17800 "configure"
17800 #include "confdefs.h"
17801 #include <ctype.h>
17802 int main() {
17803 int
17804     foo (int a)
17805     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
17806         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
17807         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
17808 ; return 0; }
17809 EOF
17810 if { (eval echo configure:17811: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17811   rm -rf conftest*
17812   \
17813     ctype_linux=yes
17814 else
17815   echo "configure: failed program was:" >&5
17816   cat conftest.$ac_ext >&5
17817   rm -rf conftest*
17818   ctype_linux=no
17819 fi
17820 rm -f conftest*
17821     echo "$ac_t""$ctype_linux" 1>&6
17822     if test $ctype_linux = "yes"; then
17823       ctype_include_dir="config/os/gnu-linux"
17824       ctype_default=no
17825     fi
17826
17827         if test $ctype_default = "yes"; then
17828     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
17829 echo "configure:17830: checking <ctype> for FreeBSD 4.0" >&5
17830     cat > conftest.$ac_ext <<EOF
17831 #line 17832 "configure"
17832 #include "confdefs.h"
17833 #include <ctype.h>
17834 int main() {
17835 int
17836     foo (int a)
17837     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
17838         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
17839 ; return 0; }
17840 EOF
17841 if { (eval echo configure:17842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17842   rm -rf conftest*
17843   \
17844     ctype_bsd=yes
17845 else
17846   echo "configure: failed program was:" >&5
17847   cat conftest.$ac_ext >&5
17848   rm -rf conftest*
17849   ctype_bsd=no
17850 fi
17851 rm -f conftest*
17852     echo "$ac_t""$ctype_bsd" 1>&6
17853     if test $ctype_bsd = "yes"; then
17854       ctype_include_dir="config/os/bsd"
17855       ctype_default=no
17856     fi
17857     fi
17858
17859         if test $ctype_default = "yes"; then
17860     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
17861 echo "configure:17862: checking <ctype> for FreeBSD 3.4" >&5
17862     cat > conftest.$ac_ext <<EOF
17863 #line 17864 "configure"
17864 #include "confdefs.h"
17865 #include <ctype.h>
17866 int main() {
17867 int
17868     foo (int a)
17869     { return _S + _R + _C + _U + _L + _A \
17870       + _D + _P + _X + _G + __istype (a, 0);}
17871 ; return 0; }
17872 EOF
17873 if { (eval echo configure:17874: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17874   rm -rf conftest*
17875   \
17876     ctype_freebsd34=yes
17877 else
17878   echo "configure: failed program was:" >&5
17879   cat conftest.$ac_ext >&5
17880   rm -rf conftest*
17881   ctype_freebsd34=no
17882 fi
17883 rm -f conftest*
17884     echo "$ac_t""$ctype_freebsd34" 1>&6
17885     if test $ctype_freebsd34 = "yes"; then
17886       ctype_include_dir="config/os/bsd"
17887       ctype_default=no
17888     fi
17889     fi
17890
17891         if test $ctype_default = "yes"; then
17892     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
17893 echo "configure:17894: checking <ctype> for Solaris 2.6,7,8" >&5
17894     cat > conftest.$ac_ext <<EOF
17895 #line 17896 "configure"
17896 #include "confdefs.h"
17897 #include <ctype.h>
17898 int main() {
17899 int
17900     foo (int a)
17901     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
17902         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
17903         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
17904 ; return 0; }
17905 EOF
17906 if { (eval echo configure:17907: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17907   rm -rf conftest*
17908   \
17909     ctype_solaris=yes
17910 else
17911   echo "configure: failed program was:" >&5
17912   cat conftest.$ac_ext >&5
17913   rm -rf conftest*
17914   ctype_solaris=no
17915 fi
17916 rm -f conftest*
17917     echo "$ac_t""$ctype_solaris" 1>&6
17918
17919     if test $ctype_solaris = "yes"; then
17920       echo $ac_n "checking   for version""... $ac_c" 1>&6
17921 echo "configure:17922: checking   for version" >&5
17922       ac_ext=C
17923 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17924 ac_cpp='$CXXCPP $CPPFLAGS'
17925 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17926 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17927 cross_compiling=$ac_cv_prog_cxx_cross
17928
17929       cat > conftest.$ac_ext <<EOF
17930 #line 17931 "configure"
17931 #include "confdefs.h"
17932 #include <ctype.h>
17933 int main() {
17934 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
17935 ; return 0; }
17936 EOF
17937 if { (eval echo configure:17938: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17938   rm -rf conftest*
17939   \
17940       ctype_solaris26=yes
17941 else
17942   echo "configure: failed program was:" >&5
17943   cat conftest.$ac_ext >&5
17944   rm -rf conftest*
17945   ctype_solaris26=no
17946 fi
17947 rm -f conftest*
17948       ac_ext=c
17949 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17950 ac_cpp='$CPP $CPPFLAGS'
17951 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17952 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17953 cross_compiling=$ac_cv_prog_cc_cross
17954
17955       if test $ctype_solaris26 = "yes"; then
17956         ctype_include_dir="config/os/solaris/solaris2.6"
17957         echo "$ac_t""Solaris 2.6" 1>&6
17958         ctype_default=no
17959       else
17960         ctype_include_dir="config/os/solaris/solaris2.7"
17961         echo "$ac_t""Solaris 7,8" 1>&6
17962         ctype_default=no
17963       fi
17964     fi
17965     fi
17966
17967         if test $ctype_default = "yes"; then
17968     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
17969 echo "configure:17970: checking <ctype> for Solaris 2.5.1" >&5
17970     cat > conftest.$ac_ext <<EOF
17971 #line 17972 "configure"
17972 #include "confdefs.h"
17973 #include <ctype.h>
17974 int main() {
17975 int
17976     foo (int a)
17977     { return _U + _L + _N + _S + _P + _C + _X + _B \
17978         + __ctype[a];}
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_solaris25=yes
17985 else
17986   echo "configure: failed program was:" >&5
17987   cat conftest.$ac_ext >&5
17988   rm -rf conftest*
17989   ctype_solaris25=no
17990 fi
17991 rm -f conftest*
17992     echo "$ac_t""$ctype_solaris25" 1>&6
17993     if test $ctype_solaris25 = "yes"; then
17994       ctype_include_dir="config/os/solaris/solaris2.5"
17995       ctype_default=no
17996     fi
17997     fi
17998
17999         if test $ctype_default = "yes"; then
18000     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
18001 echo "configure:18002: checking <ctype> for AIX" >&5
18002     cat > conftest.$ac_ext <<EOF
18003 #line 18004 "configure"
18004 #include "confdefs.h"
18005 #include <ctype.h>
18006 int main() {
18007 int
18008     foo (int a)
18009     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18010         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18011         + _VALC('a') + _IS('c', 0);}
18012 ; return 0; }
18013 EOF
18014 if { (eval echo configure:18015: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18015   rm -rf conftest*
18016   \
18017     ctype_aix=yes
18018 else
18019   echo "configure: failed program was:" >&5
18020   cat conftest.$ac_ext >&5
18021   rm -rf conftest*
18022   ctype_aix=no
18023 fi
18024 rm -f conftest*
18025     echo "$ac_t""$ctype_aix" 1>&6
18026     if test $ctype_aix = "yes"; then
18027       ctype_include_dir="config/os/aix"
18028       ctype_default=no
18029     fi
18030     fi
18031
18032         if test $ctype_default = "yes"; then
18033     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18034 echo "configure:18035: checking <ctype> for IRIX" >&5
18035     cat > conftest.$ac_ext <<EOF
18036 #line 18037 "configure"
18037 #include "confdefs.h"
18038 #include <ctype.h>
18039 int main() {
18040 int
18041     foo (int a)
18042     { return _U + _L + _N + _S + _P + _C + _B + _X + \
18043              _A + _PR + _G + _BL;}
18044 ; return 0; }
18045 EOF
18046 if { (eval echo configure:18047: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18047   rm -rf conftest*
18048   \
18049     ctype_irix=yes
18050 else
18051   echo "configure: failed program was:" >&5
18052   cat conftest.$ac_ext >&5
18053   rm -rf conftest*
18054   ctype_irix=no
18055 fi
18056 rm -f conftest*
18057     echo "$ac_t""$ctype_irix" 1>&6
18058     if test $ctype_irix = "yes"; then
18059       ctype_include_dir="config/os/irix"
18060       ctype_default=no
18061     fi
18062     fi
18063
18064         if test $ctype_default = "yes"; then
18065     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
18066 echo "configure:18067: checking <ctype> for newlib" >&5
18067     cat > conftest.$ac_ext <<EOF
18068 #line 18069 "configure"
18069 #include "confdefs.h"
18070 #include <ctype.h>
18071 int main() {
18072 int
18073     foo (int a)
18074     { return _U + _L + _N + _S + _P + _C + _X + _B \
18075         + _ctype_[a];}
18076 ; return 0; }
18077 EOF
18078 if { (eval echo configure:18079: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18079   rm -rf conftest*
18080   \
18081     ctype_newlib=yes
18082 else
18083   echo "configure: failed program was:" >&5
18084   cat conftest.$ac_ext >&5
18085   rm -rf conftest*
18086   ctype_newlib=no
18087 fi
18088 rm -f conftest*
18089     echo "$ac_t""$ctype_newlib" 1>&6
18090     if test $ctype_newlib = "yes"; then
18091       ctype_include_dir="config/newlib"
18092       ctype_default=no
18093     fi
18094     fi
18095
18096     if test $ctype_default = "yes"; then
18097       ctype_include_dir="config/os/generic"
18098       echo "configure: warning: "Using default ctype headers."" 1>&2
18099     fi
18100
18101
18102
18103
18104
18105 else
18106   echo "$ac_t""no" 1>&6
18107 fi
18108
18109
18110
18111   ac_test_CXXFLAGS="${CXXFLAGS+set}"
18112   ac_save_CXXFLAGS="$CXXFLAGS"
18113   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
18114
18115   for ac_func in strtof
18116 do
18117 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18118 echo "configure:18119: checking for $ac_func" >&5
18119 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18120   echo $ac_n "(cached) $ac_c" 1>&6
18121 else
18122   cat > conftest.$ac_ext <<EOF
18123 #line 18124 "configure"
18124 #include "confdefs.h"
18125 /* System header to define __stub macros and hopefully few prototypes,
18126     which can conflict with char $ac_func(); below.  */
18127 #include <assert.h>
18128 /* Override any gcc2 internal prototype to avoid an error.  */
18129 /* We use char because int might match the return type of a gcc2
18130     builtin and then its argument prototype would still apply.  */
18131 char $ac_func();
18132
18133 int main() {
18134
18135 /* The GNU C library defines this for functions which it implements
18136     to always fail with ENOSYS.  Some functions are actually named
18137     something starting with __ and the normal name is an alias.  */
18138 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18139 choke me
18140 #else
18141 $ac_func();
18142 #endif
18143
18144 ; return 0; }
18145 EOF
18146 if { (eval echo configure:18147: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18147   rm -rf conftest*
18148   eval "ac_cv_func_$ac_func=yes"
18149 else
18150   echo "configure: failed program was:" >&5
18151   cat conftest.$ac_ext >&5
18152   rm -rf conftest*
18153   eval "ac_cv_func_$ac_func=no"
18154 fi
18155 rm -f conftest*
18156 fi
18157
18158 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18159   echo "$ac_t""yes" 1>&6
18160     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18161   cat >> confdefs.h <<EOF
18162 #define $ac_tr_func 1
18163 EOF
18164
18165 else
18166   echo "$ac_t""no" 1>&6
18167 fi
18168 done
18169
18170
18171   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
18172 echo "configure:18173: checking for strtold declaration" >&5
18173   if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
18174   echo $ac_n "(cached) $ac_c" 1>&6
18175 else
18176
18177
18178     ac_ext=C
18179 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18180 ac_cpp='$CXXCPP $CPPFLAGS'
18181 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18182 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18183 cross_compiling=$ac_cv_prog_cxx_cross
18184
18185     cat > conftest.$ac_ext <<EOF
18186 #line 18187 "configure"
18187 #include "confdefs.h"
18188 #include <stdlib.h>
18189 int main() {
18190  strtold(0, 0);
18191 ; return 0; }
18192 EOF
18193 if { (eval echo configure:18194: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18194   rm -rf conftest*
18195   glibcpp_cv_func_strtold_use=yes
18196 else
18197   echo "configure: failed program was:" >&5
18198   cat conftest.$ac_ext >&5
18199   rm -rf conftest*
18200   glibcpp_cv_func_strtold_use=no
18201 fi
18202 rm -f conftest*
18203     ac_ext=c
18204 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18205 ac_cpp='$CPP $CPPFLAGS'
18206 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18207 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18208 cross_compiling=$ac_cv_prog_cc_cross
18209
18210
18211 fi
18212
18213   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
18214   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
18215     for ac_func in strtold
18216 do
18217 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18218 echo "configure:18219: checking for $ac_func" >&5
18219 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18220   echo $ac_n "(cached) $ac_c" 1>&6
18221 else
18222   cat > conftest.$ac_ext <<EOF
18223 #line 18224 "configure"
18224 #include "confdefs.h"
18225 /* System header to define __stub macros and hopefully few prototypes,
18226     which can conflict with char $ac_func(); below.  */
18227 #include <assert.h>
18228 /* Override any gcc2 internal prototype to avoid an error.  */
18229 /* We use char because int might match the return type of a gcc2
18230     builtin and then its argument prototype would still apply.  */
18231 char $ac_func();
18232
18233 int main() {
18234
18235 /* The GNU C library defines this for functions which it implements
18236     to always fail with ENOSYS.  Some functions are actually named
18237     something starting with __ and the normal name is an alias.  */
18238 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18239 choke me
18240 #else
18241 $ac_func();
18242 #endif
18243
18244 ; return 0; }
18245 EOF
18246 if { (eval echo configure:18247: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18247   rm -rf conftest*
18248   eval "ac_cv_func_$ac_func=yes"
18249 else
18250   echo "configure: failed program was:" >&5
18251   cat conftest.$ac_ext >&5
18252   rm -rf conftest*
18253   eval "ac_cv_func_$ac_func=no"
18254 fi
18255 rm -f conftest*
18256 fi
18257
18258 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18259   echo "$ac_t""yes" 1>&6
18260     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18261   cat >> confdefs.h <<EOF
18262 #define $ac_tr_func 1
18263 EOF
18264
18265 else
18266   echo "$ac_t""no" 1>&6
18267 fi
18268 done
18269
18270   fi
18271
18272
18273   CXXFLAGS="$ac_save_CXXFLAGS"
18274
18275
18276   for ac_hdr in unistd.h
18277 do
18278 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18279 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18280 echo "configure:18281: checking for $ac_hdr" >&5
18281 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18282   echo $ac_n "(cached) $ac_c" 1>&6
18283 else
18284   cat > conftest.$ac_ext <<EOF
18285 #line 18286 "configure"
18286 #include "confdefs.h"
18287 #include <$ac_hdr>
18288 EOF
18289 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18290 { (eval echo configure:18291: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18291 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18292 if test -z "$ac_err"; then
18293   rm -rf conftest*
18294   eval "ac_cv_header_$ac_safe=yes"
18295 else
18296   echo "$ac_err" >&5
18297   echo "configure: failed program was:" >&5
18298   cat conftest.$ac_ext >&5
18299   rm -rf conftest*
18300   eval "ac_cv_header_$ac_safe=no"
18301 fi
18302 rm -f conftest*
18303 fi
18304 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18305   echo "$ac_t""yes" 1>&6
18306     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18307   cat >> confdefs.h <<EOF
18308 #define $ac_tr_hdr 1
18309 EOF
18310
18311 else
18312   echo "$ac_t""no" 1>&6
18313 fi
18314 done
18315
18316 for ac_func in getpagesize
18317 do
18318 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18319 echo "configure:18320: checking for $ac_func" >&5
18320 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18321   echo $ac_n "(cached) $ac_c" 1>&6
18322 else
18323   cat > conftest.$ac_ext <<EOF
18324 #line 18325 "configure"
18325 #include "confdefs.h"
18326 /* System header to define __stub macros and hopefully few prototypes,
18327     which can conflict with char $ac_func(); below.  */
18328 #include <assert.h>
18329 /* Override any gcc2 internal prototype to avoid an error.  */
18330 /* We use char because int might match the return type of a gcc2
18331     builtin and then its argument prototype would still apply.  */
18332 char $ac_func();
18333
18334 int main() {
18335
18336 /* The GNU C library defines this for functions which it implements
18337     to always fail with ENOSYS.  Some functions are actually named
18338     something starting with __ and the normal name is an alias.  */
18339 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18340 choke me
18341 #else
18342 $ac_func();
18343 #endif
18344
18345 ; return 0; }
18346 EOF
18347 if { (eval echo configure:18348: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18348   rm -rf conftest*
18349   eval "ac_cv_func_$ac_func=yes"
18350 else
18351   echo "configure: failed program was:" >&5
18352   cat conftest.$ac_ext >&5
18353   rm -rf conftest*
18354   eval "ac_cv_func_$ac_func=no"
18355 fi
18356 rm -f conftest*
18357 fi
18358
18359 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18360   echo "$ac_t""yes" 1>&6
18361     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18362   cat >> confdefs.h <<EOF
18363 #define $ac_tr_func 1
18364 EOF
18365
18366 else
18367   echo "$ac_t""no" 1>&6
18368 fi
18369 done
18370
18371 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
18372 echo "configure:18373: checking for working mmap" >&5
18373 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
18374   echo $ac_n "(cached) $ac_c" 1>&6
18375 else
18376   if test "$cross_compiling" = yes; then
18377   ac_cv_func_mmap_fixed_mapped=no
18378 else
18379   cat > conftest.$ac_ext <<EOF
18380 #line 18381 "configure"
18381 #include "confdefs.h"
18382
18383 /* Thanks to Mike Haertel and Jim Avera for this test.
18384    Here is a matrix of mmap possibilities:
18385         mmap private not fixed
18386         mmap private fixed at somewhere currently unmapped
18387         mmap private fixed at somewhere already mapped
18388         mmap shared not fixed
18389         mmap shared fixed at somewhere currently unmapped
18390         mmap shared fixed at somewhere already mapped
18391    For private mappings, we should verify that changes cannot be read()
18392    back from the file, nor mmap's back from the file at a different
18393    address.  (There have been systems where private was not correctly
18394    implemented like the infamous i386 svr4.0, and systems where the
18395    VM page cache was not coherent with the filesystem buffer cache
18396    like early versions of FreeBSD and possibly contemporary NetBSD.)
18397    For shared mappings, we should conversely verify that changes get
18398    propogated back to all the places they're supposed to be.
18399
18400    Grep wants private fixed already mapped.
18401    The main things grep needs to know about mmap are:
18402    * does it exist and is it safe to write into the mmap'd area
18403    * how to use it (BSD variants)  */
18404 #include <sys/types.h>
18405 #include <fcntl.h>
18406 #include <sys/mman.h>
18407
18408 /* This mess was copied from the GNU getpagesize.h.  */
18409 #ifndef HAVE_GETPAGESIZE
18410 # ifdef HAVE_UNISTD_H
18411 #  include <unistd.h>
18412 # endif
18413
18414 /* Assume that all systems that can run configure have sys/param.h.  */
18415 # ifndef HAVE_SYS_PARAM_H
18416 #  define HAVE_SYS_PARAM_H 1
18417 # endif
18418
18419 # ifdef _SC_PAGESIZE
18420 #  define getpagesize() sysconf(_SC_PAGESIZE)
18421 # else /* no _SC_PAGESIZE */
18422 #  ifdef HAVE_SYS_PARAM_H
18423 #   include <sys/param.h>
18424 #   ifdef EXEC_PAGESIZE
18425 #    define getpagesize() EXEC_PAGESIZE
18426 #   else /* no EXEC_PAGESIZE */
18427 #    ifdef NBPG
18428 #     define getpagesize() NBPG * CLSIZE
18429 #     ifndef CLSIZE
18430 #      define CLSIZE 1
18431 #     endif /* no CLSIZE */
18432 #    else /* no NBPG */
18433 #     ifdef NBPC
18434 #      define getpagesize() NBPC
18435 #     else /* no NBPC */
18436 #      ifdef PAGESIZE
18437 #       define getpagesize() PAGESIZE
18438 #      endif /* PAGESIZE */
18439 #     endif /* no NBPC */
18440 #    endif /* no NBPG */
18441 #   endif /* no EXEC_PAGESIZE */
18442 #  else /* no HAVE_SYS_PARAM_H */
18443 #   define getpagesize() 8192   /* punt totally */
18444 #  endif /* no HAVE_SYS_PARAM_H */
18445 # endif /* no _SC_PAGESIZE */
18446
18447 #endif /* no HAVE_GETPAGESIZE */
18448
18449 #ifdef __cplusplus
18450 extern "C" { void *malloc(unsigned); }
18451 #else
18452 char *malloc();
18453 #endif
18454
18455 int
18456 main()
18457 {
18458         char *data, *data2, *data3;
18459         int i, pagesize;
18460         int fd;
18461
18462         pagesize = getpagesize();
18463
18464         /*
18465          * First, make a file with some known garbage in it.
18466          */
18467         data = malloc(pagesize);
18468         if (!data)
18469                 exit(1);
18470         for (i = 0; i < pagesize; ++i)
18471                 *(data + i) = rand();
18472         umask(0);
18473         fd = creat("conftestmmap", 0600);
18474         if (fd < 0)
18475                 exit(1);
18476         if (write(fd, data, pagesize) != pagesize)
18477                 exit(1);
18478         close(fd);
18479
18480         /*
18481          * Next, try to mmap the file at a fixed address which
18482          * already has something else allocated at it.  If we can,
18483          * also make sure that we see the same garbage.
18484          */
18485         fd = open("conftestmmap", O_RDWR);
18486         if (fd < 0)
18487                 exit(1);
18488         data2 = malloc(2 * pagesize);
18489         if (!data2)
18490                 exit(1);
18491         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
18492         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
18493             MAP_PRIVATE | MAP_FIXED, fd, 0L))
18494                 exit(1);
18495         for (i = 0; i < pagesize; ++i)
18496                 if (*(data + i) != *(data2 + i))
18497                         exit(1);
18498
18499         /*
18500          * Finally, make sure that changes to the mapped area
18501          * do not percolate back to the file as seen by read().
18502          * (This is a bug on some variants of i386 svr4.0.)
18503          */
18504         for (i = 0; i < pagesize; ++i)
18505                 *(data2 + i) = *(data2 + i) + 1;
18506         data3 = malloc(pagesize);
18507         if (!data3)
18508                 exit(1);
18509         if (read(fd, data3, pagesize) != pagesize)
18510                 exit(1);
18511         for (i = 0; i < pagesize; ++i)
18512                 if (*(data + i) != *(data3 + i))
18513                         exit(1);
18514         close(fd);
18515         unlink("conftestmmap");
18516         exit(0);
18517 }
18518
18519 EOF
18520 if { (eval echo configure:18521: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
18521 then
18522   ac_cv_func_mmap_fixed_mapped=yes
18523 else
18524   echo "configure: failed program was:" >&5
18525   cat conftest.$ac_ext >&5
18526   rm -fr conftest*
18527   ac_cv_func_mmap_fixed_mapped=no
18528 fi
18529 rm -fr conftest*
18530 fi
18531
18532 fi
18533
18534 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
18535 if test $ac_cv_func_mmap_fixed_mapped = yes; then
18536   cat >> confdefs.h <<\EOF
18537 #define HAVE_MMAP 1
18538 EOF
18539
18540 fi
18541
18542 fi
18543
18544
18545
18546 if test "$CANADIAN" = yes; then
18547   CANADIAN_TRUE=
18548   CANADIAN_FALSE='#'
18549 else
18550   CANADIAN_TRUE='#'
18551   CANADIAN_FALSE=
18552 fi
18553
18554
18555 if test "$NULL_TARGET" = yes; then
18556   NULL_TARGET_TRUE=
18557   NULL_TARGET_FALSE='#'
18558 else
18559   NULL_TARGET_TRUE='#'
18560   NULL_TARGET_FALSE=
18561 fi
18562
18563
18564 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
18565   NATIVE_TRUE=
18566   NATIVE_FALSE='#'
18567 else
18568   NATIVE_TRUE='#'
18569   NATIVE_FALSE=
18570 fi
18571
18572
18573 if test -z "$with_cross_host"; then
18574   USE_LIBDIR_TRUE=
18575   USE_LIBDIR_FALSE='#'
18576 else
18577   USE_LIBDIR_TRUE='#'
18578   USE_LIBDIR_FALSE=
18579 fi
18580
18581 cat > confcache <<\EOF
18582 # This file is a shell script that caches the results of configure
18583 # tests run on this system so they can be shared between configure
18584 # scripts and configure runs.  It is not useful on other systems.
18585 # If it contains results you don't want to keep, you may remove or edit it.
18586 #
18587 # By default, configure uses ./config.cache as the cache file,
18588 # creating it if it does not exist already.  You can give configure
18589 # the --cache-file=FILE option to use a different cache file; that is
18590 # what configure does when it calls configure scripts in
18591 # subdirectories, so they share the cache.
18592 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18593 # config.status only pays attention to the cache file if you give it the
18594 # --recheck option to rerun configure.
18595 #
18596 EOF
18597 # The following way of writing the cache mishandles newlines in values,
18598 # but we know of no workaround that is simple, portable, and efficient.
18599 # So, don't put newlines in cache variables' values.
18600 # Ultrix sh set writes to stderr and can't be redirected directly,
18601 # and sets the high bit in the cache file unless we assign to the vars.
18602 (set) 2>&1 |
18603   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18604   *ac_space=\ *)
18605     # `set' does not quote correctly, so add quotes (double-quote substitution
18606     # turns \\\\ into \\, and sed turns \\ into \).
18607     sed -n \
18608       -e "s/'/'\\\\''/g" \
18609       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18610     ;;
18611   *)
18612     # `set' quotes correctly as required by POSIX, so do not add quotes.
18613     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18614     ;;
18615   esac >> confcache
18616 if cmp -s $cache_file confcache; then
18617   :
18618 else
18619   if test -w $cache_file; then
18620     echo "updating cache $cache_file"
18621     cat confcache > $cache_file
18622   else
18623     echo "not updating unwritable cache $cache_file"
18624   fi
18625 fi
18626 rm -f confcache
18627
18628 if test $ac_cv_header_locale_h = yes; then
18629     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
18630 echo "configure:18631: checking for LC_MESSAGES" >&5
18631 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
18632   echo $ac_n "(cached) $ac_c" 1>&6
18633 else
18634   cat > conftest.$ac_ext <<EOF
18635 #line 18636 "configure"
18636 #include "confdefs.h"
18637 #include <locale.h>
18638 int main() {
18639 return LC_MESSAGES
18640 ; return 0; }
18641 EOF
18642 if { (eval echo configure:18643: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18643   rm -rf conftest*
18644   ac_cv_val_LC_MESSAGES=yes
18645 else
18646   echo "configure: failed program was:" >&5
18647   cat conftest.$ac_ext >&5
18648   rm -rf conftest*
18649   ac_cv_val_LC_MESSAGES=no
18650 fi
18651 rm -f conftest*
18652 fi
18653
18654 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
18655     if test $ac_cv_val_LC_MESSAGES = yes; then
18656       cat >> confdefs.h <<\EOF
18657 #define HAVE_LC_MESSAGES 1
18658 EOF
18659
18660     fi
18661   fi
18662
18663 if test "${multilib}" = "yes"; then
18664   multilib_arg="--enable-multilib"
18665 else
18666   multilib_arg=
18667 fi
18668
18669
18670 # Generate the various Makefiles, include files, and scripts.
18671
18672 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
18673 # Needed so that g++ can find the correct include subdir automatically.
18674 INTERFACE=v3
18675
18676 # Check for the interface version number for specifying where header
18677 # files are installed, if a version number is provided.
18678 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
18679 echo "configure:18680: checking for interface version number" >&5
18680 libstdcxx_interface=$INTERFACE
18681 echo "$ac_t""$libstdcxx_interface" 1>&6
18682
18683
18684 # Process the option --with-gxx-include-dir=<path to include-files directory>
18685 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
18686 echo "configure:18687: checking for --with-gxx-include-dir" >&5
18687 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
18688 if test "${with_gxx_include_dir+set}" = set; then
18689   withval="$with_gxx_include_dir"
18690   case "${withval}" in
18691   yes)
18692     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
18693     gxx_include_dir=no
18694     ;;
18695   no)
18696     gxx_include_dir=no
18697     ;;
18698   *)
18699     gxx_include_dir=${withval}
18700     ;;
18701 esac
18702 else
18703   gxx_include_dir=no
18704 fi
18705
18706 echo "$ac_t""$gxx_include_dir" 1>&6
18707
18708
18709
18710 if test x${gxx_include_dir} != xno; then
18711   GXX_INCLUDE_DIR_TRUE=
18712   GXX_INCLUDE_DIR_FALSE='#'
18713 else
18714   GXX_INCLUDE_DIR_TRUE='#'
18715   GXX_INCLUDE_DIR_FALSE=
18716 fi
18717
18718 # Process the option "--enable-version-specific-runtime-libs"
18719 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
18720 echo "configure:18721: checking for --enable-version-specific-runtime-libs" >&5
18721 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
18722 if test "${enable_version_specific_runtime_libs+set}" = set; then
18723   enableval="$enable_version_specific_runtime_libs"
18724     version_specific_libs=yes
18725 # Need the gcc compiler version to know where to install libraries
18726 # and header files if --enable-version-specific-runtime-libs option
18727 # is selected.
18728 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
18729 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
18730 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
18731 #gcc_version=$gcc_num-$gcc_date
18732 gcc_version=$gcc_num
18733
18734
18735 else
18736   version_specific_libs=no
18737 fi
18738
18739 echo "$ac_t""$version_specific_libs" 1>&6
18740 if test x${version_specific_libs} = xyes; then
18741
18742
18743 if test x${version_specific_libs} = xyes; then
18744   VERSION_SPECIFIC_LIBS_TRUE=
18745   VERSION_SPECIFIC_LIBS_FALSE='#'
18746 else
18747   VERSION_SPECIFIC_LIBS_TRUE='#'
18748   VERSION_SPECIFIC_LIBS_FALSE=
18749 fi
18750   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
18751 fi
18752
18753
18754
18755 # Export all the include and flag information to makefiles.
18756
18757   # Root level of the include sources.
18758   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
18759
18760   # Can either use include/c or include/c_std to grab "C" headers. This
18761   # variable is set to the include directory currently in use.
18762   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
18763
18764   # Passed down for cross compilers, canadian crosses.
18765   TOPLEVEL_INCLUDES='-I$(includedir)'
18766
18767   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
18768
18769   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
18770
18771   #if GLIBCPP_NEED_LIBIO
18772   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
18773   #else
18774   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
18775   #endif
18776
18777   #if GLIBCPP_USE_CSHADOW
18778   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
18779   #                   -I$(top_blddir)/cshadow'
18780   #else
18781   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
18782   #endif
18783
18784   # Now, export this to all the little Makefiles....
18785
18786
18787
18788
18789
18790
18791
18792
18793   # Optimization flags that are probably a good idea for thrill-seekers. Just
18794   # uncomment the lines below and make, everything else is ready to go...
18795   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
18796   OPTIMIZE_CXXFLAGS=
18797
18798
18799   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
18800
18801
18802
18803 # This should be done by mkincludedir, but hack around it now.
18804 blddir=`pwd`
18805 echo "checking for $blddir/include"
18806
18807 if test ! -d "$blddir/include"; then
18808   mkdir "$blddir/include"
18809 fi
18810
18811 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
18812 # so that multilib installs will end up installed in the correct
18813 # place. To work around this not being passed down from config-ml.in
18814 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
18815 # append it here.
18816 trap '' 1 2 15
18817 cat > confcache <<\EOF
18818 # This file is a shell script that caches the results of configure
18819 # tests run on this system so they can be shared between configure
18820 # scripts and configure runs.  It is not useful on other systems.
18821 # If it contains results you don't want to keep, you may remove or edit it.
18822 #
18823 # By default, configure uses ./config.cache as the cache file,
18824 # creating it if it does not exist already.  You can give configure
18825 # the --cache-file=FILE option to use a different cache file; that is
18826 # what configure does when it calls configure scripts in
18827 # subdirectories, so they share the cache.
18828 # Giving --cache-file=/dev/null disables caching, for debugging configure.
18829 # config.status only pays attention to the cache file if you give it the
18830 # --recheck option to rerun configure.
18831 #
18832 EOF
18833 # The following way of writing the cache mishandles newlines in values,
18834 # but we know of no workaround that is simple, portable, and efficient.
18835 # So, don't put newlines in cache variables' values.
18836 # Ultrix sh set writes to stderr and can't be redirected directly,
18837 # and sets the high bit in the cache file unless we assign to the vars.
18838 (set) 2>&1 |
18839   case `(ac_space=' '; set | grep ac_space) 2>&1` in
18840   *ac_space=\ *)
18841     # `set' does not quote correctly, so add quotes (double-quote substitution
18842     # turns \\\\ into \\, and sed turns \\ into \).
18843     sed -n \
18844       -e "s/'/'\\\\''/g" \
18845       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
18846     ;;
18847   *)
18848     # `set' quotes correctly as required by POSIX, so do not add quotes.
18849     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
18850     ;;
18851   esac >> confcache
18852 if cmp -s $cache_file confcache; then
18853   :
18854 else
18855   if test -w $cache_file; then
18856     echo "updating cache $cache_file"
18857     cat confcache > $cache_file
18858   else
18859     echo "not updating unwritable cache $cache_file"
18860   fi
18861 fi
18862 rm -f confcache
18863
18864 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
18865
18866 test "x$prefix" = xNONE && prefix=$ac_default_prefix
18867 # Let make expand exec_prefix.
18868 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
18869
18870 # Any assignment to VPATH causes Sun make to only execute
18871 # the first set of double-colon rules, so remove it if not needed.
18872 # If there is a colon in the path, we need to keep it.
18873 if test "x$srcdir" = x.; then
18874   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
18875 fi
18876
18877 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
18878
18879 DEFS=-DHAVE_CONFIG_H
18880
18881 # Without the "./", some shells look in PATH for config.status.
18882 : ${CONFIG_STATUS=./config.status}
18883
18884 echo creating $CONFIG_STATUS
18885 rm -f $CONFIG_STATUS
18886 cat > $CONFIG_STATUS <<EOF
18887 #! /bin/sh
18888 # Generated automatically by configure.
18889 # Run this file to recreate the current configuration.
18890 # This directory was configured as follows,
18891 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
18892 #
18893 # $0 $ac_configure_args
18894 #
18895 # Compiler output produced by configure, useful for debugging
18896 # configure, is in ./config.log if it exists.
18897
18898 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
18899 for ac_option
18900 do
18901   case "\$ac_option" in
18902   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
18903     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
18904     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
18905   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
18906     echo "$CONFIG_STATUS generated by autoconf version 2.13"
18907     exit 0 ;;
18908   -help | --help | --hel | --he | --h)
18909     echo "\$ac_cs_usage"; exit 0 ;;
18910   *) echo "\$ac_cs_usage"; exit 1 ;;
18911   esac
18912 done
18913
18914 ac_given_srcdir=$srcdir
18915 ac_given_INSTALL="$INSTALL"
18916
18917 trap 'rm -fr `echo "mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
18918 EOF
18919 cat >> $CONFIG_STATUS <<EOF
18920
18921 # Protect against being on the right side of a sed subst in config.status.
18922 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
18923  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
18924 $ac_vpsub
18925 $extrasub
18926 s%@SHELL@%$SHELL%g
18927 s%@CFLAGS@%$CFLAGS%g
18928 s%@CPPFLAGS@%$CPPFLAGS%g
18929 s%@CXXFLAGS@%$CXXFLAGS%g
18930 s%@FFLAGS@%$FFLAGS%g
18931 s%@DEFS@%$DEFS%g
18932 s%@LDFLAGS@%$LDFLAGS%g
18933 s%@LIBS@%$LIBS%g
18934 s%@exec_prefix@%$exec_prefix%g
18935 s%@prefix@%$prefix%g
18936 s%@program_transform_name@%$program_transform_name%g
18937 s%@bindir@%$bindir%g
18938 s%@sbindir@%$sbindir%g
18939 s%@libexecdir@%$libexecdir%g
18940 s%@datadir@%$datadir%g
18941 s%@sysconfdir@%$sysconfdir%g
18942 s%@sharedstatedir@%$sharedstatedir%g
18943 s%@localstatedir@%$localstatedir%g
18944 s%@libdir@%$libdir%g
18945 s%@includedir@%$includedir%g
18946 s%@oldincludedir@%$oldincludedir%g
18947 s%@infodir@%$infodir%g
18948 s%@mandir@%$mandir%g
18949 s%@host@%$host%g
18950 s%@host_alias@%$host_alias%g
18951 s%@host_cpu@%$host_cpu%g
18952 s%@host_vendor@%$host_vendor%g
18953 s%@host_os@%$host_os%g
18954 s%@target@%$target%g
18955 s%@target_alias@%$target_alias%g
18956 s%@target_cpu@%$target_cpu%g
18957 s%@target_vendor@%$target_vendor%g
18958 s%@target_os@%$target_os%g
18959 s%@build@%$build%g
18960 s%@build_alias@%$build_alias%g
18961 s%@build_cpu@%$build_cpu%g
18962 s%@build_vendor@%$build_vendor%g
18963 s%@build_os@%$build_os%g
18964 s%@glibcpp_basedir@%$glibcpp_basedir%g
18965 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
18966 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
18967 s%@INSTALL_DATA@%$INSTALL_DATA%g
18968 s%@PACKAGE@%$PACKAGE%g
18969 s%@VERSION@%$VERSION%g
18970 s%@ACLOCAL@%$ACLOCAL%g
18971 s%@AUTOCONF@%$AUTOCONF%g
18972 s%@AUTOMAKE@%$AUTOMAKE%g
18973 s%@AUTOHEADER@%$AUTOHEADER%g
18974 s%@MAKEINFO@%$MAKEINFO%g
18975 s%@SET_MAKE@%$SET_MAKE%g
18976 s%@CC@%$CC%g
18977 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
18978 s%@CXX@%$CXX%g
18979 s%@AS@%$AS%g
18980 s%@AR@%$AR%g
18981 s%@RANLIB@%$RANLIB%g
18982 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
18983 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
18984 s%@MAINT@%$MAINT%g
18985 s%@EXEEXT@%$EXEEXT%g
18986 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
18987 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
18988 s%@LN_S@%$LN_S%g
18989 s%@OBJEXT@%$OBJEXT%g
18990 s%@STRIP@%$STRIP%g
18991 s%@LIBTOOL@%$LIBTOOL%g
18992 s%@CXXCPP@%$CXXCPP%g
18993 s%@enable_shared@%$enable_shared%g
18994 s%@enable_static@%$enable_static%g
18995 s%@ifGNUmake@%$ifGNUmake%g
18996 s%@CPP@%$CPP%g
18997 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
18998 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
18999 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
19000 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
19001 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
19002 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
19003 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
19004 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
19005 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
19006 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
19007 s%@WERROR@%$WERROR%g
19008 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
19009 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
19010 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
19011 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
19012 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
19013 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
19014 s%@libinst_wstring_la@%$libinst_wstring_la%g
19015 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
19016 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
19017 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
19018 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
19019 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
19020 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
19021 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
19022 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
19023 s%@libstdcxx_interface@%$libstdcxx_interface%g
19024 s%@gxx_include_dir@%$gxx_include_dir%g
19025 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
19026 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
19027 s%@gcc_version@%$gcc_version%g
19028 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
19029 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
19030 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
19031 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
19032 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
19033 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
19034 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
19035 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
19036 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
19037 s%@WARN_FLAGS@%$WARN_FLAGS%g
19038
19039 CEOF
19040 EOF
19041
19042 cat >> $CONFIG_STATUS <<\EOF
19043
19044 # Split the substitutions into bite-sized pieces for seds with
19045 # small command number limits, like on Digital OSF/1 and HP-UX.
19046 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
19047 ac_file=1 # Number of current file.
19048 ac_beg=1 # First line for current file.
19049 ac_end=$ac_max_sed_cmds # Line after last line for current file.
19050 ac_more_lines=:
19051 ac_sed_cmds=""
19052 while $ac_more_lines; do
19053   if test $ac_beg -gt 1; then
19054     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
19055   else
19056     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
19057   fi
19058   if test ! -s conftest.s$ac_file; then
19059     ac_more_lines=false
19060     rm -f conftest.s$ac_file
19061   else
19062     if test -z "$ac_sed_cmds"; then
19063       ac_sed_cmds="sed -f conftest.s$ac_file"
19064     else
19065       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
19066     fi
19067     ac_file=`expr $ac_file + 1`
19068     ac_beg=$ac_end
19069     ac_end=`expr $ac_end + $ac_max_sed_cmds`
19070   fi
19071 done
19072 if test -z "$ac_sed_cmds"; then
19073   ac_sed_cmds=cat
19074 fi
19075 EOF
19076
19077 cat >> $CONFIG_STATUS <<EOF
19078
19079 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
19080 EOF
19081 cat >> $CONFIG_STATUS <<\EOF
19082 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
19083   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19084   case "$ac_file" in
19085   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19086        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19087   *) ac_file_in="${ac_file}.in" ;;
19088   esac
19089
19090   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
19091
19092   # Remove last slash and all that follows it.  Not all systems have dirname.
19093   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19094   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19095     # The file is in a subdirectory.
19096     test ! -d "$ac_dir" && mkdir "$ac_dir"
19097     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
19098     # A "../" for each directory in $ac_dir_suffix.
19099     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
19100   else
19101     ac_dir_suffix= ac_dots=
19102   fi
19103
19104   case "$ac_given_srcdir" in
19105   .)  srcdir=.
19106       if test -z "$ac_dots"; then top_srcdir=.
19107       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
19108   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
19109   *) # Relative path.
19110     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
19111     top_srcdir="$ac_dots$ac_given_srcdir" ;;
19112   esac
19113
19114   case "$ac_given_INSTALL" in
19115   [/$]*) INSTALL="$ac_given_INSTALL" ;;
19116   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
19117   esac
19118
19119   echo creating "$ac_file"
19120   rm -f "$ac_file"
19121   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
19122   case "$ac_file" in
19123   *Makefile*) ac_comsub="1i\\
19124 # $configure_input" ;;
19125   *) ac_comsub= ;;
19126   esac
19127
19128   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19129   sed -e "$ac_comsub
19130 s%@configure_input@%$configure_input%g
19131 s%@srcdir@%$srcdir%g
19132 s%@top_srcdir@%$top_srcdir%g
19133 s%@INSTALL@%$INSTALL%g
19134 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
19135 fi; done
19136 rm -f conftest.s*
19137
19138 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
19139 # NAME is the cpp macro being defined and VALUE is the value it is being given.
19140 #
19141 # ac_d sets the value in "#define NAME VALUE" lines.
19142 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
19143 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
19144 ac_dC='\3'
19145 ac_dD='%g'
19146 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
19147 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19148 ac_uB='\([      ]\)%\1#\2define\3'
19149 ac_uC=' '
19150 ac_uD='\4%g'
19151 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
19152 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
19153 ac_eB='$%\1#\2define\3'
19154 ac_eC=' '
19155 ac_eD='%g'
19156
19157 if test "${CONFIG_HEADERS+set}" != set; then
19158 EOF
19159 cat >> $CONFIG_STATUS <<EOF
19160   CONFIG_HEADERS="config.h"
19161 EOF
19162 cat >> $CONFIG_STATUS <<\EOF
19163 fi
19164 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
19165   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
19166   case "$ac_file" in
19167   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
19168        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
19169   *) ac_file_in="${ac_file}.in" ;;
19170   esac
19171
19172   echo creating $ac_file
19173
19174   rm -f conftest.frag conftest.in conftest.out
19175   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
19176   cat $ac_file_inputs > conftest.in
19177
19178 EOF
19179
19180 # Transform confdefs.h into a sed script conftest.vals that substitutes
19181 # the proper values into config.h.in to produce config.h.  And first:
19182 # Protect against being on the right side of a sed subst in config.status.
19183 # Protect against being in an unquoted here document in config.status.
19184 rm -f conftest.vals
19185 cat > conftest.hdr <<\EOF
19186 s/[\\&%]/\\&/g
19187 s%[\\$`]%\\&%g
19188 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
19189 s%ac_d%ac_u%gp
19190 s%ac_u%ac_e%gp
19191 EOF
19192 sed -n -f conftest.hdr confdefs.h > conftest.vals
19193 rm -f conftest.hdr
19194
19195 # This sed command replaces #undef with comments.  This is necessary, for
19196 # example, in the case of _POSIX_SOURCE, which is predefined and required
19197 # on some systems where configure will not decide to define it.
19198 cat >> conftest.vals <<\EOF
19199 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
19200 EOF
19201
19202 # Break up conftest.vals because some shells have a limit on
19203 # the size of here documents, and old seds have small limits too.
19204
19205 rm -f conftest.tail
19206 while :
19207 do
19208   ac_lines=`grep -c . conftest.vals`
19209   # grep -c gives empty output for an empty file on some AIX systems.
19210   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
19211   # Write a limited-size here document to conftest.frag.
19212   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
19213   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
19214   echo 'CEOF
19215   sed -f conftest.frag conftest.in > conftest.out
19216   rm -f conftest.in
19217   mv conftest.out conftest.in
19218 ' >> $CONFIG_STATUS
19219   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
19220   rm -f conftest.vals
19221   mv conftest.tail conftest.vals
19222 done
19223 rm -f conftest.vals
19224
19225 cat >> $CONFIG_STATUS <<\EOF
19226   rm -f conftest.frag conftest.h
19227   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
19228   cat conftest.in >> conftest.h
19229   rm -f conftest.in
19230   if cmp -s $ac_file conftest.h 2>/dev/null; then
19231     echo "$ac_file is unchanged"
19232     rm -f conftest.h
19233   else
19234     # Remove last slash and all that follows it.  Not all systems have dirname.
19235       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
19236       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
19237       # The file is in a subdirectory.
19238       test ! -d "$ac_dir" && mkdir "$ac_dir"
19239     fi
19240     rm -f $ac_file
19241     mv conftest.h $ac_file
19242   fi
19243 fi; done
19244
19245 EOF
19246
19247 cat >> $CONFIG_STATUS <<EOF
19248 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"
19249 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 \
19250         include/bits/ctype_inline.h \
19251         include/bits/ctype_noninline.h include/bits/ctype_base.h \
19252         include/bits/ctype_inline.h \
19253         include/bits/ctype_noninline.h include/bits/ctype_base.h include/bits/ctype_inline.h \
19254     include/bits/ctype_noninline.h"
19255 EOF
19256
19257 cat >> $CONFIG_STATUS <<\EOF
19258 srcdir=$ac_given_srcdir
19259 while test -n "$ac_sources"; do
19260   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
19261   set $ac_sources; ac_source=$1; shift; ac_sources=$*
19262
19263   echo "linking $srcdir/$ac_source to $ac_dest"
19264
19265   if test ! -r $srcdir/$ac_source; then
19266     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
19267   fi
19268   rm -f $ac_dest
19269
19270   # Make relative symlinks.
19271   # Remove last slash and all that follows it.  Not all systems have dirname.
19272   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
19273   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
19274     # The dest file is in a subdirectory.
19275     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
19276     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
19277     # A "../" for each directory in $ac_dest_dir_suffix.
19278     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
19279   else
19280     ac_dest_dir_suffix= ac_dots=
19281   fi
19282
19283   case "$srcdir" in
19284   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
19285   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
19286   esac
19287
19288   # Make a symlink if possible; otherwise try a hard link.
19289   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
19290     ln $srcdir/$ac_source $ac_dest; then :
19291   else
19292     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
19293   fi
19294 done
19295 EOF
19296 cat >> $CONFIG_STATUS <<EOF
19297
19298 srcdir=${srcdir}
19299 host=${host}
19300 target=${target}
19301 with_multisubdir=${with_multisubdir}
19302 ac_configure_args="${multilib_arg} ${ac_configure_args}"
19303 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
19304 glibcpp_basedir=${glibcpp_basedir}
19305 CC="${CC}"
19306 CXX="${CXX}"
19307
19308 EOF
19309 cat >> $CONFIG_STATUS <<\EOF
19310 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
19311 if test -n "$CONFIG_FILES"; then
19312   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
19313   grep '^MULTISUBDIR =' Makefile >> src/Makefile
19314 fi
19315 chmod +x mkcheck
19316
19317 exit 0
19318 EOF
19319 chmod +x $CONFIG_STATUS
19320 rm -fr confdefs* $ac_clean_files
19321 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
19322
19323
19324
19325 # Generate bits/c++config.h
19326 # NB: This must be the first generated file as others include it. . .
19327
19328
19329 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
19330 if test ! -f stamp-limits; then
19331
19332   touch stamp-limits
19333 fi
19334
19335
19336 # Sanity checking & User-visible messages.
19337 # Checks down here, otherwise they get scrolled off before
19338 # the user will notice.
19339
19340 # Trying to get more people to read documentation.  Possibly remove
19341 # check and warn all the time. There is no "informational" AC_MSG_
19342 # macro, so these are going to be printed even when --quiet/--silent
19343 # is given.
19344 if test ! -f stamp-sanity-warned; then
19345   touch stamp-sanity-warned
19346   echo ""
19347   echo "Please make certain that you read the installation information here:"
19348   echo "  faster => ${srcdir}/docs/install.html"
19349   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
19350   echo ""
19351   echo "and the configuration information here:"
19352   echo "  faster => ${srcdir}/docs/configopts.html"
19353   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
19354   echo ""
19355   echo "before proceeding with ${_cv_gnu_make_command}."
19356   echo ""
19357 fi
19358
19359
19360 $srcdir/mkc++config $blddir $srcdir
19361 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
19362
19363