libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --with-pic              try to use only PIC/non-PIC objects [default=use both]"
  36 ac_help="$ac_help
  37   --enable-debug          extra debugging, turn off optimization [default=no]"
  38 ac_help="$ac_help
  39   --enable-cstdio        enable stdio for target io package. (default)
  40      --enable-cstdio=LIB    use LIB target-speific io package."
  41 ac_help="$ac_help
  42   --enable-c-mbchar       enable multibyte (wide) characters [default=yes]"
  43 ac_help="$ac_help
  44   --enable-long-long      turns on 'long long' [default=yes]"
  45 ac_help="$ac_help
  46   --enable-cshadow-headers construct "shadowed" C header files for
  47                            g++ [default=no]"
  48 ac_help="$ac_help
  49   --enable-threads        enable thread usage for target GCC.
  50      --enable-threads=LIB    use LIB thread package for target GCC."
  51 ac_help="$ac_help
  52   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  53                                 [default=none]"
  54 ac_help="$ac_help
  55  --with-gxx-include-dir  the installation directory for include files"
  56 ac_help="$ac_help
  57   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory "
  58
  59 # Initialize some variables set by options.
  60 # The variables have the same names as the options, with
  61 # dashes changed to underlines.
  62 build=NONE
  63 cache_file=./config.cache
  64 exec_prefix=NONE
  65 host=NONE
  66 no_create=
  67 nonopt=NONE
  68 no_recursion=
  69 prefix=NONE
  70 program_prefix=NONE
  71 program_suffix=NONE
  72 program_transform_name=s,x,x,
  73 silent=
  74 site=
  75 srcdir=
  76 target=NONE
  77 verbose=
  78 x_includes=NONE
  79 x_libraries=NONE
  80 bindir='${exec_prefix}/bin'
  81 sbindir='${exec_prefix}/sbin'
  82 libexecdir='${exec_prefix}/libexec'
  83 datadir='${prefix}/share'
  84 sysconfdir='${prefix}/etc'
  85 sharedstatedir='${prefix}/com'
  86 localstatedir='${prefix}/var'
  87 libdir='${exec_prefix}/lib'
  88 includedir='${prefix}/include'
  89 oldincludedir='/usr/include'
  90 infodir='${prefix}/info'
  91 mandir='${prefix}/man'
  92
  93 # Initialize some other variables.
  94 subdirs=
  95 MFLAGS= MAKEFLAGS=
  96 SHELL=${CONFIG_SHELL-/bin/sh}
  97 # Maximum number of lines to put in a shell here document.
  98 ac_max_here_lines=12
  99
 100 ac_prev=
 101 for ac_option
 102 do
 103
 104   # If the previous option needs an argument, assign it.
 105   if test -n "$ac_prev"; then
 106     eval "$ac_prev=\$ac_option"
 107     ac_prev=
 108     continue
 109   fi
 110
 111   case "$ac_option" in
 112   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 113   *) ac_optarg= ;;
 114   esac
 115
 116   # Accept the important Cygnus configure options, so we can diagnose typos.
 117
 118   case "$ac_option" in
 119
 120   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 121     ac_prev=bindir ;;
 122   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 123     bindir="$ac_optarg" ;;
 124
 125   -build | --build | --buil | --bui | --bu)
 126     ac_prev=build ;;
 127   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 128     build="$ac_optarg" ;;
 129
 130   -cache-file | --cache-file | --cache-fil | --cache-fi \
 131   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 132     ac_prev=cache_file ;;
 133   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 134   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 135     cache_file="$ac_optarg" ;;
 136
 137   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 138     ac_prev=datadir ;;
 139   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 140   | --da=*)
 141     datadir="$ac_optarg" ;;
 142
 143   -disable-* | --disable-*)
 144     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 145     # Reject names that are not valid shell variable names.
 146     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 147       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 148     fi
 149     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 150     eval "enable_${ac_feature}=no" ;;
 151
 152   -enable-* | --enable-*)
 153     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 154     # Reject names that are not valid shell variable names.
 155     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 156       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 157     fi
 158     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 159     case "$ac_option" in
 160       *=*) ;;
 161       *) ac_optarg=yes ;;
 162     esac
 163     eval "enable_${ac_feature}='$ac_optarg'" ;;
 164
 165   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 166   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 167   | --exec | --exe | --ex)
 168     ac_prev=exec_prefix ;;
 169   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 170   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 171   | --exec=* | --exe=* | --ex=*)
 172     exec_prefix="$ac_optarg" ;;
 173
 174   -gas | --gas | --ga | --g)
 175     # Obsolete; use --with-gas.
 176     with_gas=yes ;;
 177
 178   -help | --help | --hel | --he)
 179     # Omit some internal or obsolete options to make the list less imposing.
 180     # This message is too long to be a string in the A/UX 3.1 sh.
 181     cat << EOF
 182 Usage: configure [options] [host]
 183 Options: [defaults in brackets after descriptions]
 184 Configuration:
 185   --cache-file=FILE       cache test results in FILE
 186   --help                  print this message
 187   --no-create             do not create output files
 188   --quiet, --silent       do not print \`checking...' messages
 189   --version               print the version of autoconf that created configure
 190 Directory and file names:
 191   --prefix=PREFIX         install architecture-independent files in PREFIX
 192                           [$ac_default_prefix]
 193   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 194                           [same as prefix]
 195   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 196   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 197   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 198   --datadir=DIR           read-only architecture-independent data in DIR
 199                           [PREFIX/share]
 200   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 201   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 202                           [PREFIX/com]
 203   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 204   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 205   --includedir=DIR        C header files in DIR [PREFIX/include]
 206   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 207   --infodir=DIR           info documentation in DIR [PREFIX/info]
 208   --mandir=DIR            man documentation in DIR [PREFIX/man]
 209   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 210   --program-prefix=PREFIX prepend PREFIX to installed program names
 211   --program-suffix=SUFFIX append SUFFIX to installed program names
 212   --program-transform-name=PROGRAM
 213                           run sed PROGRAM on installed program names
 214 EOF
 215     cat << EOF
 216 Host type:
 217   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 218   --host=HOST             configure for HOST [guessed]
 219   --target=TARGET         configure for TARGET [TARGET=HOST]
 220 Features and packages:
 221   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 222   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 223   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 224   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 225   --x-includes=DIR        X include files are in DIR
 226   --x-libraries=DIR       X library files are in DIR
 227 EOF
 228     if test -n "$ac_help"; then
 229       echo "--enable and --with options recognized:$ac_help"
 230     fi
 231     exit 0 ;;
 232
 233   -host | --host | --hos | --ho)
 234     ac_prev=host ;;
 235   -host=* | --host=* | --hos=* | --ho=*)
 236     host="$ac_optarg" ;;
 237
 238   -includedir | --includedir | --includedi | --included | --include \
 239   | --includ | --inclu | --incl | --inc)
 240     ac_prev=includedir ;;
 241   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 242   | --includ=* | --inclu=* | --incl=* | --inc=*)
 243     includedir="$ac_optarg" ;;
 244
 245   -infodir | --infodir | --infodi | --infod | --info | --inf)
 246     ac_prev=infodir ;;
 247   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 248     infodir="$ac_optarg" ;;
 249
 250   -libdir | --libdir | --libdi | --libd)
 251     ac_prev=libdir ;;
 252   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 253     libdir="$ac_optarg" ;;
 254
 255   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 256   | --libexe | --libex | --libe)
 257     ac_prev=libexecdir ;;
 258   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 259   | --libexe=* | --libex=* | --libe=*)
 260     libexecdir="$ac_optarg" ;;
 261
 262   -localstatedir | --localstatedir | --localstatedi | --localstated \
 263   | --localstate | --localstat | --localsta | --localst \
 264   | --locals | --local | --loca | --loc | --lo)
 265     ac_prev=localstatedir ;;
 266   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 267   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 268   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 269     localstatedir="$ac_optarg" ;;
 270
 271   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 272     ac_prev=mandir ;;
 273   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 274     mandir="$ac_optarg" ;;
 275
 276   -nfp | --nfp | --nf)
 277     # Obsolete; use --without-fp.
 278     with_fp=no ;;
 279
 280   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 281   | --no-cr | --no-c)
 282     no_create=yes ;;
 283
 284   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 285   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 286     no_recursion=yes ;;
 287
 288   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 289   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 290   | --oldin | --oldi | --old | --ol | --o)
 291     ac_prev=oldincludedir ;;
 292   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 293   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 294   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 295     oldincludedir="$ac_optarg" ;;
 296
 297   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 298     ac_prev=prefix ;;
 299   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 300     prefix="$ac_optarg" ;;
 301
 302   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 303   | --program-pre | --program-pr | --program-p)
 304     ac_prev=program_prefix ;;
 305   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 306   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 307     program_prefix="$ac_optarg" ;;
 308
 309   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 310   | --program-suf | --program-su | --program-s)
 311     ac_prev=program_suffix ;;
 312   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 313   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 314     program_suffix="$ac_optarg" ;;
 315
 316   -program-transform-name | --program-transform-name \
 317   | --program-transform-nam | --program-transform-na \
 318   | --program-transform-n | --program-transform- \
 319   | --program-transform | --program-transfor \
 320   | --program-transfo | --program-transf \
 321   | --program-trans | --program-tran \
 322   | --progr-tra | --program-tr | --program-t)
 323     ac_prev=program_transform_name ;;
 324   -program-transform-name=* | --program-transform-name=* \
 325   | --program-transform-nam=* | --program-transform-na=* \
 326   | --program-transform-n=* | --program-transform-=* \
 327   | --program-transform=* | --program-transfor=* \
 328   | --program-transfo=* | --program-transf=* \
 329   | --program-trans=* | --program-tran=* \
 330   | --progr-tra=* | --program-tr=* | --program-t=*)
 331     program_transform_name="$ac_optarg" ;;
 332
 333   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 334   | -silent | --silent | --silen | --sile | --sil)
 335     silent=yes ;;
 336
 337   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 338     ac_prev=sbindir ;;
 339   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 340   | --sbi=* | --sb=*)
 341     sbindir="$ac_optarg" ;;
 342
 343   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 344   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 345   | --sharedst | --shareds | --shared | --share | --shar \
 346   | --sha | --sh)
 347     ac_prev=sharedstatedir ;;
 348   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 349   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 350   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 351   | --sha=* | --sh=*)
 352     sharedstatedir="$ac_optarg" ;;
 353
 354   -site | --site | --sit)
 355     ac_prev=site ;;
 356   -site=* | --site=* | --sit=*)
 357     site="$ac_optarg" ;;
 358
 359   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 360     ac_prev=srcdir ;;
 361   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 362     srcdir="$ac_optarg" ;;
 363
 364   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 365   | --syscon | --sysco | --sysc | --sys | --sy)
 366     ac_prev=sysconfdir ;;
 367   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 368   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 369     sysconfdir="$ac_optarg" ;;
 370
 371   -target | --target | --targe | --targ | --tar | --ta | --t)
 372     ac_prev=target ;;
 373   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 374     target="$ac_optarg" ;;
 375
 376   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 377     verbose=yes ;;
 378
 379   -version | --version | --versio | --versi | --vers)
 380     echo "configure generated by autoconf version 2.13"
 381     exit 0 ;;
 382
 383   -with-* | --with-*)
 384     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 385     # Reject names that are not valid shell variable names.
 386     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 387       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 388     fi
 389     ac_package=`echo $ac_package| sed 's/-/_/g'`
 390     case "$ac_option" in
 391       *=*) ;;
 392       *) ac_optarg=yes ;;
 393     esac
 394     eval "with_${ac_package}='$ac_optarg'" ;;
 395
 396   -without-* | --without-*)
 397     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 398     # Reject names that are not valid shell variable names.
 399     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 400       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 401     fi
 402     ac_package=`echo $ac_package| sed 's/-/_/g'`
 403     eval "with_${ac_package}=no" ;;
 404
 405   --x)
 406     # Obsolete; use --with-x.
 407     with_x=yes ;;
 408
 409   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 410   | --x-incl | --x-inc | --x-in | --x-i)
 411     ac_prev=x_includes ;;
 412   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 413   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 414     x_includes="$ac_optarg" ;;
 415
 416   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 417   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 418     ac_prev=x_libraries ;;
 419   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 420   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 421     x_libraries="$ac_optarg" ;;
 422
 423   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 424     ;;
 425
 426   *)
 427     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 428       echo "configure: warning: $ac_option: invalid host type" 1>&2
 429     fi
 430     if test "x$nonopt" != xNONE; then
 431       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 432     fi
 433     nonopt="$ac_option"
 434     ;;
 435
 436   esac
 437 done
 438
 439 if test -n "$ac_prev"; then
 440   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 441 fi
 442
 443 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 444
 445 # File descriptor usage:
 446 # 0 standard input
 447 # 1 file creation
 448 # 2 errors and warnings
 449 # 3 some systems may open it to /dev/tty
 450 # 4 used on the Kubota Titan
 451 # 6 checking for... messages and results
 452 # 5 compiler messages saved in config.log
 453 if test "$silent" = yes; then
 454   exec 6>/dev/null
 455 else
 456   exec 6>&1
 457 fi
 458 exec 5>./config.log
 459
 460 echo "\
 461 This file contains any messages produced by compilers while
 462 running configure, to aid debugging if configure makes a mistake.
 463 " 1>&5
 464
 465 # Strip out --no-create and --no-recursion so they do not pile up.
 466 # Also quote any args containing shell metacharacters.
 467 ac_configure_args=
 468 for ac_arg
 469 do
 470   case "$ac_arg" in
 471   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 472   | --no-cr | --no-c) ;;
 473   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 474   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 475   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 476   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 477   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 478   esac
 479 done
 480
 481 # NLS nuisances.
 482 # Only set these to C if already set.  These must not be set unconditionally
 483 # because not all systems understand e.g. LANG=C (notably SCO).
 484 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 485 # Non-C LC_CTYPE values break the ctype check.
 486 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 487 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 488 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 489 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 490
 491 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 492 rm -rf conftest* confdefs.h
 493 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 494 echo > confdefs.h
 495
 496 # A filename unique to this package, relative to the directory that
 497 # configure is in, which we can look for to find out if srcdir is correct.
 498 ac_unique_file=src/complex.cc
 499
 500 # Find the source files, if location was not specified.
 501 if test -z "$srcdir"; then
 502   ac_srcdir_defaulted=yes
 503   # Try the directory containing this script, then its parent.
 504   ac_prog=$0
 505   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 506   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 507   srcdir=$ac_confdir
 508   if test ! -r $srcdir/$ac_unique_file; then
 509     srcdir=..
 510   fi
 511 else
 512   ac_srcdir_defaulted=no
 513 fi
 514 if test ! -r $srcdir/$ac_unique_file; then
 515   if test "$ac_srcdir_defaulted" = yes; then
 516     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 517   else
 518     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 519   fi
 520 fi
 521 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 522
 523 # Prefer explicitly selected file to automatically selected ones.
 524 if test -z "$CONFIG_SITE"; then
 525   if test "x$prefix" != xNONE; then
 526     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527   else
 528     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529   fi
 530 fi
 531 for ac_site_file in $CONFIG_SITE; do
 532   if test -r "$ac_site_file"; then
 533     echo "loading site script $ac_site_file"
 534     . "$ac_site_file"
 535   fi
 536 done
 537
 538 if test -r "$cache_file"; then
 539   echo "loading cache $cache_file"
 540   . $cache_file
 541 else
 542   echo "creating cache $cache_file"
 543   > $cache_file
 544 fi
 545
 546 ac_ext=c
 547 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 548 ac_cpp='$CPP $CPPFLAGS'
 549 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 550 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 551 cross_compiling=$ac_cv_prog_cc_cross
 552
 553 ac_exeext=
 554 ac_objext=o
 555 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 556   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 557   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 558     ac_n= ac_c='
 559 ' ac_t='        '
 560   else
 561     ac_n=-n ac_c= ac_t=
 562   fi
 563 else
 564   ac_n= ac_c='\c' ac_t=
 565 fi
 566
 567
 568 ac_aux_dir=
 569 for ac_dir in .. $srcdir/..; do
 570   if test -f $ac_dir/install-sh; then
 571     ac_aux_dir=$ac_dir
 572     ac_install_sh="$ac_aux_dir/install-sh -c"
 573     break
 574   elif test -f $ac_dir/install.sh; then
 575     ac_aux_dir=$ac_dir
 576     ac_install_sh="$ac_aux_dir/install.sh -c"
 577     break
 578   fi
 579 done
 580 if test -z "$ac_aux_dir"; then
 581   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 582 fi
 583 ac_config_guess=$ac_aux_dir/config.guess
 584 ac_config_sub=$ac_aux_dir/config.sub
 585 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 586
 587
 588 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 589
 590 # Do some error checking and defaulting for the host and target type.
 591 # The inputs are:
 592 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 593 #
 594 # The rules are:
 595 # 1. You are not allowed to specify --host, --target, and nonopt at the
 596 #    same time.
 597 # 2. Host defaults to nonopt.
 598 # 3. If nonopt is not specified, then host defaults to the current host,
 599 #    as determined by config.guess.
 600 # 4. Target and build default to nonopt.
 601 # 5. If nonopt is not specified, then target and build default to host.
 602
 603 # The aliases save the names the user supplied, while $host etc.
 604 # will get canonicalized.
 605 case $host---$target---$nonopt in
 606 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 607 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 608 esac
 609
 610
 611 # Make sure we can run config.sub.
 612 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 613 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 614 fi
 615
 616 echo $ac_n "checking host system type""... $ac_c" 1>&6
 617 echo "configure:618: checking host system type" >&5
 618
 619 host_alias=$host
 620 case "$host_alias" in
 621 NONE)
 622   case $nonopt in
 623   NONE)
 624     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 625     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 626     fi ;;
 627   *) host_alias=$nonopt ;;
 628   esac ;;
 629 esac
 630
 631 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 632 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 633 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 634 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 635 echo "$ac_t""$host" 1>&6
 636
 637 echo $ac_n "checking target system type""... $ac_c" 1>&6
 638 echo "configure:639: checking target system type" >&5
 639
 640 target_alias=$target
 641 case "$target_alias" in
 642 NONE)
 643   case $nonopt in
 644   NONE) target_alias=$host_alias ;;
 645   *) target_alias=$nonopt ;;
 646   esac ;;
 647 esac
 648
 649 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 650 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 651 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 652 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 653 echo "$ac_t""$target" 1>&6
 654
 655 echo $ac_n "checking build system type""... $ac_c" 1>&6
 656 echo "configure:657: checking build system type" >&5
 657
 658 build_alias=$build
 659 case "$build_alias" in
 660 NONE)
 661   case $nonopt in
 662   NONE) build_alias=$host_alias ;;
 663   *) build_alias=$nonopt ;;
 664   esac ;;
 665 esac
 666
 667 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 668 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 669 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 670 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 671 echo "$ac_t""$build" 1>&6
 672
 673 test "$host_alias" != "$target_alias" &&
 674   test "$program_prefix$program_suffix$program_transform_name" = \
 675     NONENONEs,x,x, &&
 676   program_prefix=${target_alias}-
 677
 678
 679 # We use these options to decide which functions to include.
 680 # Check whether --with-target-subdir or --without-target-subdir was given.
 681 if test "${with_target_subdir+set}" = set; then
 682   withval="$with_target_subdir"
 683   :
 684 fi
 685
 686 # Check whether --with-cross-host or --without-cross-host was given.
 687 if test "${with_cross_host+set}" = set; then
 688   withval="$with_cross_host"
 689   :
 690 fi
 691
 692
 693 # Runs configure.host and configure.target. Have to run this before
 694 # the GLIBCPP_ENABLE_* macros below.
 695 # Find a good install program.  We prefer a C program (faster),
 696 # so one script is as good as another.  But avoid the broken or
 697 # incompatible versions:
 698 # SysV /etc/install, /usr/sbin/install
 699 # SunOS /usr/etc/install
 700 # IRIX /sbin/install
 701 # AIX /bin/install
 702 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 703 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 704 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 705 # ./install, which can be erroneously created by make from ./install.sh.
 706 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 707 echo "configure:708: checking for a BSD compatible install" >&5
 708 if test -z "$INSTALL"; then
 709 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 710   echo $ac_n "(cached) $ac_c" 1>&6
 711 else
 712     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 713   for ac_dir in $PATH; do
 714     # Account for people who put trailing slashes in PATH elements.
 715     case "$ac_dir/" in
 716     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 717     *)
 718       # OSF1 and SCO ODT 3.0 have their own names for install.
 719       # Don't use installbsd from OSF since it installs stuff as root
 720       # by default.
 721       for ac_prog in ginstall scoinst install; do
 722         if test -f $ac_dir/$ac_prog; then
 723           if test $ac_prog = install &&
 724             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 725             # AIX install.  It has an incompatible calling convention.
 726             :
 727           else
 728             ac_cv_path_install="$ac_dir/$ac_prog -c"
 729             break 2
 730           fi
 731         fi
 732       done
 733       ;;
 734     esac
 735   done
 736   IFS="$ac_save_IFS"
 737
 738 fi
 739   if test "${ac_cv_path_install+set}" = set; then
 740     INSTALL="$ac_cv_path_install"
 741   else
 742     # As a last resort, use the slow shell script.  We don't cache a
 743     # path for INSTALL within a source directory, because that will
 744     # break other packages using the cache if that directory is
 745     # removed, or if the path is relative.
 746     INSTALL="$ac_install_sh"
 747   fi
 748 fi
 749 echo "$ac_t""$INSTALL" 1>&6
 750
 751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 752 # It thinks the first close brace ends the variable substitution.
 753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 754
 755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 756
 757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 758
 759 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 760 echo "configure:761: checking whether build environment is sane" >&5
 761 # Just in case
 762 sleep 1
 763 echo timestamp > conftestfile
 764 # Do `set' in a subshell so we don't clobber the current shell's
 765 # arguments.  Must try -L first in case configure is actually a
 766 # symlink; some systems play weird games with the mod time of symlinks
 767 # (eg FreeBSD returns the mod time of the symlink's containing
 768 # directory).
 769 if (
 770    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 771    if test "$*" = "X"; then
 772       # -L didn't work.
 773       set X `ls -t $srcdir/configure conftestfile`
 774    fi
 775    if test "$*" != "X $srcdir/configure conftestfile" \
 776       && test "$*" != "X conftestfile $srcdir/configure"; then
 777
 778       # If neither matched, then we have a broken ls.  This can happen
 779       # if, for instance, CONFIG_SHELL is bash and it inherits a
 780       # broken ls alias from the environment.  This has actually
 781       # happened.  Such a system could not be considered "sane".
 782       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 783 alias in your environment" 1>&2; exit 1; }
 784    fi
 785
 786    test "$2" = conftestfile
 787    )
 788 then
 789    # Ok.
 790    :
 791 else
 792    { echo "configure: error: newly created file is older than distributed files!
 793 Check your system clock" 1>&2; exit 1; }
 794 fi
 795 rm -f conftest*
 796 echo "$ac_t""yes" 1>&6
 797 if test "$program_transform_name" = s,x,x,; then
 798   program_transform_name=
 799 else
 800   # Double any \ or $.  echo might interpret backslashes.
 801   cat <<\EOF_SED > conftestsed
 802 s,\\,\\\\,g; s,\$,$$,g
 803 EOF_SED
 804   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 805   rm -f conftestsed
 806 fi
 807 test "$program_prefix" != NONE &&
 808   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 809 # Use a double $ so make ignores it.
 810 test "$program_suffix" != NONE &&
 811   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 812
 813 # sed with no file args requires a program.
 814 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 815
 816 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 817 echo "configure:818: checking whether ${MAKE-make} sets \${MAKE}" >&5
 818 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 819 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 820   echo $ac_n "(cached) $ac_c" 1>&6
 821 else
 822   cat > conftestmake <<\EOF
 823 all:
 824         @echo 'ac_maketemp="${MAKE}"'
 825 EOF
 826 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 827 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 828 if test -n "$ac_maketemp"; then
 829   eval ac_cv_prog_make_${ac_make}_set=yes
 830 else
 831   eval ac_cv_prog_make_${ac_make}_set=no
 832 fi
 833 rm -f conftestmake
 834 fi
 835 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 836   echo "$ac_t""yes" 1>&6
 837   SET_MAKE=
 838 else
 839   echo "$ac_t""no" 1>&6
 840   SET_MAKE="MAKE=${MAKE-make}"
 841 fi
 842
 843 if test $host != $build; then
 844   ac_tool_prefix=${host_alias}-
 845 else
 846   ac_tool_prefix=
 847 fi
 848
 849 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 850 echo "configure:851: checking for Cygwin environment" >&5
 851 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 852   echo $ac_n "(cached) $ac_c" 1>&6
 853 else
 854   cat > conftest.$ac_ext <<EOF
 855 #line 856 "configure"
 856 #include "confdefs.h"
 857
 858 int main() {
 859
 860 #ifndef __CYGWIN__
 861 #define __CYGWIN__ __CYGWIN32__
 862 #endif
 863 return __CYGWIN__;
 864 ; return 0; }
 865 EOF
 866 if { (eval echo configure:867: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 867   rm -rf conftest*
 868   ac_cv_cygwin=yes
 869 else
 870   echo "configure: failed program was:" >&5
 871   cat conftest.$ac_ext >&5
 872   rm -rf conftest*
 873   ac_cv_cygwin=no
 874 fi
 875 rm -f conftest*
 876 rm -f conftest*
 877 fi
 878
 879 echo "$ac_t""$ac_cv_cygwin" 1>&6
 880 CYGWIN=
 881 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 882 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 883 echo "configure:884: checking for mingw32 environment" >&5
 884 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 885   echo $ac_n "(cached) $ac_c" 1>&6
 886 else
 887   cat > conftest.$ac_ext <<EOF
 888 #line 889 "configure"
 889 #include "confdefs.h"
 890
 891 int main() {
 892 return __MINGW32__;
 893 ; return 0; }
 894 EOF
 895 if { (eval echo configure:896: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 896   rm -rf conftest*
 897   ac_cv_mingw32=yes
 898 else
 899   echo "configure: failed program was:" >&5
 900   cat conftest.$ac_ext >&5
 901   rm -rf conftest*
 902   ac_cv_mingw32=no
 903 fi
 904 rm -f conftest*
 905 rm -f conftest*
 906 fi
 907
 908 echo "$ac_t""$ac_cv_mingw32" 1>&6
 909 MINGW32=
 910 test "$ac_cv_mingw32" = yes && MINGW32=yes
 911
 912     # Check whether --enable-multilib or --disable-multilib was given.
 913 if test "${enable_multilib+set}" = set; then
 914   enableval="$enable_multilib"
 915   case "${enableval}" in
 916     yes) multilib=yes ;;
 917     no)  multilib=no ;;
 918     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 919    esac
 920 else
 921   multilib=yes
 922 fi
 923
 924       if test "${srcdir}" = "."; then
 925     if test "${with_target_subdir}" != "."; then
 926       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 927     else
 928       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 929     fi
 930   else
 931     glibcpp_basedir="${srcdir}/."
 932   fi
 933
 934
 935
 936 PACKAGE=libstdc++
 937
 938 VERSION=2.90.8
 939
 940 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 941   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 942 fi
 943 cat >> confdefs.h <<EOF
 944 #define PACKAGE "$PACKAGE"
 945 EOF
 946
 947 cat >> confdefs.h <<EOF
 948 #define VERSION "$VERSION"
 949 EOF
 950
 951
 952
 953 missing_dir=`cd $ac_aux_dir && pwd`
 954 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 955 echo "configure:956: checking for working aclocal" >&5
 956 # Run test in a subshell; some versions of sh will print an error if
 957 # an executable is not found, even if stderr is redirected.
 958 # Redirect stdin to placate older versions of autoconf.  Sigh.
 959 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 960    ACLOCAL=aclocal
 961    echo "$ac_t""found" 1>&6
 962 else
 963    ACLOCAL="$missing_dir/missing aclocal"
 964    echo "$ac_t""missing" 1>&6
 965 fi
 966
 967 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 968 echo "configure:969: checking for working autoconf" >&5
 969 # Run test in a subshell; some versions of sh will print an error if
 970 # an executable is not found, even if stderr is redirected.
 971 # Redirect stdin to placate older versions of autoconf.  Sigh.
 972 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 973    AUTOCONF=autoconf
 974    echo "$ac_t""found" 1>&6
 975 else
 976    AUTOCONF="$missing_dir/missing autoconf"
 977    echo "$ac_t""missing" 1>&6
 978 fi
 979
 980 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 981 echo "configure:982: checking for working automake" >&5
 982 # Run test in a subshell; some versions of sh will print an error if
 983 # an executable is not found, even if stderr is redirected.
 984 # Redirect stdin to placate older versions of autoconf.  Sigh.
 985 if (automake --version) < /dev/null > /dev/null 2>&1; then
 986    AUTOMAKE=automake
 987    echo "$ac_t""found" 1>&6
 988 else
 989    AUTOMAKE="$missing_dir/missing automake"
 990    echo "$ac_t""missing" 1>&6
 991 fi
 992
 993 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
 994 echo "configure:995: checking for working autoheader" >&5
 995 # Run test in a subshell; some versions of sh will print an error if
 996 # an executable is not found, even if stderr is redirected.
 997 # Redirect stdin to placate older versions of autoconf.  Sigh.
 998 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
 999    AUTOHEADER=autoheader
1000    echo "$ac_t""found" 1>&6
1001 else
1002    AUTOHEADER="$missing_dir/missing autoheader"
1003    echo "$ac_t""missing" 1>&6
1004 fi
1005
1006 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1007 echo "configure:1008: checking for working makeinfo" >&5
1008 # Run test in a subshell; some versions of sh will print an error if
1009 # an executable is not found, even if stderr is redirected.
1010 # Redirect stdin to placate older versions of autoconf.  Sigh.
1011 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1012    MAKEINFO=makeinfo
1013    echo "$ac_t""found" 1>&6
1014 else
1015    MAKEINFO="$missing_dir/missing makeinfo"
1016    echo "$ac_t""missing" 1>&6
1017 fi
1018
1019
1020
1021   # Never versions of autoconf add an underscore to these functions.
1022   # Prevent future problems ...
1023
1024
1025
1026
1027
1028 #  AC_PROG_CC
1029
1030 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1031 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1032 # are probably using a cross compiler, which will not be able to fully
1033 # link an executable.  This should really be fixed in autoconf
1034 # itself.
1035
1036
1037
1038
1039 # Extract the first word of "gcc", so it can be a program name with args.
1040 set dummy gcc; ac_word=$2
1041 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1042 echo "configure:1043: checking for $ac_word" >&5
1043 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1044   echo $ac_n "(cached) $ac_c" 1>&6
1045 else
1046   if test -n "$CC"; then
1047   ac_cv_prog_CC="$CC" # Let the user override the test.
1048 else
1049   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1050   ac_dummy="$PATH"
1051   for ac_dir in $ac_dummy; do
1052     test -z "$ac_dir" && ac_dir=.
1053     if test -f $ac_dir/$ac_word; then
1054       ac_cv_prog_CC="gcc"
1055       break
1056     fi
1057   done
1058   IFS="$ac_save_ifs"
1059 fi
1060 fi
1061 CC="$ac_cv_prog_CC"
1062 if test -n "$CC"; then
1063   echo "$ac_t""$CC" 1>&6
1064 else
1065   echo "$ac_t""no" 1>&6
1066 fi
1067
1068 if test -z "$CC"; then
1069   # Extract the first word of "cc", so it can be a program name with args.
1070 set dummy cc; ac_word=$2
1071 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1072 echo "configure:1073: checking for $ac_word" >&5
1073 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1074   echo $ac_n "(cached) $ac_c" 1>&6
1075 else
1076   if test -n "$CC"; then
1077   ac_cv_prog_CC="$CC" # Let the user override the test.
1078 else
1079   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1080   ac_prog_rejected=no
1081   ac_dummy="$PATH"
1082   for ac_dir in $ac_dummy; do
1083     test -z "$ac_dir" && ac_dir=.
1084     if test -f $ac_dir/$ac_word; then
1085       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1086         ac_prog_rejected=yes
1087         continue
1088       fi
1089       ac_cv_prog_CC="cc"
1090       break
1091     fi
1092   done
1093   IFS="$ac_save_ifs"
1094 if test $ac_prog_rejected = yes; then
1095   # We found a bogon in the path, so make sure we never use it.
1096   set dummy $ac_cv_prog_CC
1097   shift
1098   if test $# -gt 0; then
1099     # We chose a different compiler from the bogus one.
1100     # However, it has the same basename, so the bogon will be chosen
1101     # first if we set CC to just the basename; use the full file name.
1102     shift
1103     set dummy "$ac_dir/$ac_word" "$@"
1104     shift
1105     ac_cv_prog_CC="$@"
1106   fi
1107 fi
1108 fi
1109 fi
1110 CC="$ac_cv_prog_CC"
1111 if test -n "$CC"; then
1112   echo "$ac_t""$CC" 1>&6
1113 else
1114   echo "$ac_t""no" 1>&6
1115 fi
1116
1117   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1118 fi
1119
1120 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1121 echo "configure:1122: checking whether we are using GNU C" >&5
1122 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1123   echo $ac_n "(cached) $ac_c" 1>&6
1124 else
1125   cat > conftest.c <<EOF
1126 #ifdef __GNUC__
1127   yes;
1128 #endif
1129 EOF
1130 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1131: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1131   ac_cv_prog_gcc=yes
1132 else
1133   ac_cv_prog_gcc=no
1134 fi
1135 fi
1136
1137 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1138
1139 if test $ac_cv_prog_gcc = yes; then
1140   GCC=yes
1141   ac_test_CFLAGS="${CFLAGS+set}"
1142   ac_save_CFLAGS="$CFLAGS"
1143   CFLAGS=
1144   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1145 echo "configure:1146: checking whether ${CC-cc} accepts -g" >&5
1146 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1147   echo $ac_n "(cached) $ac_c" 1>&6
1148 else
1149   echo 'void f(){}' > conftest.c
1150 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1151   ac_cv_prog_cc_g=yes
1152 else
1153   ac_cv_prog_cc_g=no
1154 fi
1155 rm -f conftest*
1156
1157 fi
1158
1159 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1160   if test "$ac_test_CFLAGS" = set; then
1161     CFLAGS="$ac_save_CFLAGS"
1162   elif test $ac_cv_prog_cc_g = yes; then
1163     CFLAGS="-g -O2"
1164   else
1165     CFLAGS="-O2"
1166   fi
1167 else
1168   GCC=
1169   test "${CFLAGS+set}" = set || CFLAGS="-g"
1170 fi
1171
1172
1173 # Can't just call these here as g++ requires libstc++ to be built....
1174 #  AC_PROG_CXX
1175
1176 # Likewise for AC_PROG_CXX.
1177
1178
1179
1180 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1181 # flags that come in CXX while configuring libstdc++.  They're different
1182 # from those used for all other target libraries.  If CXX is set in
1183 # the environment, respect that here.
1184 CXX_libstdcxx=$CXX
1185 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1186 do
1187 # Extract the first word of "$ac_prog", so it can be a program name with args.
1188 set dummy $ac_prog; ac_word=$2
1189 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1190 echo "configure:1191: checking for $ac_word" >&5
1191 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1192   echo $ac_n "(cached) $ac_c" 1>&6
1193 else
1194   if test -n "$CXX_libstdcxx"; then
1195   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1196 else
1197   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1198   ac_dummy="$PATH"
1199   for ac_dir in $ac_dummy; do
1200     test -z "$ac_dir" && ac_dir=.
1201     if test -f $ac_dir/$ac_word; then
1202       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1203       break
1204     fi
1205   done
1206   IFS="$ac_save_ifs"
1207 fi
1208 fi
1209 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1210 if test -n "$CXX_libstdcxx"; then
1211   echo "$ac_t""$CXX_libstdcxx" 1>&6
1212 else
1213   echo "$ac_t""no" 1>&6
1214 fi
1215
1216 test -n "$CXX_libstdcxx" && break
1217 done
1218 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1219
1220 CXX=$CXX_libstdcxx
1221
1222 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1223
1224 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1225 echo "configure:1226: checking whether we are using GNU C++" >&5
1226 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1227   echo $ac_n "(cached) $ac_c" 1>&6
1228 else
1229   cat > conftest.C <<EOF
1230 #ifdef __GNUC__
1231   yes;
1232 #endif
1233 EOF
1234 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1235: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1235   ac_cv_prog_gxx=yes
1236 else
1237   ac_cv_prog_gxx=no
1238 fi
1239 fi
1240
1241 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1242
1243 if test $ac_cv_prog_gxx = yes; then
1244   GXX=yes
1245   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1246   ac_save_CXXFLAGS="$CXXFLAGS"
1247   CXXFLAGS=
1248   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1249 echo "configure:1250: checking whether ${CXX-g++} accepts -g" >&5
1250 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1251   echo $ac_n "(cached) $ac_c" 1>&6
1252 else
1253   echo 'void f(){}' > conftest.cc
1254 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1255   ac_cv_prog_cxx_g=yes
1256 else
1257   ac_cv_prog_cxx_g=no
1258 fi
1259 rm -f conftest*
1260
1261 fi
1262
1263 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1264   if test "$ac_test_CXXFLAGS" = set; then
1265     CXXFLAGS="$ac_save_CXXFLAGS"
1266   elif test $ac_cv_prog_cxx_g = yes; then
1267     CXXFLAGS="-g -O2"
1268   else
1269     CXXFLAGS="-O2"
1270   fi
1271 else
1272   GXX=
1273   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1274 fi
1275
1276
1277   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1278 set dummy ${ac_tool_prefix}as; ac_word=$2
1279 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1280 echo "configure:1281: checking for $ac_word" >&5
1281 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1282   echo $ac_n "(cached) $ac_c" 1>&6
1283 else
1284   if test -n "$AS"; then
1285   ac_cv_prog_AS="$AS" # Let the user override the test.
1286 else
1287   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1288   ac_dummy="$PATH"
1289   for ac_dir in $ac_dummy; do
1290     test -z "$ac_dir" && ac_dir=.
1291     if test -f $ac_dir/$ac_word; then
1292       ac_cv_prog_AS="${ac_tool_prefix}as"
1293       break
1294     fi
1295   done
1296   IFS="$ac_save_ifs"
1297   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1298 fi
1299 fi
1300 AS="$ac_cv_prog_AS"
1301 if test -n "$AS"; then
1302   echo "$ac_t""$AS" 1>&6
1303 else
1304   echo "$ac_t""no" 1>&6
1305 fi
1306
1307
1308
1309   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1310 set dummy ${ac_tool_prefix}ar; ac_word=$2
1311 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1312 echo "configure:1313: checking for $ac_word" >&5
1313 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1314   echo $ac_n "(cached) $ac_c" 1>&6
1315 else
1316   if test -n "$AR"; then
1317   ac_cv_prog_AR="$AR" # Let the user override the test.
1318 else
1319   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1320   ac_dummy="$PATH"
1321   for ac_dir in $ac_dummy; do
1322     test -z "$ac_dir" && ac_dir=.
1323     if test -f $ac_dir/$ac_word; then
1324       ac_cv_prog_AR="${ac_tool_prefix}ar"
1325       break
1326     fi
1327   done
1328   IFS="$ac_save_ifs"
1329   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1330 fi
1331 fi
1332 AR="$ac_cv_prog_AR"
1333 if test -n "$AR"; then
1334   echo "$ac_t""$AR" 1>&6
1335 else
1336   echo "$ac_t""no" 1>&6
1337 fi
1338
1339
1340
1341   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1342 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1343 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1344 echo "configure:1345: checking for $ac_word" >&5
1345 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1346   echo $ac_n "(cached) $ac_c" 1>&6
1347 else
1348   if test -n "$RANLIB"; then
1349   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1350 else
1351   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1352   ac_dummy="$PATH"
1353   for ac_dir in $ac_dummy; do
1354     test -z "$ac_dir" && ac_dir=.
1355     if test -f $ac_dir/$ac_word; then
1356       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1357       break
1358     fi
1359   done
1360   IFS="$ac_save_ifs"
1361 fi
1362 fi
1363 RANLIB="$ac_cv_prog_RANLIB"
1364 if test -n "$RANLIB"; then
1365   echo "$ac_t""$RANLIB" 1>&6
1366 else
1367   echo "$ac_t""no" 1>&6
1368 fi
1369
1370
1371 if test -z "$ac_cv_prog_RANLIB"; then
1372 if test -n "$ac_tool_prefix"; then
1373   # Extract the first word of "ranlib", so it can be a program name with args.
1374 set dummy ranlib; ac_word=$2
1375 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1376 echo "configure:1377: checking for $ac_word" >&5
1377 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1378   echo $ac_n "(cached) $ac_c" 1>&6
1379 else
1380   if test -n "$RANLIB"; then
1381   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1382 else
1383   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1384   ac_dummy="$PATH"
1385   for ac_dir in $ac_dummy; do
1386     test -z "$ac_dir" && ac_dir=.
1387     if test -f $ac_dir/$ac_word; then
1388       ac_cv_prog_RANLIB="ranlib"
1389       break
1390     fi
1391   done
1392   IFS="$ac_save_ifs"
1393   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403 else
1404   RANLIB=":"
1405 fi
1406 fi
1407
1408
1409   # Find a good install program.  We prefer a C program (faster),
1410 # so one script is as good as another.  But avoid the broken or
1411 # incompatible versions:
1412 # SysV /etc/install, /usr/sbin/install
1413 # SunOS /usr/etc/install
1414 # IRIX /sbin/install
1415 # AIX /bin/install
1416 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1417 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1418 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1419 # ./install, which can be erroneously created by make from ./install.sh.
1420 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1421 echo "configure:1422: checking for a BSD compatible install" >&5
1422 if test -z "$INSTALL"; then
1423 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1424   echo $ac_n "(cached) $ac_c" 1>&6
1425 else
1426     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1427   for ac_dir in $PATH; do
1428     # Account for people who put trailing slashes in PATH elements.
1429     case "$ac_dir/" in
1430     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1431     *)
1432       # OSF1 and SCO ODT 3.0 have their own names for install.
1433       # Don't use installbsd from OSF since it installs stuff as root
1434       # by default.
1435       for ac_prog in ginstall scoinst install; do
1436         if test -f $ac_dir/$ac_prog; then
1437           if test $ac_prog = install &&
1438             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1439             # AIX install.  It has an incompatible calling convention.
1440             :
1441           else
1442             ac_cv_path_install="$ac_dir/$ac_prog -c"
1443             break 2
1444           fi
1445         fi
1446       done
1447       ;;
1448     esac
1449   done
1450   IFS="$ac_save_IFS"
1451
1452 fi
1453   if test "${ac_cv_path_install+set}" = set; then
1454     INSTALL="$ac_cv_path_install"
1455   else
1456     # As a last resort, use the slow shell script.  We don't cache a
1457     # path for INSTALL within a source directory, because that will
1458     # break other packages using the cache if that directory is
1459     # removed, or if the path is relative.
1460     INSTALL="$ac_install_sh"
1461   fi
1462 fi
1463 echo "$ac_t""$INSTALL" 1>&6
1464
1465 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1466 # It thinks the first close brace ends the variable substitution.
1467 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1468
1469 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1470
1471 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1472
1473
1474   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1475 echo "configure:1476: checking whether to enable maintainer-specific portions of Makefiles" >&5
1476     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1477 if test "${enable_maintainer_mode+set}" = set; then
1478   enableval="$enable_maintainer_mode"
1479   USE_MAINTAINER_MODE=$enableval
1480 else
1481   USE_MAINTAINER_MODE=no
1482 fi
1483
1484   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1485
1486
1487 if test $USE_MAINTAINER_MODE = yes; then
1488   MAINTAINER_MODE_TRUE=
1489   MAINTAINER_MODE_FALSE='#'
1490 else
1491   MAINTAINER_MODE_TRUE='#'
1492   MAINTAINER_MODE_FALSE=
1493 fi
1494   MAINT=$MAINTAINER_MODE_TRUE
1495
1496
1497
1498   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1499   # at least currently, we never actually build a program, so we never
1500   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1501   # fails, because we are probably configuring with a cross compiler
1502   # which cant create executables.  So we include AC_EXEEXT to keep
1503   # automake happy, but we dont execute it, since we dont care about
1504   # the result.
1505   if false; then
1506
1507
1508 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1509 echo "configure:1510: checking for executable suffix" >&5
1510 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1511   echo $ac_n "(cached) $ac_c" 1>&6
1512 else
1513   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1514   ac_cv_exeext=.exe
1515 else
1516   rm -f conftest*
1517   echo 'int main () { return 0; }' > conftest.$ac_ext
1518   ac_cv_exeext=
1519   if { (eval echo configure:1520: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1520     for file in conftest.*; do
1521       case $file in
1522       *.c | *.o | *.obj) ;;
1523       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1524       esac
1525     done
1526   else
1527     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1528   fi
1529   rm -f conftest*
1530   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1531 fi
1532 fi
1533
1534 EXEEXT=""
1535 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1536 echo "$ac_t""${ac_cv_exeext}" 1>&6
1537 ac_exeext=$EXEEXT
1538
1539   fi
1540
1541   # configure.host sets the following important variables
1542   #        glibcpp_cflags    - host specific C compiler flags
1543   #        glibcpp_cxxflags  - host specific C++ compiler flags
1544   glibcpp_cflags=
1545   glibcpp_cxxflags=
1546
1547   . ${glibcpp_basedir}/configure.host
1548
1549   case ${glibcpp_basedir} in
1550     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1551     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1552   esac
1553
1554   # This does for the target what configure.host does for the host.  In
1555   # addition to modifying the same flags, it also sets up symlinks.
1556
1557     . ${glibcpp_basedir}/configure.target
1558     echo "$ac_t""CPU config directory is $cpu_include_dir" 1>&6
1559     echo "$ac_t""OS config directory is $os_include_dir" 1>&6
1560
1561
1562
1563   GLIBCPP_CFLAGS="${glibcpp_cflags}"
1564   GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1565
1566
1567
1568
1569
1570 # Check whether --enable-shared or --disable-shared was given.
1571 if test "${enable_shared+set}" = set; then
1572   enableval="$enable_shared"
1573   p=${PACKAGE-default}
1574 case "$enableval" in
1575 yes) enable_shared=yes ;;
1576 no) enable_shared=no ;;
1577 *)
1578   enable_shared=no
1579   # Look at the argument we got.  We use all the common list separators.
1580   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1581   for pkg in $enableval; do
1582     if test "X$pkg" = "X$p"; then
1583       enable_shared=yes
1584     fi
1585   done
1586   IFS="$ac_save_ifs"
1587   ;;
1588 esac
1589 else
1590   enable_shared=yes
1591 fi
1592
1593 # Check whether --enable-static or --disable-static was given.
1594 if test "${enable_static+set}" = set; then
1595   enableval="$enable_static"
1596   p=${PACKAGE-default}
1597 case "$enableval" in
1598 yes) enable_static=yes ;;
1599 no) enable_static=no ;;
1600 *)
1601   enable_static=no
1602   # Look at the argument we got.  We use all the common list separators.
1603   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1604   for pkg in $enableval; do
1605     if test "X$pkg" = "X$p"; then
1606       enable_static=yes
1607     fi
1608   done
1609   IFS="$ac_save_ifs"
1610   ;;
1611 esac
1612 else
1613   enable_static=yes
1614 fi
1615
1616 # Check whether --enable-fast-install or --disable-fast-install was given.
1617 if test "${enable_fast_install+set}" = set; then
1618   enableval="$enable_fast_install"
1619   p=${PACKAGE-default}
1620 case "$enableval" in
1621 yes) enable_fast_install=yes ;;
1622 no) enable_fast_install=no ;;
1623 *)
1624   enable_fast_install=no
1625   # Look at the argument we got.  We use all the common list separators.
1626   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1627   for pkg in $enableval; do
1628     if test "X$pkg" = "X$p"; then
1629       enable_fast_install=yes
1630     fi
1631   done
1632   IFS="$ac_save_ifs"
1633   ;;
1634 esac
1635 else
1636   enable_fast_install=yes
1637 fi
1638
1639 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1640 if test "${with_gnu_ld+set}" = set; then
1641   withval="$with_gnu_ld"
1642   test "$withval" = no || with_gnu_ld=yes
1643 else
1644   with_gnu_ld=no
1645 fi
1646
1647 ac_prog=ld
1648 if test "$ac_cv_prog_gcc" = yes; then
1649   # Check if gcc -print-prog-name=ld gives a path.
1650   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1651 echo "configure:1652: checking for ld used by GCC" >&5
1652   case $host in
1653   *-*-mingw*)
1654     # gcc leaves a trailing carriage return which upsets mingw
1655     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
1656   *)
1657     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
1658   esac
1659   case "$ac_prog" in
1660     # Accept absolute paths.
1661     [\\/]* | [A-Za-z]:[\\/]*)
1662       re_direlt='/[^/][^/]*/\.\./'
1663       # Canonicalize the path of ld
1664       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1665       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1666         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1667       done
1668       test -z "$LD" && LD="$ac_prog"
1669       ;;
1670   "")
1671     # If it fails, then pretend we aren't using GCC.
1672     ac_prog=ld
1673     ;;
1674   *)
1675     # If it is relative, then search for the first ld in PATH.
1676     with_gnu_ld=unknown
1677     ;;
1678   esac
1679 elif test "$with_gnu_ld" = yes; then
1680   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1681 echo "configure:1682: checking for GNU ld" >&5
1682 else
1683   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1684 echo "configure:1685: checking for non-GNU ld" >&5
1685 fi
1686 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1687   echo $ac_n "(cached) $ac_c" 1>&6
1688 else
1689   if test -z "$LD"; then
1690   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1691   for ac_dir in $PATH; do
1692     test -z "$ac_dir" && ac_dir=.
1693     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1694       ac_cv_path_LD="$ac_dir/$ac_prog"
1695       # Check to see if the program is GNU ld.  I'd rather use --version,
1696       # but apparently some GNU ld's only accept -v.
1697       # Break only if it was the GNU/non-GNU ld that we prefer.
1698       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1699         test "$with_gnu_ld" != no && break
1700       else
1701         test "$with_gnu_ld" != yes && break
1702       fi
1703     fi
1704   done
1705   IFS="$ac_save_ifs"
1706 else
1707   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1708 fi
1709 fi
1710
1711 LD="$ac_cv_path_LD"
1712 if test -n "$LD"; then
1713   echo "$ac_t""$LD" 1>&6
1714 else
1715   echo "$ac_t""no" 1>&6
1716 fi
1717 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1718 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1719 echo "configure:1720: checking if the linker ($LD) is GNU ld" >&5
1720 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1721   echo $ac_n "(cached) $ac_c" 1>&6
1722 else
1723   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1724 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1725   ac_cv_prog_gnu_ld=yes
1726 else
1727   ac_cv_prog_gnu_ld=no
1728 fi
1729 fi
1730
1731 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1732 with_gnu_ld=$ac_cv_prog_gnu_ld
1733
1734
1735 echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6
1736 echo "configure:1737: checking for $LD option to reload object files" >&5
1737 if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then
1738   echo $ac_n "(cached) $ac_c" 1>&6
1739 else
1740   lt_cv_ld_reload_flag='-r'
1741 fi
1742
1743 echo "$ac_t""$lt_cv_ld_reload_flag" 1>&6
1744 reload_flag=$lt_cv_ld_reload_flag
1745 test -n "$reload_flag" && reload_flag=" $reload_flag"
1746
1747 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1748 echo "configure:1749: checking for BSD-compatible nm" >&5
1749 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1750   echo $ac_n "(cached) $ac_c" 1>&6
1751 else
1752   if test -n "$NM"; then
1753   # Let the user override the test.
1754   ac_cv_path_NM="$NM"
1755 else
1756   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1757   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1758     test -z "$ac_dir" && ac_dir=.
1759     tmp_nm=$ac_dir/${ac_tool_prefix}nm
1760     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
1761       # Check to see if the nm accepts a BSD-compat flag.
1762       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1763       #   nm: unknown option "B" ignored
1764       # Tru64's nm complains that /dev/null is an invalid object file
1765       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
1766         ac_cv_path_NM="$tmp_nm -B"
1767         break
1768       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1769         ac_cv_path_NM="$tmp_nm -p"
1770         break
1771       else
1772         ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
1773         continue # so that we can try to find one that supports BSD flags
1774       fi
1775     fi
1776   done
1777   IFS="$ac_save_ifs"
1778   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1779 fi
1780 fi
1781
1782 NM="$ac_cv_path_NM"
1783 echo "$ac_t""$NM" 1>&6
1784
1785 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1786 echo "configure:1787: checking whether ln -s works" >&5
1787 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1788   echo $ac_n "(cached) $ac_c" 1>&6
1789 else
1790   rm -f conftestdata
1791 if ln -s X conftestdata 2>/dev/null
1792 then
1793   rm -f conftestdata
1794   ac_cv_prog_LN_S="ln -s"
1795 else
1796   ac_cv_prog_LN_S=ln
1797 fi
1798 fi
1799 LN_S="$ac_cv_prog_LN_S"
1800 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1801   echo "$ac_t""yes" 1>&6
1802 else
1803   echo "$ac_t""no" 1>&6
1804 fi
1805
1806 echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6
1807 echo "configure:1808: checking how to recognise dependant libraries" >&5
1808 if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then
1809   echo $ac_n "(cached) $ac_c" 1>&6
1810 else
1811   lt_cv_file_magic_cmd='$MAGIC_CMD'
1812 lt_cv_file_magic_test_file=
1813 lt_cv_deplibs_check_method='unknown'
1814 # Need to set the preceding variable on all platforms that support
1815 # interlibrary dependencies.
1816 # 'none' -- dependencies not supported.
1817 # `unknown' -- same as none, but documents that we really don't know.
1818 # 'pass_all' -- all dependencies passed with no checks.
1819 # 'test_compile' -- check by making test program.
1820 # 'file_magic [regex]' -- check by looking for files in library path
1821 # which responds to the $file_magic_cmd with a given egrep regex.
1822 # If you have `file' or equivalent on your system and you're not sure
1823 # whether `pass_all' will *always* work, you probably want this one.
1824
1825 case "$host_os" in
1826 aix4*)
1827   lt_cv_deplibs_check_method=pass_all
1828   ;;
1829
1830 beos*)
1831   lt_cv_deplibs_check_method=pass_all
1832   ;;
1833
1834 bsdi4*)
1835     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
1836     lt_cv_file_magic_cmd='/usr/bin/file -L'
1837   lt_cv_file_magic_test_file=/shlib/libc.so
1838   ;;
1839
1840 cygwin* | mingw* |pw32*)
1841   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
1842   lt_cv_file_magic_cmd='$OBJDUMP -f'
1843   ;;
1844
1845 freebsd* )
1846   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
1847     case "$host_cpu" in
1848     i*86 )
1849       # Not sure whether the presence of OpenBSD here was a mistake.
1850       # Let's accept both of them until this is cleared up.
1851             lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
1852             lt_cv_file_magic_cmd=/usr/bin/file
1853       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
1854       ;;
1855     esac
1856   else
1857     lt_cv_deplibs_check_method=pass_all
1858   fi
1859   ;;
1860
1861 gnu*)
1862   lt_cv_deplibs_check_method=pass_all
1863   ;;
1864
1865 hpux10.20*)
1866   # TODO:  Does this work for hpux-11 too?
1867   lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9.0-9) shared library'
1868   lt_cv_file_magic_cmd=/usr/bin/file
1869   lt_cv_file_magic_test_file=/usr/lib/libc.sl
1870   ;;
1871
1872 irix5* | irix6*)
1873   case "$host_os" in
1874   irix5*)
1875     # this will be overridden with pass_all, but let us keep it just in case
1876     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
1877     ;;
1878   *)
1879     case "$LD" in
1880     *-32|*"-32 ") libmagic=32-bit;;
1881     *-n32|*"-n32 ") libmagic=N32;;
1882     *-64|*"-64 ") libmagic=64-bit;;
1883     *) libmagic=never-match;;
1884     esac
1885     # this will be overridden with pass_all, but let us keep it just in case
1886         lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
1887         ;;
1888   esac
1889   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
1890   lt_cv_deplibs_check_method=pass_all
1891   ;;
1892
1893 # This must be Linux ELF.
1894 linux-gnu*)
1895   case "$host_cpu" in
1896   alpha* | i*86 | powerpc* | sparc* | ia64* )
1897     lt_cv_deplibs_check_method=pass_all ;;
1898   *)
1899     # glibc up to 2.1.1 does not perform some relocations on ARM
1900         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
1901       esac
1902   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
1903   ;;
1904
1905 netbsd*)
1906   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
1907   else
1908         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
1909         lt_cv_file_magic_cmd='/usr/bin/file -L'
1910     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1911   fi
1912   ;;
1913
1914 osf3* | osf4* | osf5*)
1915   # this will be overridden with pass_all, but let us keep it just in case
1916   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
1917   lt_cv_file_magic_test_file=/shlib/libc.so
1918   lt_cv_deplibs_check_method=pass_all
1919   ;;
1920
1921 sco3.2v5*)
1922   lt_cv_deplibs_check_method=pass_all
1923   ;;
1924
1925 solaris*)
1926   lt_cv_deplibs_check_method=pass_all
1927   lt_cv_file_magic_test_file=/lib/libc.so
1928   ;;
1929
1930 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
1931   case "$host_vendor" in
1932   ncr)
1933     lt_cv_deplibs_check_method=pass_all
1934     ;;
1935   motorola)
1936         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
1937         lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1938     ;;
1939   esac
1940   ;;
1941 esac
1942
1943 fi
1944
1945 echo "$ac_t""$lt_cv_deplibs_check_method" 1>&6
1946 file_magic_cmd=$lt_cv_file_magic_cmd
1947 deplibs_check_method=$lt_cv_deplibs_check_method
1948
1949 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
1950 echo "configure:1951: checking for object suffix" >&5
1951 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
1952   echo $ac_n "(cached) $ac_c" 1>&6
1953 else
1954   rm -f conftest*
1955 echo 'int i = 1;' > conftest.$ac_ext
1956 if { (eval echo configure:1957: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1957   for ac_file in conftest.*; do
1958     case $ac_file in
1959     *.c) ;;
1960     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
1961     esac
1962   done
1963 else
1964   { echo "configure: error: installation or configuration problem; compiler does not work" 1>&2; exit 1; }
1965 fi
1966 rm -f conftest*
1967 fi
1968
1969 echo "$ac_t""$ac_cv_objext" 1>&6
1970 OBJEXT=$ac_cv_objext
1971 ac_objext=$ac_cv_objext
1972
1973 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
1974
1975 # Only perform the check for file, if the check method requires it
1976 case "$deplibs_check_method" in
1977 file_magic*)
1978   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
1979     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
1980 echo "configure:1981: checking for ${ac_tool_prefix}file" >&5
1981 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
1982   echo $ac_n "(cached) $ac_c" 1>&6
1983 else
1984   case "$MAGIC_CMD" in
1985   /*)
1986   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
1987   ;;
1988   ?:/*)
1989   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
1990   ;;
1991   *)
1992   ac_save_MAGIC_CMD="$MAGIC_CMD"
1993   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1994   ac_dummy="/usr/bin:$PATH"
1995   for ac_dir in $ac_dummy; do
1996     test -z "$ac_dir" && ac_dir=.
1997     if test -f $ac_dir/${ac_tool_prefix}file; then
1998       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
1999       if test -n "$file_magic_test_file"; then
2000         case "$deplibs_check_method" in
2001         "file_magic "*)
2002           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2003           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2004           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2005             egrep "$file_magic_regex" > /dev/null; then
2006             :
2007           else
2008             cat <<EOF 1>&2
2009
2010 *** Warning: the command libtool uses to detect shared libraries,
2011 *** $file_magic_cmd, produces output that libtool cannot recognize.
2012 *** The result is that libtool may fail to recognize shared libraries
2013 *** as such.  This will affect the creation of libtool libraries that
2014 *** depend on shared libraries, but programs linked with such libtool
2015 *** libraries will work regardless of this problem.  Nevertheless, you
2016 *** may want to report the problem to your system manager and/or to
2017 *** bug-libtool@gnu.org
2018
2019 EOF
2020           fi ;;
2021         esac
2022       fi
2023       break
2024     fi
2025   done
2026   IFS="$ac_save_ifs"
2027   MAGIC_CMD="$ac_save_MAGIC_CMD"
2028   ;;
2029 esac
2030 fi
2031
2032 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2033 if test -n "$MAGIC_CMD"; then
2034   echo "$ac_t""$MAGIC_CMD" 1>&6
2035 else
2036   echo "$ac_t""no" 1>&6
2037 fi
2038
2039 if test -z "$lt_cv_path_MAGIC_CMD"; then
2040   if test -n "$ac_tool_prefix"; then
2041     echo $ac_n "checking for file""... $ac_c" 1>&6
2042 echo "configure:2043: checking for file" >&5
2043 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
2044   echo $ac_n "(cached) $ac_c" 1>&6
2045 else
2046   case "$MAGIC_CMD" in
2047   /*)
2048   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2049   ;;
2050   ?:/*)
2051   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
2052   ;;
2053   *)
2054   ac_save_MAGIC_CMD="$MAGIC_CMD"
2055   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2056   ac_dummy="/usr/bin:$PATH"
2057   for ac_dir in $ac_dummy; do
2058     test -z "$ac_dir" && ac_dir=.
2059     if test -f $ac_dir/file; then
2060       lt_cv_path_MAGIC_CMD="$ac_dir/file"
2061       if test -n "$file_magic_test_file"; then
2062         case "$deplibs_check_method" in
2063         "file_magic "*)
2064           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2065           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2066           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2067             egrep "$file_magic_regex" > /dev/null; then
2068             :
2069           else
2070             cat <<EOF 1>&2
2071
2072 *** Warning: the command libtool uses to detect shared libraries,
2073 *** $file_magic_cmd, produces output that libtool cannot recognize.
2074 *** The result is that libtool may fail to recognize shared libraries
2075 *** as such.  This will affect the creation of libtool libraries that
2076 *** depend on shared libraries, but programs linked with such libtool
2077 *** libraries will work regardless of this problem.  Nevertheless, you
2078 *** may want to report the problem to your system manager and/or to
2079 *** bug-libtool@gnu.org
2080
2081 EOF
2082           fi ;;
2083         esac
2084       fi
2085       break
2086     fi
2087   done
2088   IFS="$ac_save_ifs"
2089   MAGIC_CMD="$ac_save_MAGIC_CMD"
2090   ;;
2091 esac
2092 fi
2093
2094 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2095 if test -n "$MAGIC_CMD"; then
2096   echo "$ac_t""$MAGIC_CMD" 1>&6
2097 else
2098   echo "$ac_t""no" 1>&6
2099 fi
2100
2101   else
2102     MAGIC_CMD=:
2103   fi
2104 fi
2105
2106   fi
2107   ;;
2108 esac
2109
2110 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
2111 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
2112 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2113 echo "configure:2114: checking for $ac_word" >&5
2114 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2115   echo $ac_n "(cached) $ac_c" 1>&6
2116 else
2117   if test -n "$RANLIB"; then
2118   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2119 else
2120   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2121   ac_dummy="$PATH"
2122   for ac_dir in $ac_dummy; do
2123     test -z "$ac_dir" && ac_dir=.
2124     if test -f $ac_dir/$ac_word; then
2125       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
2126       break
2127     fi
2128   done
2129   IFS="$ac_save_ifs"
2130 fi
2131 fi
2132 RANLIB="$ac_cv_prog_RANLIB"
2133 if test -n "$RANLIB"; then
2134   echo "$ac_t""$RANLIB" 1>&6
2135 else
2136   echo "$ac_t""no" 1>&6
2137 fi
2138
2139
2140 if test -z "$ac_cv_prog_RANLIB"; then
2141 if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "ranlib", so it can be a program name with args.
2143 set dummy ranlib; ac_word=$2
2144 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2145 echo "configure:2146: checking for $ac_word" >&5
2146 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2147   echo $ac_n "(cached) $ac_c" 1>&6
2148 else
2149   if test -n "$RANLIB"; then
2150   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2151 else
2152   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2153   ac_dummy="$PATH"
2154   for ac_dir in $ac_dummy; do
2155     test -z "$ac_dir" && ac_dir=.
2156     if test -f $ac_dir/$ac_word; then
2157       ac_cv_prog_RANLIB="ranlib"
2158       break
2159     fi
2160   done
2161   IFS="$ac_save_ifs"
2162   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
2163 fi
2164 fi
2165 RANLIB="$ac_cv_prog_RANLIB"
2166 if test -n "$RANLIB"; then
2167   echo "$ac_t""$RANLIB" 1>&6
2168 else
2169   echo "$ac_t""no" 1>&6
2170 fi
2171
2172 else
2173   RANLIB=":"
2174 fi
2175 fi
2176
2177 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
2178 set dummy ${ac_tool_prefix}strip; ac_word=$2
2179 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2180 echo "configure:2181: checking for $ac_word" >&5
2181 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2182   echo $ac_n "(cached) $ac_c" 1>&6
2183 else
2184   if test -n "$STRIP"; then
2185   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2186 else
2187   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2188   ac_dummy="$PATH"
2189   for ac_dir in $ac_dummy; do
2190     test -z "$ac_dir" && ac_dir=.
2191     if test -f $ac_dir/$ac_word; then
2192       ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2193       break
2194     fi
2195   done
2196   IFS="$ac_save_ifs"
2197 fi
2198 fi
2199 STRIP="$ac_cv_prog_STRIP"
2200 if test -n "$STRIP"; then
2201   echo "$ac_t""$STRIP" 1>&6
2202 else
2203   echo "$ac_t""no" 1>&6
2204 fi
2205
2206
2207 if test -z "$ac_cv_prog_STRIP"; then
2208 if test -n "$ac_tool_prefix"; then
2209   # Extract the first word of "strip", so it can be a program name with args.
2210 set dummy strip; ac_word=$2
2211 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2212 echo "configure:2213: checking for $ac_word" >&5
2213 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2214   echo $ac_n "(cached) $ac_c" 1>&6
2215 else
2216   if test -n "$STRIP"; then
2217   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2218 else
2219   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2220   ac_dummy="$PATH"
2221   for ac_dir in $ac_dummy; do
2222     test -z "$ac_dir" && ac_dir=.
2223     if test -f $ac_dir/$ac_word; then
2224       ac_cv_prog_STRIP="strip"
2225       break
2226     fi
2227   done
2228   IFS="$ac_save_ifs"
2229   test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP=":"
2230 fi
2231 fi
2232 STRIP="$ac_cv_prog_STRIP"
2233 if test -n "$STRIP"; then
2234   echo "$ac_t""$STRIP" 1>&6
2235 else
2236   echo "$ac_t""no" 1>&6
2237 fi
2238
2239 else
2240   STRIP=":"
2241 fi
2242 fi
2243
2244
2245 # Check for any special flags to pass to ltconfig.
2246 libtool_flags="--cache-file=$cache_file"
2247 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
2248 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
2249 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
2250 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
2251 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
2252 libtool_flags="$libtool_flags --enable-dlopen"
2253
2254 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
2255 if test "${enable_libtool_lock+set}" = set; then
2256   enableval="$enable_libtool_lock"
2257   :
2258 fi
2259
2260 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
2261 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
2262
2263 # Check whether --with-pic or --without-pic was given.
2264 if test "${with_pic+set}" = set; then
2265   withval="$with_pic"
2266   pic_mode="$withval"
2267 else
2268   pic_mode=default
2269 fi
2270
2271 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
2272 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
2273
2274 # Some flags need to be propagated to the compiler or linker for good
2275 # libtool support.
2276 case "$host" in
2277 *-*-irix6*)
2278   # Find out which ABI we are using.
2279   echo '#line 2280 "configure"' > conftest.$ac_ext
2280   if { (eval echo configure:2281: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2281     case "`/usr/bin/file conftest.o`" in
2282     *32-bit*)
2283       LD="${LD-ld} -32"
2284       ;;
2285     *N32*)
2286       LD="${LD-ld} -n32"
2287       ;;
2288     *64-bit*)
2289       LD="${LD-ld} -64"
2290       ;;
2291     esac
2292   fi
2293   rm -rf conftest*
2294   ;;
2295
2296 *-*-sco3.2v5*)
2297   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
2298   SAVE_CFLAGS="$CFLAGS"
2299   CFLAGS="$CFLAGS -belf"
2300   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
2301 echo "configure:2302: checking whether the C compiler needs -belf" >&5
2302 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
2303   echo $ac_n "(cached) $ac_c" 1>&6
2304 else
2305
2306      ac_ext=c
2307 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2308 ac_cpp='$CPP $CPPFLAGS'
2309 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2310 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2311 cross_compiling=$ac_cv_prog_cc_cross
2312
2313      cat > conftest.$ac_ext <<EOF
2314 #line 2315 "configure"
2315 #include "confdefs.h"
2316
2317 int main() {
2318
2319 ; return 0; }
2320 EOF
2321 if { (eval echo configure:2322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2322   rm -rf conftest*
2323   lt_cv_cc_needs_belf=yes
2324 else
2325   echo "configure: failed program was:" >&5
2326   cat conftest.$ac_ext >&5
2327   rm -rf conftest*
2328   lt_cv_cc_needs_belf=no
2329 fi
2330 rm -f conftest*
2331      ac_ext=c
2332 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2333 ac_cpp='$CPP $CPPFLAGS'
2334 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2335 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2336 cross_compiling=$ac_cv_prog_cc_cross
2337
2338 fi
2339
2340 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
2341   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
2342     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
2343     CFLAGS="$SAVE_CFLAGS"
2344   fi
2345   ;;
2346
2347
2348 esac
2349
2350 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
2351 echo "configure:2352: checking how to run the C++ preprocessor" >&5
2352 if test -z "$CXXCPP"; then
2353 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
2354   echo $ac_n "(cached) $ac_c" 1>&6
2355 else
2356   ac_ext=C
2357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2358 ac_cpp='$CXXCPP $CPPFLAGS'
2359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2361 cross_compiling=$ac_cv_prog_cxx_cross
2362   CXXCPP="${CXX-g++} -E"
2363   cat > conftest.$ac_ext <<EOF
2364 #line 2365 "configure"
2365 #include "confdefs.h"
2366 #include <stdlib.h>
2367 EOF
2368 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2369 { (eval echo configure:2370: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2370 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2371 if test -z "$ac_err"; then
2372   :
2373 else
2374   echo "$ac_err" >&5
2375   echo "configure: failed program was:" >&5
2376   cat conftest.$ac_ext >&5
2377   rm -rf conftest*
2378   CXXCPP=/lib/cpp
2379 fi
2380 rm -f conftest*
2381   ac_cv_prog_CXXCPP="$CXXCPP"
2382 ac_ext=c
2383 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2384 ac_cpp='$CPP $CPPFLAGS'
2385 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2386 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2387 cross_compiling=$ac_cv_prog_cc_cross
2388 fi
2389 fi
2390 CXXCPP="$ac_cv_prog_CXXCPP"
2391 echo "$ac_t""$CXXCPP" 1>&6
2392
2393
2394 # Save cache, so that ltconfig can load it
2395 cat > confcache <<\EOF
2396 # This file is a shell script that caches the results of configure
2397 # tests run on this system so they can be shared between configure
2398 # scripts and configure runs.  It is not useful on other systems.
2399 # If it contains results you don't want to keep, you may remove or edit it.
2400 #
2401 # By default, configure uses ./config.cache as the cache file,
2402 # creating it if it does not exist already.  You can give configure
2403 # the --cache-file=FILE option to use a different cache file; that is
2404 # what configure does when it calls configure scripts in
2405 # subdirectories, so they share the cache.
2406 # Giving --cache-file=/dev/null disables caching, for debugging configure.
2407 # config.status only pays attention to the cache file if you give it the
2408 # --recheck option to rerun configure.
2409 #
2410 EOF
2411 # The following way of writing the cache mishandles newlines in values,
2412 # but we know of no workaround that is simple, portable, and efficient.
2413 # So, don't put newlines in cache variables' values.
2414 # Ultrix sh set writes to stderr and can't be redirected directly,
2415 # and sets the high bit in the cache file unless we assign to the vars.
2416 (set) 2>&1 |
2417   case `(ac_space=' '; set | grep ac_space) 2>&1` in
2418   *ac_space=\ *)
2419     # `set' does not quote correctly, so add quotes (double-quote substitution
2420     # turns \\\\ into \\, and sed turns \\ into \).
2421     sed -n \
2422       -e "s/'/'\\\\''/g" \
2423       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
2424     ;;
2425   *)
2426     # `set' quotes correctly as required by POSIX, so do not add quotes.
2427     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
2428     ;;
2429   esac >> confcache
2430 if cmp -s $cache_file confcache; then
2431   :
2432 else
2433   if test -w $cache_file; then
2434     echo "updating cache $cache_file"
2435     cat confcache > $cache_file
2436   else
2437     echo "not updating unwritable cache $cache_file"
2438   fi
2439 fi
2440 rm -f confcache
2441
2442
2443 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
2444 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
2445 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2446 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2447 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2448 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2449 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
2450 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2451 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
2452 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2453
2454 # Reload cache, that may have been modified by ltconfig
2455 if test -r "$cache_file"; then
2456   echo "loading cache $cache_file"
2457   . $cache_file
2458 else
2459   echo "creating cache $cache_file"
2460   > $cache_file
2461 fi
2462
2463
2464 # This can be used to rebuild libtool when needed
2465 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
2466
2467 # Always use our own libtool.
2468 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2469
2470 # Redirect the config.log output again, so that the ltconfig log is not
2471 # clobbered by the next message.
2472 exec 5>>./config.log
2473
2474
2475
2476
2477 LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh"
2478 lt_save_CC="$CC"
2479 lt_save_CFLAGS="$CFLAGS"
2480 AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \
2481 MAGIC_CMD="$MAGIC_CMD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2482 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2483 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2484 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2485 deplibs_check_method="$deplibs_check_method" \
2486 file_magic_cmd="$file_magic_cmd" \
2487 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \
2488 --build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \
2489 || { echo "configure: error: libtool tag configuration failed" 1>&2; exit 1; }
2490 CC="$lt_save_CC"
2491 CFLAGS="$lt_save_CFLAGS"
2492
2493 # Redirect the config.log output again, so that the ltconfig log is not
2494 # clobbered by the next message.
2495 exec 5>>./config.log
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
2506 echo "configure:2507: checking for GNU make" >&5
2507 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
2508   echo $ac_n "(cached) $ac_c" 1>&6
2509 else
2510   _cv_gnu_make_command='' ;
2511           for a in "${MAKE:-make}" make gmake gnumake ; do
2512                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2513                   then
2514                           _cv_gnu_make_command=$a ;
2515                           break;
2516                   fi
2517           done ;
2518
2519 fi
2520
2521 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
2522   if test  "x$_cv_gnu_make_command" != "x"  ; then
2523           ifGNUmake='' ;
2524   else
2525           ifGNUmake='#' ;
2526   fi
2527
2528
2529   if test "x$_cv_gnu_make_command" = "x"; then
2530     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
2531   fi
2532
2533
2534
2535
2536 # Check for c++ or library specific bits that don't require linking.
2537
2538 if test ! -f stamp-sanity-compiler; then
2539   echo $ac_n "checking for g++ that will successfully compile libstdc++-v3""... $ac_c" 1>&6
2540 echo "configure:2541: checking for g++ that will successfully compile libstdc++-v3" >&5
2541
2542   ac_ext=C
2543 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2544 ac_cpp='$CXXCPP $CPPFLAGS'
2545 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2546 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2547 cross_compiling=$ac_cv_prog_cxx_cross
2548
2549   cat > conftest.$ac_ext <<EOF
2550 #line 2551 "configure"
2551 #include "confdefs.h"
2552
2553   #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2554     ok
2555   #endif
2556
2557 EOF
2558 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2559   egrep "ok" >/dev/null 2>&1; then
2560   rm -rf conftest*
2561   gpp_satisfactory=yes
2562 else
2563   rm -rf conftest*
2564   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2565 fi
2566 rm -f conftest*
2567
2568   ac_ext=c
2569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2570 ac_cpp='$CPP $CPPFLAGS'
2571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2573 cross_compiling=$ac_cv_prog_cc_cross
2574
2575   echo "$ac_t""$gpp_satisfactory" 1>&6
2576   touch stamp-sanity-compiler
2577 fi
2578
2579
2580 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2581 # Check whether --enable-debug or --disable-debug was given.
2582 if test "${enable_debug+set}" = set; then
2583   enableval="$enable_debug"
2584   case "${enableval}" in
2585  yes) enable_debug=yes ;;
2586  no)  enable_debug=no ;;
2587  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2588  esac
2589 else
2590   enable_debug=no
2591 fi
2592
2593 case "${enable_debug}" in
2594     yes)
2595         DEBUG_FLAGS='-O0 -ggdb3'
2596         ;;
2597     no)
2598         DEBUG_FLAGS='-g'
2599         ;;
2600 esac
2601
2602
2603 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2604 echo "configure:2605: checking how to run the C preprocessor" >&5
2605 # On Suns, sometimes $CPP names a directory.
2606 if test -n "$CPP" && test -d "$CPP"; then
2607   CPP=
2608 fi
2609 if test -z "$CPP"; then
2610 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2611   echo $ac_n "(cached) $ac_c" 1>&6
2612 else
2613     # This must be in double quotes, not single quotes, because CPP may get
2614   # substituted into the Makefile and "${CC-cc}" will confuse make.
2615   CPP="${CC-cc} -E"
2616   # On the NeXT, cc -E runs the code through the compiler's parser,
2617   # not just through cpp.
2618   cat > conftest.$ac_ext <<EOF
2619 #line 2620 "configure"
2620 #include "confdefs.h"
2621 #include <assert.h>
2622 Syntax Error
2623 EOF
2624 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2625 { (eval echo configure:2626: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2626 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2627 if test -z "$ac_err"; then
2628   :
2629 else
2630   echo "$ac_err" >&5
2631   echo "configure: failed program was:" >&5
2632   cat conftest.$ac_ext >&5
2633   rm -rf conftest*
2634   CPP="${CC-cc} -E -traditional-cpp"
2635   cat > conftest.$ac_ext <<EOF
2636 #line 2637 "configure"
2637 #include "confdefs.h"
2638 #include <assert.h>
2639 Syntax Error
2640 EOF
2641 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2642 { (eval echo configure:2643: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2643 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2644 if test -z "$ac_err"; then
2645   :
2646 else
2647   echo "$ac_err" >&5
2648   echo "configure: failed program was:" >&5
2649   cat conftest.$ac_ext >&5
2650   rm -rf conftest*
2651   CPP="${CC-cc} -nologo -E"
2652   cat > conftest.$ac_ext <<EOF
2653 #line 2654 "configure"
2654 #include "confdefs.h"
2655 #include <assert.h>
2656 Syntax Error
2657 EOF
2658 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2659 { (eval echo configure:2660: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2660 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2661 if test -z "$ac_err"; then
2662   :
2663 else
2664   echo "$ac_err" >&5
2665   echo "configure: failed program was:" >&5
2666   cat conftest.$ac_ext >&5
2667   rm -rf conftest*
2668   CPP=/lib/cpp
2669 fi
2670 rm -f conftest*
2671 fi
2672 rm -f conftest*
2673 fi
2674 rm -f conftest*
2675   ac_cv_prog_CPP="$CPP"
2676 fi
2677   CPP="$ac_cv_prog_CPP"
2678 else
2679   ac_cv_prog_CPP="$CPP"
2680 fi
2681 echo "$ac_t""$CPP" 1>&6
2682
2683
2684   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2685 echo "configure:2686: checking for cstdio to use" >&5
2686   # Check whether --enable-cstdio or --disable-cstdio was given.
2687 if test "${enable_cstdio+set}" = set; then
2688   enableval="$enable_cstdio"
2689   if test x$enable_cstdio = xno; then
2690      enable_cstdio=stdio
2691   fi
2692 else
2693   enable_cstdio=stdio
2694 fi
2695
2696
2697   enable_cstdio_flag=$enable_cstdio
2698
2699     case x${enable_cstdio_flag} in
2700     xlibio)
2701       CSTDIO_H=config/c_io_libio.h
2702       CSTDIO_CC=config/c_io_libio.cc
2703       echo "$ac_t""libio" 1>&6
2704
2705       # see if we are on a system with libio native (ie, linux)
2706       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2707 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2708 echo "configure:2709: checking for libio.h" >&5
2709 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2710   echo $ac_n "(cached) $ac_c" 1>&6
2711 else
2712   cat > conftest.$ac_ext <<EOF
2713 #line 2714 "configure"
2714 #include "confdefs.h"
2715 #include <libio.h>
2716 EOF
2717 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2718 { (eval echo configure:2719: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2719 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2720 if test -z "$ac_err"; then
2721   rm -rf conftest*
2722   eval "ac_cv_header_$ac_safe=yes"
2723 else
2724   echo "$ac_err" >&5
2725   echo "configure: failed program was:" >&5
2726   cat conftest.$ac_ext >&5
2727   rm -rf conftest*
2728   eval "ac_cv_header_$ac_safe=no"
2729 fi
2730 rm -f conftest*
2731 fi
2732 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2733   echo "$ac_t""yes" 1>&6
2734   has_libio=yes
2735 else
2736   echo "$ac_t""no" 1>&6
2737 has_libio=no
2738 fi
2739
2740
2741       # Need to check and see what version of glibc is being used. If
2742       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2743       # compile most of libio for linux systems.
2744       if test x$has_libio = x"yes"; then
2745         case "$target" in
2746           *-*-linux*)
2747               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2748 echo "configure:2749: checking for glibc version >= 2.2" >&5
2749               cat > conftest.$ac_ext <<EOF
2750 #line 2751 "configure"
2751 #include "confdefs.h"
2752
2753             #include <features.h>
2754               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2755                     ok
2756               #endif
2757
2758 EOF
2759 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2760   egrep "ok" >/dev/null 2>&1; then
2761   rm -rf conftest*
2762   glibc_satisfactory=yes
2763 else
2764   rm -rf conftest*
2765   glibc_satisfactory=no
2766 fi
2767 rm -f conftest*
2768
2769               echo "$ac_t""$glibc_satisfactory" 1>&6
2770             ;;
2771         esac
2772
2773         # XXX at the moment, admit defeat and force the recompilation
2774         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2775         glibc_satisfactory=no
2776
2777         if test x$glibc_satisfactory = x"yes"; then
2778            need_libio=no
2779            need_wlibio=no
2780         else
2781            need_libio=yes
2782            # bkoz XXX need to add checks to enable this
2783            # pme XXX here's a first pass at such a check
2784            if test x$enable_c_mbchar != xno; then
2785               need_wlibio=yes
2786            else
2787               need_wlibio=no
2788            fi
2789         fi
2790
2791       else
2792          # Using libio, but <libio.h> doesn't exist on the target system. . .
2793          need_libio=yes
2794          # bkoz XXX need to add checks to enable this
2795          # pme XXX here's a first pass at such a check
2796          if test x$enable_c_mbchar != xno; then
2797              need_wlibio=yes
2798          else
2799              need_wlibio=no
2800          fi
2801       fi
2802       ;;
2803     xstdio | x | xno | xnone | xyes)
2804       # default
2805       CSTDIO_H=config/c_io_stdio.h
2806       CSTDIO_CC=config/c_io_stdio.cc
2807       echo "$ac_t""stdio" 1>&6
2808
2809       # We're not using stdio.
2810       need_libio=no
2811       need_wlibio=no
2812       # Wide characters are not supported with this package.
2813       enable_c_mbchar=no
2814       ;;
2815     *)
2816       echo "$enable_cstdio is an unknown io package" 1>&2
2817       exit 1
2818       ;;
2819   esac
2820
2821
2822
2823   # 2000-08-04 bkoz hack
2824   CCODECVT_C=config/c_io_libio_codecvt.c
2825
2826   # 2000-08-04 bkoz hack
2827
2828
2829
2830 if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2831   GLIBCPP_BUILD_LIBIO_TRUE=
2832   GLIBCPP_BUILD_LIBIO_FALSE='#'
2833 else
2834   GLIBCPP_BUILD_LIBIO_TRUE='#'
2835   GLIBCPP_BUILD_LIBIO_FALSE=
2836 fi
2837
2838
2839 if test "$need_libio" = yes; then
2840   GLIBCPP_NEED_LIBIO_TRUE=
2841   GLIBCPP_NEED_LIBIO_FALSE='#'
2842 else
2843   GLIBCPP_NEED_LIBIO_TRUE='#'
2844   GLIBCPP_NEED_LIBIO_FALSE=
2845 fi
2846
2847
2848 if test "$need_wlibio" = yes; then
2849   GLIBCPP_NEED_WLIBIO_TRUE=
2850   GLIBCPP_NEED_WLIBIO_FALSE='#'
2851 else
2852   GLIBCPP_NEED_WLIBIO_TRUE='#'
2853   GLIBCPP_NEED_WLIBIO_FALSE=
2854 fi
2855   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2856         libio_la=../libio/libio.la
2857   else
2858         libio_la=
2859   fi
2860
2861
2862 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2863 if test "${enable_c_mbchar+set}" = set; then
2864   enableval="$enable_c_mbchar"
2865   case "$enableval" in
2866  yes) enable_c_mbchar=yes ;;
2867  no)  enable_c_mbchar=no ;;
2868  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2869  esac
2870 else
2871   enable_c_mbchar=yes
2872 fi
2873
2874
2875   # Check whether --enable-long-long or --disable-long-long was given.
2876 if test "${enable_long_long+set}" = set; then
2877   enableval="$enable_long_long"
2878     case "$enableval" in
2879    yes) enable_long_long=yes ;;
2880    no)  enable_long_long=no ;;
2881    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2882    esac
2883 else
2884   enable_long_long=yes
2885 fi
2886
2887   # Allow use of os-dependent settings, so that macros that turn on
2888   # C99 capabilities can be defined and used in a consistent way.
2889   OS_INC_PATH=${srcdir}/$os_include_dir
2890   ac_test_CFLAGS="${CFLAGS+set}"
2891   ac_save_CFLAGS="$CFLAGS"
2892   CFLAGS="-I$OS_INC_PATH"
2893
2894   # Check for the existence of functions used if long long is enabled.
2895   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2896 echo "configure:2897: checking for strtoll" >&5
2897 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2898   echo $ac_n "(cached) $ac_c" 1>&6
2899 else
2900   cat > conftest.$ac_ext <<EOF
2901 #line 2902 "configure"
2902 #include "confdefs.h"
2903 /* System header to define __stub macros and hopefully few prototypes,
2904     which can conflict with char strtoll(); below.  */
2905 #include <assert.h>
2906 /* Override any gcc2 internal prototype to avoid an error.  */
2907 /* We use char because int might match the return type of a gcc2
2908     builtin and then its argument prototype would still apply.  */
2909 char strtoll();
2910
2911 int main() {
2912
2913 /* The GNU C library defines this for functions which it implements
2914     to always fail with ENOSYS.  Some functions are actually named
2915     something starting with __ and the normal name is an alias.  */
2916 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2917 choke me
2918 #else
2919 strtoll();
2920 #endif
2921
2922 ; return 0; }
2923 EOF
2924 if { (eval echo configure:2925: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2925   rm -rf conftest*
2926   eval "ac_cv_func_strtoll=yes"
2927 else
2928   echo "configure: failed program was:" >&5
2929   cat conftest.$ac_ext >&5
2930   rm -rf conftest*
2931   eval "ac_cv_func_strtoll=no"
2932 fi
2933 rm -f conftest*
2934 fi
2935
2936 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2937   echo "$ac_t""yes" 1>&6
2938   :
2939 else
2940   echo "$ac_t""no" 1>&6
2941 ac_strtoll=no
2942 fi
2943
2944   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2945 echo "configure:2946: checking for strtoull" >&5
2946 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2947   echo $ac_n "(cached) $ac_c" 1>&6
2948 else
2949   cat > conftest.$ac_ext <<EOF
2950 #line 2951 "configure"
2951 #include "confdefs.h"
2952 /* System header to define __stub macros and hopefully few prototypes,
2953     which can conflict with char strtoull(); below.  */
2954 #include <assert.h>
2955 /* Override any gcc2 internal prototype to avoid an error.  */
2956 /* We use char because int might match the return type of a gcc2
2957     builtin and then its argument prototype would still apply.  */
2958 char strtoull();
2959
2960 int main() {
2961
2962 /* The GNU C library defines this for functions which it implements
2963     to always fail with ENOSYS.  Some functions are actually named
2964     something starting with __ and the normal name is an alias.  */
2965 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2966 choke me
2967 #else
2968 strtoull();
2969 #endif
2970
2971 ; return 0; }
2972 EOF
2973 if { (eval echo configure:2974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2974   rm -rf conftest*
2975   eval "ac_cv_func_strtoull=yes"
2976 else
2977   echo "configure: failed program was:" >&5
2978   cat conftest.$ac_ext >&5
2979   rm -rf conftest*
2980   eval "ac_cv_func_strtoull=no"
2981 fi
2982 rm -f conftest*
2983 fi
2984
2985 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2986   echo "$ac_t""yes" 1>&6
2987   :
2988 else
2989   echo "$ac_t""no" 1>&6
2990 ac_strtoull=no
2991 fi
2992
2993
2994   # Check for lldiv_t, et. al.
2995   echo $ac_n "checking for lldiv_t declaration""... $ac_c" 1>&6
2996 echo "configure:2997: checking for lldiv_t declaration" >&5
2997   if eval "test \"`echo '$''{'glibcpp_lldiv_t_use'+set}'`\" = set"; then
2998   echo $ac_n "(cached) $ac_c" 1>&6
2999 else
3000
3001   cat > conftest.$ac_ext <<EOF
3002 #line 3003 "configure"
3003 #include "confdefs.h"
3004 #include <bits/os_defines.h>
3005                   #include <stdlib.h>
3006 int main() {
3007  lldiv_t mydivt;
3008 ; return 0; }
3009 EOF
3010 if { (eval echo configure:3011: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3011   rm -rf conftest*
3012   glibcpp_lldiv_t_use=yes
3013 else
3014   echo "configure: failed program was:" >&5
3015   cat conftest.$ac_ext >&5
3016   rm -rf conftest*
3017   glibcpp_lldiv_t_use=no
3018 fi
3019 rm -f conftest*
3020
3021 fi
3022
3023   echo "$ac_t""$glibcpp_lldiv_t_use" 1>&6
3024   if test x$glibcpp_lldiv_t_use = x"yes"; then
3025     cat >> confdefs.h <<\EOF
3026 #define HAVE_LLDIV_T 1
3027 EOF
3028
3029   fi
3030
3031   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
3032 echo "configure:3033: checking for enabled long long" >&5
3033   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
3034     enable_long_long=no;
3035   fi;
3036   echo "$ac_t""$enable_long_long" 1>&6
3037
3038   # Option parsed, now set things appropriately
3039   if test x"$enable_long_long" = xyes; then
3040     cat >> confdefs.h <<\EOF
3041 #define _GLIBCPP_USE_LONG_LONG 1
3042 EOF
3043
3044   fi
3045
3046   # Reset CFLAGS
3047   CFLAGS="$ac_save_CFLAGS"
3048
3049 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
3050 echo "configure:3051: checking for enabled cshadow headers" >&5
3051 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
3052 if test "${enable_cshadow_headers+set}" = set; then
3053   enableval="$enable_cshadow_headers"
3054
3055   case "$enableval" in
3056    yes) enable_cshadow_headers=yes
3057         ;;
3058    no)  enable_cshadow_headers=no
3059         ;;
3060    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3061         ;;
3062   esac
3063 else
3064   enable_cshadow_headers=no
3065 fi
3066
3067   echo "$ac_t""$enable_cshadow_headers" 1>&6
3068
3069       case "$enable_cshadow_headers" in
3070     yes)
3071         CSHADOW_FLAGS="-fno-builtin"
3072         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3073         cat >> confdefs.h <<\EOF
3074 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3075 EOF
3076
3077         ;;
3078     no)
3079         CSHADOW_FLAGS=""
3080         C_INCLUDE_DIR='${top_srcdir}/include/c'
3081         ;;
3082   esac
3083
3084
3085
3086
3087
3088 if test "$enable_cshadow_headers" = yes; then
3089   GLIBCPP_USE_CSHADOW_TRUE=
3090   GLIBCPP_USE_CSHADOW_FALSE='#'
3091 else
3092   GLIBCPP_USE_CSHADOW_TRUE='#'
3093   GLIBCPP_USE_CSHADOW_FALSE=
3094 fi
3095
3096
3097       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3098 echo "configure:3099: checking for threads package to use" >&5
3099   # Check whether --enable-threads or --disable-threads was given.
3100 if test "${enable_threads+set}" = set; then
3101   enableval="$enable_threads"
3102   if test x$enable_threads = xno; then
3103     enable_threads=''
3104   fi
3105 else
3106   enable_threads=''
3107 fi
3108
3109
3110   enable_threads_flag=$enable_threads
3111
3112     case x${enable_threads_flag} in
3113         x | xno | xnone)
3114                 # No threads
3115                 target_thread_file='single'
3116                 ;;
3117         xyes)
3118                 # default
3119                 target_thread_file='posix'
3120                 ;;
3121         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3122         xsolaris | xwin32 | xdce | xvxworks)
3123                 target_thread_file=$enable_threads_flag
3124                 ;;
3125         *)
3126                 echo "$enable_threads is an unknown thread package" 1>&2
3127                 exit 1
3128                 ;;
3129   esac
3130
3131     THREADH=
3132   case "$target_thread_file" in
3133     no | none | single)
3134       THREADH=threads-no.h
3135       ;;
3136     posix | pthreads)
3137       THREADH=threads-posix.h
3138       ;;
3139     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3140       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3141       ;;
3142     *)
3143       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3144       ;;
3145   esac
3146   echo "$ac_t""$THREADH" 1>&6
3147
3148
3149   if test $THREADH != threads-no.h; then
3150     cat >> confdefs.h <<\EOF
3151 #define _GLIBCPP_USE_THREADS 1
3152 EOF
3153
3154   fi
3155
3156
3157     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3158 echo "configure:3159: checking for atomicity.h" >&5
3159     # We have ATOMICITY already from GLIBCPP_CONFIGURE
3160     if test "$ATOMICITYH" = "config/cpu/generic"; then
3161       echo "configure: warning: No ATOMICITY settings found, using generic atomic ops." 1>&2
3162     fi
3163     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3164
3165
3166 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3167 if test "${enable_cxx_flags+set}" = set; then
3168   enableval="$enable_cxx_flags"
3169   case "x$enableval" in
3170  xyes)
3171         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3172  xno|x)
3173         enable_cxx_flags='' ;;
3174  *)
3175         enable_cxx_flags="$enableval" ;;
3176  esac
3177 else
3178   enable_cxx_flags='none'
3179 fi
3180
3181
3182 if test "$enable_cxx_flags" = "none"; then
3183   enable_cxx_flags='';
3184 fi
3185
3186 if test -n "$enable_cxx_flags"; then
3187     for f in $enable_cxx_flags; do
3188         case "$f" in
3189             -fhonor-std)  ;;
3190             -*)  ;;
3191             *)   # and we're trying to pass /what/ exactly?
3192                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3193         esac
3194     done
3195 fi
3196 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3197
3198
3199
3200 if test -n "$with_cross_host"; then
3201
3202   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3203   # may not work correctly, because the compiler may not be able to
3204   # link executables.
3205   xcompiling=1
3206   NATIVE=no
3207
3208   # If Canadian cross, then don't pick up tools from the build
3209   # directory.
3210   if test x"$build" != x"$with_cross_host" && x"$build" != x"$target"; then
3211     CANADIAN=yes
3212     NULL_TARGET=yes
3213   else
3214     CANADIAN=no
3215     NULL_TARGET=no
3216   fi
3217
3218   case "$target_alias" in
3219     *-linux-*)
3220         # Construct linux crosses by hand, eliminating bits that need ld...
3221         # Check for available headers.
3222         for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h \
3223         machine/endian.h machine/param.h sys/machine.h fp.h locale.h \
3224         float.h inttypes.h
3225 do
3226 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3227 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3228 echo "configure:3229: checking for $ac_hdr" >&5
3229 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3230   echo $ac_n "(cached) $ac_c" 1>&6
3231 else
3232   cat > conftest.$ac_ext <<EOF
3233 #line 3234 "configure"
3234 #include "confdefs.h"
3235 #include <$ac_hdr>
3236 EOF
3237 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3238 { (eval echo configure:3239: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3239 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3240 if test -z "$ac_err"; then
3241   rm -rf conftest*
3242   eval "ac_cv_header_$ac_safe=yes"
3243 else
3244   echo "$ac_err" >&5
3245   echo "configure: failed program was:" >&5
3246   cat conftest.$ac_ext >&5
3247   rm -rf conftest*
3248   eval "ac_cv_header_$ac_safe=no"
3249 fi
3250 rm -f conftest*
3251 fi
3252 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3253   echo "$ac_t""yes" 1>&6
3254     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3255   cat >> confdefs.h <<EOF
3256 #define $ac_tr_hdr 1
3257 EOF
3258
3259 else
3260   echo "$ac_t""no" 1>&6
3261 fi
3262 done
3263
3264
3265         # GLIBCPP_CHECK_COMPILER_FEATURES
3266         WFMT_FLAGS='-fdiagnostics-show-location=once'
3267         SECTION_FLAGS='-ffunction-sections -fdata-sections'
3268
3269
3270
3271   # If we're not using GNU ld, then there's no point in even trying these
3272   # tests.  Check for that first.  We should have already tested for gld
3273   # by now (in libtool), but require it now just to be safe...
3274   SECTION_LDFLAGS=''
3275   OPT_LDFLAGS=''
3276
3277
3278   # Set --gc-sections.
3279   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
3280     # GNU ld it is!  Joy and bunny rabbits!
3281
3282     # All these tests are for C++; save the language and the compiler flags.
3283     # Need to do this so that g++ won't try to link in libstdc++
3284     ac_test_CFLAGS="${CFLAGS+set}"
3285     ac_save_CFLAGS="$CFLAGS"
3286     CFLAGS='-x c++  -Wl,--gc-sections'
3287
3288     # Check for -Wl,--gc-sections
3289     # XXX This test is broken at the moment, as symbols required for
3290     # linking are now in libsupc++ (not built yet.....). In addition,
3291     # this test has cored on solaris in the past. In addition,
3292     # --gc-sections doesn't really work at the moment (keeps on discarding
3293     # used sections, first .eh_frame and now some of the glibc sections for
3294     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3295     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3296 echo "configure:3297: checking for ld that supports -Wl,--gc-sections" >&5
3297     if test "$cross_compiling" = yes; then
3298   ac_sectionLDflags=yes
3299 else
3300   cat > conftest.$ac_ext <<EOF
3301 #line 3302 "configure"
3302 #include "confdefs.h"
3303
3304      int main(void)
3305      {
3306        try { throw 1; }
3307        catch (...) { };
3308        return 0;
3309      }
3310
3311 EOF
3312 if { (eval echo configure:3313: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3313 then
3314   ac_sectionLDflags=yes
3315 else
3316   echo "configure: failed program was:" >&5
3317   cat conftest.$ac_ext >&5
3318   rm -fr conftest*
3319   ac_sectionLFflags=no
3320 fi
3321 rm -fr conftest*
3322 fi
3323
3324     if test "$ac_test_CFLAGS" = set; then
3325       CFLAGS="$ac_save_CFLAGS"
3326     else
3327       # this is the suspicious part
3328       CFLAGS=''
3329     fi
3330     if test "$ac_sectionLDflags" = "yes"; then
3331       SECTION_LDFLAGS='-Wl,--gc-sections'
3332     fi
3333     echo "$ac_t""$ac_sectionLDflags" 1>&6
3334   fi
3335
3336   # Set linker optimization flags.
3337   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3338     OPT_LDFLAGS='-Wl,-O1'
3339   fi
3340
3341
3342
3343
3344         # GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
3345         # GLIBCPP_CHECK_MATH_SUPPORT
3346         cat >> confdefs.h <<\EOF
3347 #define HAVE_ACOSF 1
3348 EOF
3349
3350         cat >> confdefs.h <<\EOF
3351 #define HAVE_ASINF 1
3352 EOF
3353
3354         cat >> confdefs.h <<\EOF
3355 #define HAVE_ATAN2F 1
3356 EOF
3357
3358         cat >> confdefs.h <<\EOF
3359 #define HAVE_ATANF 1
3360 EOF
3361
3362         cat >> confdefs.h <<\EOF
3363 #define HAVE_CEILF 1
3364 EOF
3365
3366         cat >> confdefs.h <<\EOF
3367 #define HAVE_COPYSIGN 1
3368 EOF
3369
3370         cat >> confdefs.h <<\EOF
3371 #define HAVE_COPYSIGNF 1
3372 EOF
3373
3374         cat >> confdefs.h <<\EOF
3375 #define HAVE_COSF 1
3376 EOF
3377
3378         cat >> confdefs.h <<\EOF
3379 #define HAVE_COSHF 1
3380 EOF
3381
3382         cat >> confdefs.h <<\EOF
3383 #define HAVE_EXPF 1
3384 EOF
3385
3386         cat >> confdefs.h <<\EOF
3387 #define HAVE_FABSF 1
3388 EOF
3389
3390         cat >> confdefs.h <<\EOF
3391 #define HAVE_FINITE 1
3392 EOF
3393
3394         cat >> confdefs.h <<\EOF
3395 #define HAVE_FINITEF 1
3396 EOF
3397
3398         cat >> confdefs.h <<\EOF
3399 #define HAVE_FLOORF 1
3400 EOF
3401
3402         cat >> confdefs.h <<\EOF
3403 #define HAVE_FMODF 1
3404 EOF
3405
3406         cat >> confdefs.h <<\EOF
3407 #define HAVE_FREXPF 1
3408 EOF
3409
3410         cat >> confdefs.h <<\EOF
3411 #define HAVE_ISINF 1
3412 EOF
3413
3414         cat >> confdefs.h <<\EOF
3415 #define HAVE_ISINFF 1
3416 EOF
3417
3418         cat >> confdefs.h <<\EOF
3419 #define HAVE_ISNAN 1
3420 EOF
3421
3422         cat >> confdefs.h <<\EOF
3423 #define HAVE_ISNANF 1
3424 EOF
3425
3426         cat >> confdefs.h <<\EOF
3427 #define HAVE_LDEXPF 1
3428 EOF
3429
3430         cat >> confdefs.h <<\EOF
3431 #define HAVE_LOG10F 1
3432 EOF
3433
3434         cat >> confdefs.h <<\EOF
3435 #define HAVE_LOGF 1
3436 EOF
3437
3438         cat >> confdefs.h <<\EOF
3439 #define HAVE_MODFF 1
3440 EOF
3441
3442         cat >> confdefs.h <<\EOF
3443 #define HAVE_POWF 1
3444 EOF
3445
3446         cat >> confdefs.h <<\EOF
3447 #define HAVE_SINCOS 1
3448 EOF
3449
3450         cat >> confdefs.h <<\EOF
3451 #define HAVE_SINCOSF 1
3452 EOF
3453
3454         cat >> confdefs.h <<\EOF
3455 #define HAVE_SINF 1
3456 EOF
3457
3458         cat >> confdefs.h <<\EOF
3459 #define HAVE_SINHF 1
3460 EOF
3461
3462         cat >> confdefs.h <<\EOF
3463 #define HAVE_SQRTF 1
3464 EOF
3465
3466         cat >> confdefs.h <<\EOF
3467 #define HAVE_TANF 1
3468 EOF
3469
3470         cat >> confdefs.h <<\EOF
3471 #define HAVE_TANHF 1
3472 EOF
3473
3474
3475         # At some point, we should differentiate between architectures
3476         # like x86, which have long double versions, and alpha/powerpc/etc.,
3477         # which don't. For the time being, punt.
3478         if test x"long_double_math_on_this_cpu" = x"yes"; then
3479           cat >> confdefs.h <<\EOF
3480 #define HAVE_ACOSL 1
3481 EOF
3482
3483           cat >> confdefs.h <<\EOF
3484 #define HAVE_ASINL 1
3485 EOF
3486
3487           cat >> confdefs.h <<\EOF
3488 #define HAVE_ATAN2L 1
3489 EOF
3490
3491           cat >> confdefs.h <<\EOF
3492 #define HAVE_ATANL 1
3493 EOF
3494
3495           cat >> confdefs.h <<\EOF
3496 #define HAVE_CEILL 1
3497 EOF
3498
3499           cat >> confdefs.h <<\EOF
3500 #define HAVE_COPYSIGNL 1
3501 EOF
3502
3503           cat >> confdefs.h <<\EOF
3504 #define HAVE_COSL 1
3505 EOF
3506
3507           cat >> confdefs.h <<\EOF
3508 #define HAVE_COSHL 1
3509 EOF
3510
3511           cat >> confdefs.h <<\EOF
3512 #define HAVE_EXPL 1
3513 EOF
3514
3515           cat >> confdefs.h <<\EOF
3516 #define HAVE_FABSL 1
3517 EOF
3518
3519           cat >> confdefs.h <<\EOF
3520 #define HAVE_FINITEL 1
3521 EOF
3522
3523           cat >> confdefs.h <<\EOF
3524 #define HAVE_FLOORL 1
3525 EOF
3526
3527           cat >> confdefs.h <<\EOF
3528 #define HAVE_FMODL 1
3529 EOF
3530
3531           cat >> confdefs.h <<\EOF
3532 #define HAVE_FREXPL 1
3533 EOF
3534
3535           cat >> confdefs.h <<\EOF
3536 #define HAVE_ISINFL 1
3537 EOF
3538
3539           cat >> confdefs.h <<\EOF
3540 #define HAVE_ISNANL 1
3541 EOF
3542
3543           cat >> confdefs.h <<\EOF
3544 #define HAVE_LDEXPL 1
3545 EOF
3546
3547           cat >> confdefs.h <<\EOF
3548 #define HAVE_LOG10L 1
3549 EOF
3550
3551           cat >> confdefs.h <<\EOF
3552 #define HAVE_LOGL 1
3553 EOF
3554
3555           cat >> confdefs.h <<\EOF
3556 #define HAVE_MODFL 1
3557 EOF
3558
3559           cat >> confdefs.h <<\EOF
3560 #define HAVE_POWL 1
3561 EOF
3562
3563           cat >> confdefs.h <<\EOF
3564 #define HAVE_SINCOSL 1
3565 EOF
3566
3567           cat >> confdefs.h <<\EOF
3568 #define HAVE_SINL 1
3569 EOF
3570
3571           cat >> confdefs.h <<\EOF
3572 #define HAVE_SINHL 1
3573 EOF
3574
3575           cat >> confdefs.h <<\EOF
3576 #define HAVE_SQRTL 1
3577 EOF
3578
3579           cat >> confdefs.h <<\EOF
3580 #define HAVE_TANL 1
3581 EOF
3582
3583           cat >> confdefs.h <<\EOF
3584 #define HAVE_TANHL 1
3585 EOF
3586
3587         fi
3588
3589     for ac_hdr in complex.h
3590 do
3591 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3592 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3593 echo "configure:3594: checking for $ac_hdr" >&5
3594 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3595   echo $ac_n "(cached) $ac_c" 1>&6
3596 else
3597   cat > conftest.$ac_ext <<EOF
3598 #line 3599 "configure"
3599 #include "confdefs.h"
3600 #include <$ac_hdr>
3601 EOF
3602 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3603 { (eval echo configure:3604: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3604 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3605 if test -z "$ac_err"; then
3606   rm -rf conftest*
3607   eval "ac_cv_header_$ac_safe=yes"
3608 else
3609   echo "$ac_err" >&5
3610   echo "configure: failed program was:" >&5
3611   cat conftest.$ac_ext >&5
3612   rm -rf conftest*
3613   eval "ac_cv_header_$ac_safe=no"
3614 fi
3615 rm -f conftest*
3616 fi
3617 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3618   echo "$ac_t""yes" 1>&6
3619     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3620   cat >> confdefs.h <<EOF
3621 #define $ac_tr_hdr 1
3622 EOF
3623
3624 else
3625   echo "$ac_t""no" 1>&6
3626 fi
3627 done
3628
3629   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
3630 echo "configure:3631: checking for main in -lm" >&5
3631 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
3632 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
3633   echo $ac_n "(cached) $ac_c" 1>&6
3634 else
3635   ac_save_LIBS="$LIBS"
3636 LIBS="-lm  $LIBS"
3637 cat > conftest.$ac_ext <<EOF
3638 #line 3639 "configure"
3639 #include "confdefs.h"
3640
3641 int main() {
3642 main()
3643 ; return 0; }
3644 EOF
3645 if { (eval echo configure:3646: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3646   rm -rf conftest*
3647   eval "ac_cv_lib_$ac_lib_var=yes"
3648 else
3649   echo "configure: failed program was:" >&5
3650   cat conftest.$ac_ext >&5
3651   rm -rf conftest*
3652   eval "ac_cv_lib_$ac_lib_var=no"
3653 fi
3654 rm -f conftest*
3655 LIBS="$ac_save_LIBS"
3656
3657 fi
3658 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
3659   echo "$ac_t""yes" 1>&6
3660     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
3661     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
3662   cat >> confdefs.h <<EOF
3663 #define $ac_tr_lib 1
3664 EOF
3665
3666   LIBS="-lm $LIBS"
3667
3668 else
3669   echo "$ac_t""no" 1>&6
3670 fi
3671
3672   for ac_func in csqrt csqrtf nan hypot hypotf
3673 do
3674 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3675 echo "configure:3676: checking for $ac_func" >&5
3676 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3677   echo $ac_n "(cached) $ac_c" 1>&6
3678 else
3679   cat > conftest.$ac_ext <<EOF
3680 #line 3681 "configure"
3681 #include "confdefs.h"
3682 /* System header to define __stub macros and hopefully few prototypes,
3683     which can conflict with char $ac_func(); below.  */
3684 #include <assert.h>
3685 /* Override any gcc2 internal prototype to avoid an error.  */
3686 /* We use char because int might match the return type of a gcc2
3687     builtin and then its argument prototype would still apply.  */
3688 char $ac_func();
3689
3690 int main() {
3691
3692 /* The GNU C library defines this for functions which it implements
3693     to always fail with ENOSYS.  Some functions are actually named
3694     something starting with __ and the normal name is an alias.  */
3695 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3696 choke me
3697 #else
3698 $ac_func();
3699 #endif
3700
3701 ; return 0; }
3702 EOF
3703 if { (eval echo configure:3704: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3704   rm -rf conftest*
3705   eval "ac_cv_func_$ac_func=yes"
3706 else
3707   echo "configure: failed program was:" >&5
3708   cat conftest.$ac_ext >&5
3709   rm -rf conftest*
3710   eval "ac_cv_func_$ac_func=no"
3711 fi
3712 rm -f conftest*
3713 fi
3714
3715 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3716   echo "$ac_t""yes" 1>&6
3717     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3718   cat >> confdefs.h <<EOF
3719 #define $ac_tr_func 1
3720 EOF
3721
3722 else
3723   echo "$ac_t""no" 1>&6
3724 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3725 fi
3726 done
3727
3728
3729
3730           USE_COMPLEX_LONG_DOUBLE=no
3731   if test x$ac_cv_func_atan2l = x"yes" \
3732      && test x$ac_cv_func_copysignl = x"yes"; then
3733     USE_COMPLEX_LONG_DOUBLE=yes
3734     for ac_func in csqrtl hypotl signbitl
3735 do
3736 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3737 echo "configure:3738: checking for $ac_func" >&5
3738 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3739   echo $ac_n "(cached) $ac_c" 1>&6
3740 else
3741   cat > conftest.$ac_ext <<EOF
3742 #line 3743 "configure"
3743 #include "confdefs.h"
3744 /* System header to define __stub macros and hopefully few prototypes,
3745     which can conflict with char $ac_func(); below.  */
3746 #include <assert.h>
3747 /* Override any gcc2 internal prototype to avoid an error.  */
3748 /* We use char because int might match the return type of a gcc2
3749     builtin and then its argument prototype would still apply.  */
3750 char $ac_func();
3751
3752 int main() {
3753
3754 /* The GNU C library defines this for functions which it implements
3755     to always fail with ENOSYS.  Some functions are actually named
3756     something starting with __ and the normal name is an alias.  */
3757 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3758 choke me
3759 #else
3760 $ac_func();
3761 #endif
3762
3763 ; return 0; }
3764 EOF
3765 if { (eval echo configure:3766: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3766   rm -rf conftest*
3767   eval "ac_cv_func_$ac_func=yes"
3768 else
3769   echo "configure: failed program was:" >&5
3770   cat conftest.$ac_ext >&5
3771   rm -rf conftest*
3772   eval "ac_cv_func_$ac_func=no"
3773 fi
3774 rm -f conftest*
3775 fi
3776
3777 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3778   echo "$ac_t""yes" 1>&6
3779     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3780   cat >> confdefs.h <<EOF
3781 #define $ac_tr_func 1
3782 EOF
3783
3784 else
3785   echo "$ac_t""no" 1>&6
3786 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3787 fi
3788 done
3789
3790
3791   fi
3792
3793
3794
3795
3796
3797
3798   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
3799 echo "configure:3800: checking for GNU C++ __complex__ support" >&5
3800   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
3801   echo $ac_n "(cached) $ac_c" 1>&6
3802 else
3803
3804
3805     ac_ext=C
3806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3807 ac_cpp='$CXXCPP $CPPFLAGS'
3808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3810 cross_compiling=$ac_cv_prog_cxx_cross
3811
3812     cat > conftest.$ac_ext <<EOF
3813 #line 3814 "configure"
3814 #include "confdefs.h"
3815 struct dcomplex { __complex__ double x; }; \
3816                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
3817 int main() {
3818 \
3819                      dcomplex x; f(x);
3820 ; return 0; }
3821 EOF
3822 if { (eval echo configure:3823: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3823   rm -rf conftest*
3824   glibcpp_cv_complex=ok
3825 else
3826   echo "configure: failed program was:" >&5
3827   cat conftest.$ac_ext >&5
3828   rm -rf conftest*
3829   glibcpp_cv_complex=buggy
3830
3831 fi
3832 rm -f conftest*
3833     ac_ext=c
3834 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3835 ac_cpp='$CPP $CPPFLAGS'
3836 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3837 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3838 cross_compiling=$ac_cv_prog_cc_cross
3839
3840
3841 fi
3842
3843   echo "$ac_t""$glibcpp_cv_complex" 1>&6
3844   if test $glibcpp_cv_complex = buggy; then
3845     cat >> confdefs.h <<\EOF
3846 #define _GLIBCPP_BUGGY_COMPLEX 1
3847 EOF
3848
3849   fi
3850
3851   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
3852 echo "configure:3853: checking for GNU C++ __complex__ float support" >&5
3853   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
3854   echo $ac_n "(cached) $ac_c" 1>&6
3855 else
3856
3857
3858     ac_ext=C
3859 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3860 ac_cpp='$CXXCPP $CPPFLAGS'
3861 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3862 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3863 cross_compiling=$ac_cv_prog_cxx_cross
3864
3865     rm -f conftest.h
3866     cat > conftest.h <<EOB
3867       //
3868       // Check for buggy __complex__ that causes ICE in most versions of egcs
3869       // and gcc-2.95.x on certain platforms (eg., x86-win32).
3870       //
3871       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
3872       // more info on the bug itself.
3873       //
3874       struct
3875       float_complex
3876       {
3877        __complex__ float m_value;
3878        float_complex (float = 0.0f, float = 0.0f);
3879        float_complex (__complex__ float val) : m_value (val) {}
3880        float_complex foo (const float_complex &val)
3881          { return float_complex (~val.m_value); }
3882       };
3883 EOB
3884     cat > conftest.$ac_ext <<EOF
3885 #line 3886 "configure"
3886 #include "confdefs.h"
3887 #include "conftest.h"
3888 int main() {
3889
3890 ; return 0; }
3891 EOF
3892 if { (eval echo configure:3893: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3893   rm -rf conftest*
3894   glibcpp_cv_float_complex=ok
3895 else
3896   echo "configure: failed program was:" >&5
3897   cat conftest.$ac_ext >&5
3898   rm -rf conftest*
3899   glibcpp_cv_float_complex=buggy
3900
3901 fi
3902 rm -f conftest*
3903     ac_ext=c
3904 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3905 ac_cpp='$CPP $CPPFLAGS'
3906 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3907 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3908 cross_compiling=$ac_cv_prog_cc_cross
3909
3910
3911 fi
3912
3913   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
3914   if test $glibcpp_cv_float_complex = buggy; then
3915     cat >> confdefs.h <<\EOF
3916 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3917 EOF
3918
3919   fi
3920
3921
3922   if test x$enable_c_mbchar != xno; then
3923
3924         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
3925 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
3926 echo "configure:3927: checking for wchar.h" >&5
3927 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3928   echo $ac_n "(cached) $ac_c" 1>&6
3929 else
3930   cat > conftest.$ac_ext <<EOF
3931 #line 3932 "configure"
3932 #include "confdefs.h"
3933 #include <wchar.h>
3934 EOF
3935 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3936 { (eval echo configure:3937: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3937 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3938 if test -z "$ac_err"; then
3939   rm -rf conftest*
3940   eval "ac_cv_header_$ac_safe=yes"
3941 else
3942   echo "$ac_err" >&5
3943   echo "configure: failed program was:" >&5
3944   cat conftest.$ac_ext >&5
3945   rm -rf conftest*
3946   eval "ac_cv_header_$ac_safe=no"
3947 fi
3948 rm -f conftest*
3949 fi
3950 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3951   echo "$ac_t""yes" 1>&6
3952   ac_has_wchar_h=yes
3953 else
3954   echo "$ac_t""no" 1>&6
3955 ac_has_wchar_h=no
3956 fi
3957
3958     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
3959 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
3960 echo "configure:3961: checking for wctype.h" >&5
3961 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3962   echo $ac_n "(cached) $ac_c" 1>&6
3963 else
3964   cat > conftest.$ac_ext <<EOF
3965 #line 3966 "configure"
3966 #include "confdefs.h"
3967 #include <wctype.h>
3968 EOF
3969 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3970 { (eval echo configure:3971: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3971 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3972 if test -z "$ac_err"; then
3973   rm -rf conftest*
3974   eval "ac_cv_header_$ac_safe=yes"
3975 else
3976   echo "$ac_err" >&5
3977   echo "configure: failed program was:" >&5
3978   cat conftest.$ac_ext >&5
3979   rm -rf conftest*
3980   eval "ac_cv_header_$ac_safe=no"
3981 fi
3982 rm -f conftest*
3983 fi
3984 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3985   echo "$ac_t""yes" 1>&6
3986   ac_has_wctype_h=yes
3987 else
3988   echo "$ac_t""no" 1>&6
3989 ac_has_wctype_h=no
3990 fi
3991
3992
3993         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
3994
3995                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
3996 echo "configure:3997: checking for mbstate_t" >&5
3997       cat > conftest.$ac_ext <<EOF
3998 #line 3999 "configure"
3999 #include "confdefs.h"
4000 #include <wchar.h>
4001 int main() {
4002 mbstate_t teststate;
4003 ; return 0; }
4004 EOF
4005 if { (eval echo configure:4006: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4006   rm -rf conftest*
4007   use_native_mbstatet=yes
4008 else
4009   echo "configure: failed program was:" >&5
4010   cat conftest.$ac_ext >&5
4011   rm -rf conftest*
4012   use_native_mbstatet=no
4013 fi
4014 rm -f conftest*
4015       echo "$ac_t""$use_native_mbstatet" 1>&6
4016
4017                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
4018 echo "configure:4019: checking for WCHAR_MIN and WCHAR_MAX" >&5
4019       cat > conftest.$ac_ext <<EOF
4020 #line 4021 "configure"
4021 #include "confdefs.h"
4022 #include <wchar.h>
4023 int main() {
4024 int i = WCHAR_MIN; int j = WCHAR_MAX;
4025 ; return 0; }
4026 EOF
4027 if { (eval echo configure:4028: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4028   rm -rf conftest*
4029   has_wchar_minmax=yes
4030 else
4031   echo "configure: failed program was:" >&5
4032   cat conftest.$ac_ext >&5
4033   rm -rf conftest*
4034   has_wchar_minmax=no
4035 fi
4036 rm -f conftest*
4037       echo "$ac_t""$has_wchar_minmax" 1>&6
4038
4039                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
4040 echo "configure:4041: checking for WEOF" >&5
4041       cat > conftest.$ac_ext <<EOF
4042 #line 4043 "configure"
4043 #include "confdefs.h"
4044
4045         #include <wchar.h>
4046         #include <stddef.h>
4047 int main() {
4048 wint_t i = WEOF;
4049 ; return 0; }
4050 EOF
4051 if { (eval echo configure:4052: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4052   rm -rf conftest*
4053   has_weof=yes
4054 else
4055   echo "configure: failed program was:" >&5
4056   cat conftest.$ac_ext >&5
4057   rm -rf conftest*
4058   has_weof=no
4059 fi
4060 rm -f conftest*
4061       echo "$ac_t""$has_weof" 1>&6
4062
4063             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
4064       wcsrtombs mbsrtowcs
4065 do
4066 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4067 echo "configure:4068: checking for $ac_func" >&5
4068 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4069   echo $ac_n "(cached) $ac_c" 1>&6
4070 else
4071   cat > conftest.$ac_ext <<EOF
4072 #line 4073 "configure"
4073 #include "confdefs.h"
4074 /* System header to define __stub macros and hopefully few prototypes,
4075     which can conflict with char $ac_func(); below.  */
4076 #include <assert.h>
4077 /* Override any gcc2 internal prototype to avoid an error.  */
4078 /* We use char because int might match the return type of a gcc2
4079     builtin and then its argument prototype would still apply.  */
4080 char $ac_func();
4081
4082 int main() {
4083
4084 /* The GNU C library defines this for functions which it implements
4085     to always fail with ENOSYS.  Some functions are actually named
4086     something starting with __ and the normal name is an alias.  */
4087 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4088 choke me
4089 #else
4090 $ac_func();
4091 #endif
4092
4093 ; return 0; }
4094 EOF
4095 if { (eval echo configure:4096: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4096   rm -rf conftest*
4097   eval "ac_cv_func_$ac_func=yes"
4098 else
4099   echo "configure: failed program was:" >&5
4100   cat conftest.$ac_ext >&5
4101   rm -rf conftest*
4102   eval "ac_cv_func_$ac_func=no"
4103 fi
4104 rm -f conftest*
4105 fi
4106
4107 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4108   echo "$ac_t""yes" 1>&6
4109     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4110   cat >> confdefs.h <<EOF
4111 #define $ac_tr_func 1
4112 EOF
4113  ac_wfuncs=yes
4114 else
4115   echo "$ac_t""no" 1>&6
4116 ac_wfuncs=no
4117 fi
4118 done
4119
4120
4121       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
4122 echo "configure:4123: checking for ISO C99 wchar_t support" >&5
4123       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
4124          && test x"$ac_wfuncs" = xyes; then
4125         ac_isoC99_wchar_t=yes
4126       else
4127         ac_isoC99_wchar_t=no
4128       fi
4129       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
4130
4131                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
4132 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
4133 echo "configure:4134: checking for iconv.h" >&5
4134 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4135   echo $ac_n "(cached) $ac_c" 1>&6
4136 else
4137   cat > conftest.$ac_ext <<EOF
4138 #line 4139 "configure"
4139 #include "confdefs.h"
4140 #include <iconv.h>
4141 EOF
4142 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4143 { (eval echo configure:4144: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4144 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4145 if test -z "$ac_err"; then
4146   rm -rf conftest*
4147   eval "ac_cv_header_$ac_safe=yes"
4148 else
4149   echo "$ac_err" >&5
4150   echo "configure: failed program was:" >&5
4151   cat conftest.$ac_ext >&5
4152   rm -rf conftest*
4153   eval "ac_cv_header_$ac_safe=no"
4154 fi
4155 rm -f conftest*
4156 fi
4157 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4158   echo "$ac_t""yes" 1>&6
4159   ac_has_iconv_h=yes
4160 else
4161   echo "$ac_t""no" 1>&6
4162 ac_has_iconv_h=no
4163 fi
4164
4165       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
4166 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
4167 echo "configure:4168: checking for langinfo.h" >&5
4168 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4169   echo $ac_n "(cached) $ac_c" 1>&6
4170 else
4171   cat > conftest.$ac_ext <<EOF
4172 #line 4173 "configure"
4173 #include "confdefs.h"
4174 #include <langinfo.h>
4175 EOF
4176 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4177 { (eval echo configure:4178: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4178 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4179 if test -z "$ac_err"; then
4180   rm -rf conftest*
4181   eval "ac_cv_header_$ac_safe=yes"
4182 else
4183   echo "$ac_err" >&5
4184   echo "configure: failed program was:" >&5
4185   cat conftest.$ac_ext >&5
4186   rm -rf conftest*
4187   eval "ac_cv_header_$ac_safe=no"
4188 fi
4189 rm -f conftest*
4190 fi
4191 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4192   echo "$ac_t""yes" 1>&6
4193   ac_has_langinfo_h=yes
4194 else
4195   echo "$ac_t""no" 1>&6
4196 ac_has_langinfo_h=no
4197 fi
4198
4199
4200             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
4201 echo "configure:4202: checking for iconv in -liconv" >&5
4202 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
4203 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4204   echo $ac_n "(cached) $ac_c" 1>&6
4205 else
4206   ac_save_LIBS="$LIBS"
4207 LIBS="-liconv  $LIBS"
4208 cat > conftest.$ac_ext <<EOF
4209 #line 4210 "configure"
4210 #include "confdefs.h"
4211 /* Override any gcc2 internal prototype to avoid an error.  */
4212 /* We use char because int might match the return type of a gcc2
4213     builtin and then its argument prototype would still apply.  */
4214 char iconv();
4215
4216 int main() {
4217 iconv()
4218 ; return 0; }
4219 EOF
4220 if { (eval echo configure:4221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4221   rm -rf conftest*
4222   eval "ac_cv_lib_$ac_lib_var=yes"
4223 else
4224   echo "configure: failed program was:" >&5
4225   cat conftest.$ac_ext >&5
4226   rm -rf conftest*
4227   eval "ac_cv_lib_$ac_lib_var=no"
4228 fi
4229 rm -f conftest*
4230 LIBS="$ac_save_LIBS"
4231
4232 fi
4233 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4234   echo "$ac_t""yes" 1>&6
4235   libiconv="-liconv"
4236 else
4237   echo "$ac_t""no" 1>&6
4238 fi
4239
4240       ac_save_LIBS="$LIBS"
4241       LIBS="$LIBS $libiconv"
4242
4243       for ac_func in iconv_open iconv_close iconv nl_langinfo
4244 do
4245 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4246 echo "configure:4247: checking for $ac_func" >&5
4247 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4248   echo $ac_n "(cached) $ac_c" 1>&6
4249 else
4250   cat > conftest.$ac_ext <<EOF
4251 #line 4252 "configure"
4252 #include "confdefs.h"
4253 /* System header to define __stub macros and hopefully few prototypes,
4254     which can conflict with char $ac_func(); below.  */
4255 #include <assert.h>
4256 /* Override any gcc2 internal prototype to avoid an error.  */
4257 /* We use char because int might match the return type of a gcc2
4258     builtin and then its argument prototype would still apply.  */
4259 char $ac_func();
4260
4261 int main() {
4262
4263 /* The GNU C library defines this for functions which it implements
4264     to always fail with ENOSYS.  Some functions are actually named
4265     something starting with __ and the normal name is an alias.  */
4266 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4267 choke me
4268 #else
4269 $ac_func();
4270 #endif
4271
4272 ; return 0; }
4273 EOF
4274 if { (eval echo configure:4275: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4275   rm -rf conftest*
4276   eval "ac_cv_func_$ac_func=yes"
4277 else
4278   echo "configure: failed program was:" >&5
4279   cat conftest.$ac_ext >&5
4280   rm -rf conftest*
4281   eval "ac_cv_func_$ac_func=no"
4282 fi
4283 rm -f conftest*
4284 fi
4285
4286 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4287   echo "$ac_t""yes" 1>&6
4288     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4289   cat >> confdefs.h <<EOF
4290 #define $ac_tr_func 1
4291 EOF
4292  \
4293       ac_XPG2funcs=yes
4294 else
4295   echo "$ac_t""no" 1>&6
4296 ac_XPG2funcs=no
4297 fi
4298 done
4299
4300
4301       LIBS="$ac_save_LIBS"
4302
4303       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
4304 echo "configure:4305: checking for XPG2 wchar_t support" >&5
4305       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
4306          && test x"$ac_XPG2funcs" = xyes; then
4307         ac_XPG2_wchar_t=yes
4308       else
4309         ac_XPG2_wchar_t=no
4310       fi
4311       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
4312
4313                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
4314 echo "configure:4315: checking for enabled wchar_t specializations" >&5
4315       if test x"$ac_isoC99_wchar_t" = xyes \
4316          && test x"$ac_XPG2_wchar_t" = xyes; then
4317         libinst_wstring_la="libinst-wstring.la"
4318         cat >> confdefs.h <<\EOF
4319 #define _GLIBCPP_USE_WCHAR_T 1
4320 EOF
4321
4322         echo "$ac_t"""yes"" 1>&6
4323       else
4324         libinst_wstring_la=""
4325         echo "$ac_t"""no"" 1>&6
4326       fi
4327
4328
4329     else
4330       echo "configure: warning: <wchar.h> not found" 1>&2
4331     fi
4332
4333   else
4334         :
4335   fi
4336
4337         # GLIBCPP_CHECK_CTYPE_SUPPORT
4338         ctype_include_dir="config/os/gnu-linux"
4339         # GLIBCPP_CHECK_STDLIB_SUPPORT
4340         cat >> confdefs.h <<\EOF
4341 #define HAVE_STRTOF 1
4342 EOF
4343
4344         cat >> confdefs.h <<\EOF
4345 #define HAVE_STRTOLD 1
4346 EOF
4347
4348         # AC_FUNC_MMAP
4349         cat >> confdefs.h <<\EOF
4350 #define HAVE_MMAP 1
4351 EOF
4352
4353         ;;
4354     *)
4355         # We assume newlib.  This lets us hard-code the functions we know
4356         # we'll have.
4357         cat >> confdefs.h <<\EOF
4358 #define HAVE_FINITE 1
4359 EOF
4360
4361         cat >> confdefs.h <<\EOF
4362 #define HAVE_ISNAN 1
4363 EOF
4364
4365         cat >> confdefs.h <<\EOF
4366 #define HAVE_ISNANF 1
4367 EOF
4368
4369         cat >> confdefs.h <<\EOF
4370 #define HAVE_ISINF 1
4371 EOF
4372
4373         cat >> confdefs.h <<\EOF
4374 #define HAVE_ISINFF 1
4375 EOF
4376
4377
4378         ctype_include_dir="config/os/newlib"
4379
4380         cat >> confdefs.h <<\EOF
4381 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
4382 EOF
4383
4384         cat >> confdefs.h <<\EOF
4385 #define _GLIBCPP_BUGGY_COMPLEX 1
4386 EOF
4387
4388         # need to check for faster f versions of math functions, ie sinf?
4389         ;;
4390   esac
4391 else
4392
4393   # We are being configured natively. We can do more elaborate tests
4394   # that include AC_TRY_COMPILE now, as the linker is assumed to be
4395   # working.
4396   xcompiling=0
4397   NATIVE=yes
4398   CANADIAN=no
4399   NULL_TARGET=no
4400
4401   # Check for available headers.
4402   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
4403   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
4404 do
4405 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
4406 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
4407 echo "configure:4408: checking for $ac_hdr" >&5
4408 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4409   echo $ac_n "(cached) $ac_c" 1>&6
4410 else
4411   cat > conftest.$ac_ext <<EOF
4412 #line 4413 "configure"
4413 #include "confdefs.h"
4414 #include <$ac_hdr>
4415 EOF
4416 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4417 { (eval echo configure:4418: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4418 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4419 if test -z "$ac_err"; then
4420   rm -rf conftest*
4421   eval "ac_cv_header_$ac_safe=yes"
4422 else
4423   echo "$ac_err" >&5
4424   echo "configure: failed program was:" >&5
4425   cat conftest.$ac_ext >&5
4426   rm -rf conftest*
4427   eval "ac_cv_header_$ac_safe=no"
4428 fi
4429 rm -f conftest*
4430 fi
4431 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4432   echo "$ac_t""yes" 1>&6
4433     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
4434   cat >> confdefs.h <<EOF
4435 #define $ac_tr_hdr 1
4436 EOF
4437
4438 else
4439   echo "$ac_t""no" 1>&6
4440 fi
4441 done
4442
4443
4444
4445   # All these tests are for C++; save the language and the compiler flags.
4446   # The CXXFLAGS thing is suspicious, but based on similar bits
4447   # found in GLIBCPP_CONFIGURE.
4448
4449   ac_ext=C
4450 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4451 ac_cpp='$CXXCPP $CPPFLAGS'
4452 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4453 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4454 cross_compiling=$ac_cv_prog_cxx_cross
4455
4456   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4457   ac_save_CXXFLAGS="$CXXFLAGS"
4458
4459   # Check for maintainer-mode bits.
4460   if test x"$USE_MAINTAINER_MODE" = xno; then
4461     WERROR=''
4462   else
4463     WERROR='-Werror'
4464   fi
4465
4466   # Check for more sophisticated diagnostic control.
4467   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
4468 echo "configure:4469: checking for g++ that supports -fdiagnostics-show-location=once" >&5
4469   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
4470   cat > conftest.$ac_ext <<EOF
4471 #line 4472 "configure"
4472 #include "confdefs.h"
4473
4474 int main() {
4475 int foo;
4476
4477 ; return 0; }
4478 EOF
4479 if { (eval echo configure:4480: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4480   rm -rf conftest*
4481   ac_gabydiags=yes
4482 else
4483   echo "configure: failed program was:" >&5
4484   cat conftest.$ac_ext >&5
4485   rm -rf conftest*
4486   ac_gabydiags=no
4487 fi
4488 rm -f conftest*
4489   if test "$ac_test_CXXFLAGS" = set; then
4490     CXXFLAGS="$ac_save_CXXFLAGS"
4491   else
4492     # this is the suspicious part
4493     CXXFLAGS=''
4494   fi
4495   if test "$ac_gabydiags" = "yes"; then
4496     WFMT_FLAGS='-fdiagnostics-show-location=once'
4497   fi
4498   echo "$ac_t""$ac_gabydiags" 1>&6
4499
4500   # Check for -ffunction-sections -fdata-sections
4501   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
4502 echo "configure:4503: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
4503   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
4504   cat > conftest.$ac_ext <<EOF
4505 #line 4506 "configure"
4506 #include "confdefs.h"
4507
4508 int main() {
4509 int foo;
4510
4511 ; return 0; }
4512 EOF
4513 if { (eval echo configure:4514: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4514   rm -rf conftest*
4515   ac_fdsections=yes
4516 else
4517   echo "configure: failed program was:" >&5
4518   cat conftest.$ac_ext >&5
4519   rm -rf conftest*
4520   ac_fdsections=no
4521 fi
4522 rm -f conftest*
4523   if test "$ac_test_CXXFLAGS" = set; then
4524     CXXFLAGS="$ac_save_CXXFLAGS"
4525   else
4526     # this is the suspicious part
4527     CXXFLAGS=''
4528   fi
4529   if test "$ac_fdsections" = "yes"; then
4530     SECTION_FLAGS='-ffunction-sections -fdata-sections'
4531   fi
4532   echo "$ac_t""$ac_fdsections" 1>&6
4533
4534   ac_ext=c
4535 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4536 ac_cpp='$CPP $CPPFLAGS'
4537 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4538 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4539 cross_compiling=$ac_cv_prog_cc_cross
4540
4541
4542
4543
4544
4545
4546   # If we're not using GNU ld, then there's no point in even trying these
4547   # tests.  Check for that first.  We should have already tested for gld
4548   # by now (in libtool), but require it now just to be safe...
4549   SECTION_LDFLAGS=''
4550   OPT_LDFLAGS=''
4551
4552
4553   # Set --gc-sections.
4554   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
4555     # GNU ld it is!  Joy and bunny rabbits!
4556
4557     # All these tests are for C++; save the language and the compiler flags.
4558     # Need to do this so that g++ won't try to link in libstdc++
4559     ac_test_CFLAGS="${CFLAGS+set}"
4560     ac_save_CFLAGS="$CFLAGS"
4561     CFLAGS='-x c++  -Wl,--gc-sections'
4562
4563     # Check for -Wl,--gc-sections
4564     # XXX This test is broken at the moment, as symbols required for
4565     # linking are now in libsupc++ (not built yet.....). In addition,
4566     # this test has cored on solaris in the past. In addition,
4567     # --gc-sections doesn't really work at the moment (keeps on discarding
4568     # used sections, first .eh_frame and now some of the glibc sections for
4569     # iconv). Bzzzzt. Thanks for playing, maybe next time.
4570     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
4571 echo "configure:4572: checking for ld that supports -Wl,--gc-sections" >&5
4572     if test "$cross_compiling" = yes; then
4573   ac_sectionLDflags=yes
4574 else
4575   cat > conftest.$ac_ext <<EOF
4576 #line 4577 "configure"
4577 #include "confdefs.h"
4578
4579      int main(void)
4580      {
4581        try { throw 1; }
4582        catch (...) { };
4583        return 0;
4584      }
4585
4586 EOF
4587 if { (eval echo configure:4588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
4588 then
4589   ac_sectionLDflags=yes
4590 else
4591   echo "configure: failed program was:" >&5
4592   cat conftest.$ac_ext >&5
4593   rm -fr conftest*
4594   ac_sectionLFflags=no
4595 fi
4596 rm -fr conftest*
4597 fi
4598
4599     if test "$ac_test_CFLAGS" = set; then
4600       CFLAGS="$ac_save_CFLAGS"
4601     else
4602       # this is the suspicious part
4603       CFLAGS=''
4604     fi
4605     if test "$ac_sectionLDflags" = "yes"; then
4606       SECTION_LDFLAGS='-Wl,--gc-sections'
4607     fi
4608     echo "$ac_t""$ac_sectionLDflags" 1>&6
4609   fi
4610
4611   # Set linker optimization flags.
4612   if test "$ac_cv_prog_gnu_ld" = "yes"; then
4613     OPT_LDFLAGS='-Wl,-O1'
4614   fi
4615
4616
4617
4618
4619
4620
4621   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
4622 echo "configure:4623: checking for __builtin_abs declaration" >&5
4623   if test x${glibcpp_cv_func___builtin_abs_use+set} != xset; then
4624     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
4625   echo $ac_n "(cached) $ac_c" 1>&6
4626 else
4627
4628
4629       ac_ext=C
4630 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4631 ac_cpp='$CXXCPP $CPPFLAGS'
4632 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4633 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4634 cross_compiling=$ac_cv_prog_cxx_cross
4635
4636       cat > conftest.$ac_ext <<EOF
4637 #line 4638 "configure"
4638 #include "confdefs.h"
4639 #include <math.h>
4640 int main() {
4641  __builtin_abs(0);
4642 ; return 0; }
4643 EOF
4644 if { (eval echo configure:4645: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4645   rm -rf conftest*
4646   glibcpp_cv_func___builtin_abs_use=yes
4647 else
4648   echo "configure: failed program was:" >&5
4649   cat conftest.$ac_ext >&5
4650   rm -rf conftest*
4651   glibcpp_cv_func___builtin_abs_use=no
4652 fi
4653 rm -f conftest*
4654       ac_ext=c
4655 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4656 ac_cpp='$CPP $CPPFLAGS'
4657 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4658 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4659 cross_compiling=$ac_cv_prog_cc_cross
4660
4661
4662 fi
4663
4664   fi
4665   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
4666   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
4667     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
4668 echo "configure:4669: checking for __builtin_abs linkage" >&5
4669     if test x${glibcpp_cv_func___builtin_abs_link+set} != xset; then
4670       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
4671   echo $ac_n "(cached) $ac_c" 1>&6
4672 else
4673
4674         cat > conftest.$ac_ext <<EOF
4675 #line 4676 "configure"
4676 #include "confdefs.h"
4677 #include <math.h>
4678 int main() {
4679  __builtin_abs(0);
4680 ; return 0; }
4681 EOF
4682 if { (eval echo configure:4683: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4683   rm -rf conftest*
4684   glibcpp_cv_func___builtin_abs_link=yes
4685 else
4686   echo "configure: failed program was:" >&5
4687   cat conftest.$ac_ext >&5
4688   rm -rf conftest*
4689   glibcpp_cv_func___builtin_abs_link=no
4690 fi
4691 rm -f conftest*
4692
4693 fi
4694
4695     fi
4696     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
4697     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
4698       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4699       cat >> confdefs.h <<EOF
4700 #define ${ac_tr_func} 1
4701 EOF
4702
4703     fi
4704   fi
4705
4706
4707   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
4708 echo "configure:4709: checking for __builtin_fabsf declaration" >&5
4709   if test x${glibcpp_cv_func___builtin_fabsf_use+set} != xset; then
4710     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
4711   echo $ac_n "(cached) $ac_c" 1>&6
4712 else
4713
4714
4715       ac_ext=C
4716 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4717 ac_cpp='$CXXCPP $CPPFLAGS'
4718 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4719 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4720 cross_compiling=$ac_cv_prog_cxx_cross
4721
4722       cat > conftest.$ac_ext <<EOF
4723 #line 4724 "configure"
4724 #include "confdefs.h"
4725 #include <math.h>
4726 int main() {
4727  __builtin_fabsf(0);
4728 ; return 0; }
4729 EOF
4730 if { (eval echo configure:4731: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4731   rm -rf conftest*
4732   glibcpp_cv_func___builtin_fabsf_use=yes
4733 else
4734   echo "configure: failed program was:" >&5
4735   cat conftest.$ac_ext >&5
4736   rm -rf conftest*
4737   glibcpp_cv_func___builtin_fabsf_use=no
4738 fi
4739 rm -f conftest*
4740       ac_ext=c
4741 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4742 ac_cpp='$CPP $CPPFLAGS'
4743 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4744 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4745 cross_compiling=$ac_cv_prog_cc_cross
4746
4747
4748 fi
4749
4750   fi
4751   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
4752   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
4753     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
4754 echo "configure:4755: checking for __builtin_fabsf linkage" >&5
4755     if test x${glibcpp_cv_func___builtin_fabsf_link+set} != xset; then
4756       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
4757   echo $ac_n "(cached) $ac_c" 1>&6
4758 else
4759
4760         cat > conftest.$ac_ext <<EOF
4761 #line 4762 "configure"
4762 #include "confdefs.h"
4763 #include <math.h>
4764 int main() {
4765  __builtin_fabsf(0);
4766 ; return 0; }
4767 EOF
4768 if { (eval echo configure:4769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4769   rm -rf conftest*
4770   glibcpp_cv_func___builtin_fabsf_link=yes
4771 else
4772   echo "configure: failed program was:" >&5
4773   cat conftest.$ac_ext >&5
4774   rm -rf conftest*
4775   glibcpp_cv_func___builtin_fabsf_link=no
4776 fi
4777 rm -f conftest*
4778
4779 fi
4780
4781     fi
4782     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
4783     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
4784       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4785       cat >> confdefs.h <<EOF
4786 #define ${ac_tr_func} 1
4787 EOF
4788
4789     fi
4790   fi
4791
4792
4793   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
4794 echo "configure:4795: checking for __builtin_fabs declaration" >&5
4795   if test x${glibcpp_cv_func___builtin_fabs_use+set} != xset; then
4796     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
4797   echo $ac_n "(cached) $ac_c" 1>&6
4798 else
4799
4800
4801       ac_ext=C
4802 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4803 ac_cpp='$CXXCPP $CPPFLAGS'
4804 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4805 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4806 cross_compiling=$ac_cv_prog_cxx_cross
4807
4808       cat > conftest.$ac_ext <<EOF
4809 #line 4810 "configure"
4810 #include "confdefs.h"
4811 #include <math.h>
4812 int main() {
4813  __builtin_fabs(0);
4814 ; return 0; }
4815 EOF
4816 if { (eval echo configure:4817: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4817   rm -rf conftest*
4818   glibcpp_cv_func___builtin_fabs_use=yes
4819 else
4820   echo "configure: failed program was:" >&5
4821   cat conftest.$ac_ext >&5
4822   rm -rf conftest*
4823   glibcpp_cv_func___builtin_fabs_use=no
4824 fi
4825 rm -f conftest*
4826       ac_ext=c
4827 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4828 ac_cpp='$CPP $CPPFLAGS'
4829 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4830 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4831 cross_compiling=$ac_cv_prog_cc_cross
4832
4833
4834 fi
4835
4836   fi
4837   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
4838   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
4839     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
4840 echo "configure:4841: checking for __builtin_fabs linkage" >&5
4841     if test x${glibcpp_cv_func___builtin_fabs_link+set} != xset; then
4842       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
4843   echo $ac_n "(cached) $ac_c" 1>&6
4844 else
4845
4846         cat > conftest.$ac_ext <<EOF
4847 #line 4848 "configure"
4848 #include "confdefs.h"
4849 #include <math.h>
4850 int main() {
4851  __builtin_fabs(0);
4852 ; return 0; }
4853 EOF
4854 if { (eval echo configure:4855: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4855   rm -rf conftest*
4856   glibcpp_cv_func___builtin_fabs_link=yes
4857 else
4858   echo "configure: failed program was:" >&5
4859   cat conftest.$ac_ext >&5
4860   rm -rf conftest*
4861   glibcpp_cv_func___builtin_fabs_link=no
4862 fi
4863 rm -f conftest*
4864
4865 fi
4866
4867     fi
4868     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
4869     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
4870       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4871       cat >> confdefs.h <<EOF
4872 #define ${ac_tr_func} 1
4873 EOF
4874
4875     fi
4876   fi
4877
4878
4879   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
4880 echo "configure:4881: checking for __builtin_fabsl declaration" >&5
4881   if test x${glibcpp_cv_func___builtin_fabsl_use+set} != xset; then
4882     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
4883   echo $ac_n "(cached) $ac_c" 1>&6
4884 else
4885
4886
4887       ac_ext=C
4888 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4889 ac_cpp='$CXXCPP $CPPFLAGS'
4890 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4891 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4892 cross_compiling=$ac_cv_prog_cxx_cross
4893
4894       cat > conftest.$ac_ext <<EOF
4895 #line 4896 "configure"
4896 #include "confdefs.h"
4897 #include <math.h>
4898 int main() {
4899  __builtin_fabsl(0);
4900 ; return 0; }
4901 EOF
4902 if { (eval echo configure:4903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4903   rm -rf conftest*
4904   glibcpp_cv_func___builtin_fabsl_use=yes
4905 else
4906   echo "configure: failed program was:" >&5
4907   cat conftest.$ac_ext >&5
4908   rm -rf conftest*
4909   glibcpp_cv_func___builtin_fabsl_use=no
4910 fi
4911 rm -f conftest*
4912       ac_ext=c
4913 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4914 ac_cpp='$CPP $CPPFLAGS'
4915 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4916 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4917 cross_compiling=$ac_cv_prog_cc_cross
4918
4919
4920 fi
4921
4922   fi
4923   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
4924   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
4925     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
4926 echo "configure:4927: checking for __builtin_fabsl linkage" >&5
4927     if test x${glibcpp_cv_func___builtin_fabsl_link+set} != xset; then
4928       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
4929   echo $ac_n "(cached) $ac_c" 1>&6
4930 else
4931
4932         cat > conftest.$ac_ext <<EOF
4933 #line 4934 "configure"
4934 #include "confdefs.h"
4935 #include <math.h>
4936 int main() {
4937  __builtin_fabsl(0);
4938 ; return 0; }
4939 EOF
4940 if { (eval echo configure:4941: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4941   rm -rf conftest*
4942   glibcpp_cv_func___builtin_fabsl_link=yes
4943 else
4944   echo "configure: failed program was:" >&5
4945   cat conftest.$ac_ext >&5
4946   rm -rf conftest*
4947   glibcpp_cv_func___builtin_fabsl_link=no
4948 fi
4949 rm -f conftest*
4950
4951 fi
4952
4953     fi
4954     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
4955     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
4956       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4957       cat >> confdefs.h <<EOF
4958 #define ${ac_tr_func} 1
4959 EOF
4960
4961     fi
4962   fi
4963
4964
4965   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
4966 echo "configure:4967: checking for __builtin_labs declaration" >&5
4967   if test x${glibcpp_cv_func___builtin_labs_use+set} != xset; then
4968     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
4969   echo $ac_n "(cached) $ac_c" 1>&6
4970 else
4971
4972
4973       ac_ext=C
4974 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4975 ac_cpp='$CXXCPP $CPPFLAGS'
4976 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4977 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4978 cross_compiling=$ac_cv_prog_cxx_cross
4979
4980       cat > conftest.$ac_ext <<EOF
4981 #line 4982 "configure"
4982 #include "confdefs.h"
4983 #include <math.h>
4984 int main() {
4985  __builtin_labs(0);
4986 ; return 0; }
4987 EOF
4988 if { (eval echo configure:4989: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4989   rm -rf conftest*
4990   glibcpp_cv_func___builtin_labs_use=yes
4991 else
4992   echo "configure: failed program was:" >&5
4993   cat conftest.$ac_ext >&5
4994   rm -rf conftest*
4995   glibcpp_cv_func___builtin_labs_use=no
4996 fi
4997 rm -f conftest*
4998       ac_ext=c
4999 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5000 ac_cpp='$CPP $CPPFLAGS'
5001 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5002 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5003 cross_compiling=$ac_cv_prog_cc_cross
5004
5005
5006 fi
5007
5008   fi
5009   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
5010   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
5011     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
5012 echo "configure:5013: checking for __builtin_labs linkage" >&5
5013     if test x${glibcpp_cv_func___builtin_labs_link+set} != xset; then
5014       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
5015   echo $ac_n "(cached) $ac_c" 1>&6
5016 else
5017
5018         cat > conftest.$ac_ext <<EOF
5019 #line 5020 "configure"
5020 #include "confdefs.h"
5021 #include <math.h>
5022 int main() {
5023  __builtin_labs(0);
5024 ; return 0; }
5025 EOF
5026 if { (eval echo configure:5027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5027   rm -rf conftest*
5028   glibcpp_cv_func___builtin_labs_link=yes
5029 else
5030   echo "configure: failed program was:" >&5
5031   cat conftest.$ac_ext >&5
5032   rm -rf conftest*
5033   glibcpp_cv_func___builtin_labs_link=no
5034 fi
5035 rm -f conftest*
5036
5037 fi
5038
5039     fi
5040     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
5041     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
5042       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5043       cat >> confdefs.h <<EOF
5044 #define ${ac_tr_func} 1
5045 EOF
5046
5047     fi
5048   fi
5049
5050
5051
5052   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
5053 echo "configure:5054: checking for __builtin_sqrtf declaration" >&5
5054   if test x${glibcpp_cv_func___builtin_sqrtf_use+set} != xset; then
5055     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
5056   echo $ac_n "(cached) $ac_c" 1>&6
5057 else
5058
5059
5060       ac_ext=C
5061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5062 ac_cpp='$CXXCPP $CPPFLAGS'
5063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5065 cross_compiling=$ac_cv_prog_cxx_cross
5066
5067       cat > conftest.$ac_ext <<EOF
5068 #line 5069 "configure"
5069 #include "confdefs.h"
5070 #include <math.h>
5071 int main() {
5072  __builtin_sqrtf(0);
5073 ; return 0; }
5074 EOF
5075 if { (eval echo configure:5076: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5076   rm -rf conftest*
5077   glibcpp_cv_func___builtin_sqrtf_use=yes
5078 else
5079   echo "configure: failed program was:" >&5
5080   cat conftest.$ac_ext >&5
5081   rm -rf conftest*
5082   glibcpp_cv_func___builtin_sqrtf_use=no
5083 fi
5084 rm -f conftest*
5085       ac_ext=c
5086 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5087 ac_cpp='$CPP $CPPFLAGS'
5088 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5089 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5090 cross_compiling=$ac_cv_prog_cc_cross
5091
5092
5093 fi
5094
5095   fi
5096   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
5097   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
5098     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
5099 echo "configure:5100: checking for __builtin_sqrtf linkage" >&5
5100     if test x${glibcpp_cv_func___builtin_sqrtf_link+set} != xset; then
5101       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
5102   echo $ac_n "(cached) $ac_c" 1>&6
5103 else
5104
5105         cat > conftest.$ac_ext <<EOF
5106 #line 5107 "configure"
5107 #include "confdefs.h"
5108 #include <math.h>
5109 int main() {
5110  __builtin_sqrtf(0);
5111 ; return 0; }
5112 EOF
5113 if { (eval echo configure:5114: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5114   rm -rf conftest*
5115   glibcpp_cv_func___builtin_sqrtf_link=yes
5116 else
5117   echo "configure: failed program was:" >&5
5118   cat conftest.$ac_ext >&5
5119   rm -rf conftest*
5120   glibcpp_cv_func___builtin_sqrtf_link=no
5121 fi
5122 rm -f conftest*
5123
5124 fi
5125
5126     fi
5127     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
5128     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
5129       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5130       cat >> confdefs.h <<EOF
5131 #define ${ac_tr_func} 1
5132 EOF
5133
5134     fi
5135   fi
5136
5137
5138   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
5139 echo "configure:5140: checking for __builtin_fsqrt declaration" >&5
5140   if test x${glibcpp_cv_func___builtin_fsqrt_use+set} != xset; then
5141     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
5142   echo $ac_n "(cached) $ac_c" 1>&6
5143 else
5144
5145
5146       ac_ext=C
5147 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5148 ac_cpp='$CXXCPP $CPPFLAGS'
5149 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5150 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5151 cross_compiling=$ac_cv_prog_cxx_cross
5152
5153       cat > conftest.$ac_ext <<EOF
5154 #line 5155 "configure"
5155 #include "confdefs.h"
5156 #include <math.h>
5157 int main() {
5158  __builtin_fsqrt(0);
5159 ; return 0; }
5160 EOF
5161 if { (eval echo configure:5162: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5162   rm -rf conftest*
5163   glibcpp_cv_func___builtin_fsqrt_use=yes
5164 else
5165   echo "configure: failed program was:" >&5
5166   cat conftest.$ac_ext >&5
5167   rm -rf conftest*
5168   glibcpp_cv_func___builtin_fsqrt_use=no
5169 fi
5170 rm -f conftest*
5171       ac_ext=c
5172 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5173 ac_cpp='$CPP $CPPFLAGS'
5174 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5175 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5176 cross_compiling=$ac_cv_prog_cc_cross
5177
5178
5179 fi
5180
5181   fi
5182   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
5183   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
5184     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
5185 echo "configure:5186: checking for __builtin_fsqrt linkage" >&5
5186     if test x${glibcpp_cv_func___builtin_fsqrt_link+set} != xset; then
5187       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
5188   echo $ac_n "(cached) $ac_c" 1>&6
5189 else
5190
5191         cat > conftest.$ac_ext <<EOF
5192 #line 5193 "configure"
5193 #include "confdefs.h"
5194 #include <math.h>
5195 int main() {
5196  __builtin_fsqrt(0);
5197 ; return 0; }
5198 EOF
5199 if { (eval echo configure:5200: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5200   rm -rf conftest*
5201   glibcpp_cv_func___builtin_fsqrt_link=yes
5202 else
5203   echo "configure: failed program was:" >&5
5204   cat conftest.$ac_ext >&5
5205   rm -rf conftest*
5206   glibcpp_cv_func___builtin_fsqrt_link=no
5207 fi
5208 rm -f conftest*
5209
5210 fi
5211
5212     fi
5213     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
5214     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
5215       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5216       cat >> confdefs.h <<EOF
5217 #define ${ac_tr_func} 1
5218 EOF
5219
5220     fi
5221   fi
5222
5223
5224   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
5225 echo "configure:5226: checking for __builtin_sqrtl declaration" >&5
5226   if test x${glibcpp_cv_func___builtin_sqrtl_use+set} != xset; then
5227     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
5228   echo $ac_n "(cached) $ac_c" 1>&6
5229 else
5230
5231
5232       ac_ext=C
5233 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5234 ac_cpp='$CXXCPP $CPPFLAGS'
5235 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5236 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5237 cross_compiling=$ac_cv_prog_cxx_cross
5238
5239       cat > conftest.$ac_ext <<EOF
5240 #line 5241 "configure"
5241 #include "confdefs.h"
5242 #include <math.h>
5243 int main() {
5244  __builtin_sqrtl(0);
5245 ; return 0; }
5246 EOF
5247 if { (eval echo configure:5248: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5248   rm -rf conftest*
5249   glibcpp_cv_func___builtin_sqrtl_use=yes
5250 else
5251   echo "configure: failed program was:" >&5
5252   cat conftest.$ac_ext >&5
5253   rm -rf conftest*
5254   glibcpp_cv_func___builtin_sqrtl_use=no
5255 fi
5256 rm -f conftest*
5257       ac_ext=c
5258 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5259 ac_cpp='$CPP $CPPFLAGS'
5260 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5261 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5262 cross_compiling=$ac_cv_prog_cc_cross
5263
5264
5265 fi
5266
5267   fi
5268   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
5269   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
5270     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
5271 echo "configure:5272: checking for __builtin_sqrtl linkage" >&5
5272     if test x${glibcpp_cv_func___builtin_sqrtl_link+set} != xset; then
5273       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
5274   echo $ac_n "(cached) $ac_c" 1>&6
5275 else
5276
5277         cat > conftest.$ac_ext <<EOF
5278 #line 5279 "configure"
5279 #include "confdefs.h"
5280 #include <math.h>
5281 int main() {
5282  __builtin_sqrtl(0);
5283 ; return 0; }
5284 EOF
5285 if { (eval echo configure:5286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5286   rm -rf conftest*
5287   glibcpp_cv_func___builtin_sqrtl_link=yes
5288 else
5289   echo "configure: failed program was:" >&5
5290   cat conftest.$ac_ext >&5
5291   rm -rf conftest*
5292   glibcpp_cv_func___builtin_sqrtl_link=no
5293 fi
5294 rm -f conftest*
5295
5296 fi
5297
5298     fi
5299     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
5300     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
5301       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5302       cat >> confdefs.h <<EOF
5303 #define ${ac_tr_func} 1
5304 EOF
5305
5306     fi
5307   fi
5308
5309
5310
5311   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
5312 echo "configure:5313: checking for __builtin_sinf declaration" >&5
5313   if test x${glibcpp_cv_func___builtin_sinf_use+set} != xset; then
5314     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
5315   echo $ac_n "(cached) $ac_c" 1>&6
5316 else
5317
5318
5319       ac_ext=C
5320 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5321 ac_cpp='$CXXCPP $CPPFLAGS'
5322 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5323 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5324 cross_compiling=$ac_cv_prog_cxx_cross
5325
5326       cat > conftest.$ac_ext <<EOF
5327 #line 5328 "configure"
5328 #include "confdefs.h"
5329 #include <math.h>
5330 int main() {
5331  __builtin_sinf(0);
5332 ; return 0; }
5333 EOF
5334 if { (eval echo configure:5335: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5335   rm -rf conftest*
5336   glibcpp_cv_func___builtin_sinf_use=yes
5337 else
5338   echo "configure: failed program was:" >&5
5339   cat conftest.$ac_ext >&5
5340   rm -rf conftest*
5341   glibcpp_cv_func___builtin_sinf_use=no
5342 fi
5343 rm -f conftest*
5344       ac_ext=c
5345 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5346 ac_cpp='$CPP $CPPFLAGS'
5347 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5348 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5349 cross_compiling=$ac_cv_prog_cc_cross
5350
5351
5352 fi
5353
5354   fi
5355   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
5356   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
5357     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
5358 echo "configure:5359: checking for __builtin_sinf linkage" >&5
5359     if test x${glibcpp_cv_func___builtin_sinf_link+set} != xset; then
5360       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
5361   echo $ac_n "(cached) $ac_c" 1>&6
5362 else
5363
5364         cat > conftest.$ac_ext <<EOF
5365 #line 5366 "configure"
5366 #include "confdefs.h"
5367 #include <math.h>
5368 int main() {
5369  __builtin_sinf(0);
5370 ; return 0; }
5371 EOF
5372 if { (eval echo configure:5373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5373   rm -rf conftest*
5374   glibcpp_cv_func___builtin_sinf_link=yes
5375 else
5376   echo "configure: failed program was:" >&5
5377   cat conftest.$ac_ext >&5
5378   rm -rf conftest*
5379   glibcpp_cv_func___builtin_sinf_link=no
5380 fi
5381 rm -f conftest*
5382
5383 fi
5384
5385     fi
5386     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
5387     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
5388       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5389       cat >> confdefs.h <<EOF
5390 #define ${ac_tr_func} 1
5391 EOF
5392
5393     fi
5394   fi
5395
5396
5397   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
5398 echo "configure:5399: checking for __builtin_sin declaration" >&5
5399   if test x${glibcpp_cv_func___builtin_sin_use+set} != xset; then
5400     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
5401   echo $ac_n "(cached) $ac_c" 1>&6
5402 else
5403
5404
5405       ac_ext=C
5406 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5407 ac_cpp='$CXXCPP $CPPFLAGS'
5408 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5409 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5410 cross_compiling=$ac_cv_prog_cxx_cross
5411
5412       cat > conftest.$ac_ext <<EOF
5413 #line 5414 "configure"
5414 #include "confdefs.h"
5415 #include <math.h>
5416 int main() {
5417  __builtin_sin(0);
5418 ; return 0; }
5419 EOF
5420 if { (eval echo configure:5421: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5421   rm -rf conftest*
5422   glibcpp_cv_func___builtin_sin_use=yes
5423 else
5424   echo "configure: failed program was:" >&5
5425   cat conftest.$ac_ext >&5
5426   rm -rf conftest*
5427   glibcpp_cv_func___builtin_sin_use=no
5428 fi
5429 rm -f conftest*
5430       ac_ext=c
5431 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5432 ac_cpp='$CPP $CPPFLAGS'
5433 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5434 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5435 cross_compiling=$ac_cv_prog_cc_cross
5436
5437
5438 fi
5439
5440   fi
5441   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
5442   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
5443     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
5444 echo "configure:5445: checking for __builtin_sin linkage" >&5
5445     if test x${glibcpp_cv_func___builtin_sin_link+set} != xset; then
5446       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
5447   echo $ac_n "(cached) $ac_c" 1>&6
5448 else
5449
5450         cat > conftest.$ac_ext <<EOF
5451 #line 5452 "configure"
5452 #include "confdefs.h"
5453 #include <math.h>
5454 int main() {
5455  __builtin_sin(0);
5456 ; return 0; }
5457 EOF
5458 if { (eval echo configure:5459: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5459   rm -rf conftest*
5460   glibcpp_cv_func___builtin_sin_link=yes
5461 else
5462   echo "configure: failed program was:" >&5
5463   cat conftest.$ac_ext >&5
5464   rm -rf conftest*
5465   glibcpp_cv_func___builtin_sin_link=no
5466 fi
5467 rm -f conftest*
5468
5469 fi
5470
5471     fi
5472     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
5473     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
5474       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5475       cat >> confdefs.h <<EOF
5476 #define ${ac_tr_func} 1
5477 EOF
5478
5479     fi
5480   fi
5481
5482
5483   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
5484 echo "configure:5485: checking for __builtin_sinl declaration" >&5
5485   if test x${glibcpp_cv_func___builtin_sinl_use+set} != xset; then
5486     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
5487   echo $ac_n "(cached) $ac_c" 1>&6
5488 else
5489
5490
5491       ac_ext=C
5492 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5493 ac_cpp='$CXXCPP $CPPFLAGS'
5494 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5495 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5496 cross_compiling=$ac_cv_prog_cxx_cross
5497
5498       cat > conftest.$ac_ext <<EOF
5499 #line 5500 "configure"
5500 #include "confdefs.h"
5501 #include <math.h>
5502 int main() {
5503  __builtin_sinl(0);
5504 ; return 0; }
5505 EOF
5506 if { (eval echo configure:5507: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5507   rm -rf conftest*
5508   glibcpp_cv_func___builtin_sinl_use=yes
5509 else
5510   echo "configure: failed program was:" >&5
5511   cat conftest.$ac_ext >&5
5512   rm -rf conftest*
5513   glibcpp_cv_func___builtin_sinl_use=no
5514 fi
5515 rm -f conftest*
5516       ac_ext=c
5517 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5518 ac_cpp='$CPP $CPPFLAGS'
5519 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5520 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5521 cross_compiling=$ac_cv_prog_cc_cross
5522
5523
5524 fi
5525
5526   fi
5527   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
5528   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
5529     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
5530 echo "configure:5531: checking for __builtin_sinl linkage" >&5
5531     if test x${glibcpp_cv_func___builtin_sinl_link+set} != xset; then
5532       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
5533   echo $ac_n "(cached) $ac_c" 1>&6
5534 else
5535
5536         cat > conftest.$ac_ext <<EOF
5537 #line 5538 "configure"
5538 #include "confdefs.h"
5539 #include <math.h>
5540 int main() {
5541  __builtin_sinl(0);
5542 ; return 0; }
5543 EOF
5544 if { (eval echo configure:5545: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5545   rm -rf conftest*
5546   glibcpp_cv_func___builtin_sinl_link=yes
5547 else
5548   echo "configure: failed program was:" >&5
5549   cat conftest.$ac_ext >&5
5550   rm -rf conftest*
5551   glibcpp_cv_func___builtin_sinl_link=no
5552 fi
5553 rm -f conftest*
5554
5555 fi
5556
5557     fi
5558     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
5559     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
5560       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5561       cat >> confdefs.h <<EOF
5562 #define ${ac_tr_func} 1
5563 EOF
5564
5565     fi
5566   fi
5567
5568
5569
5570   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
5571 echo "configure:5572: checking for __builtin_cosf declaration" >&5
5572   if test x${glibcpp_cv_func___builtin_cosf_use+set} != xset; then
5573     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
5574   echo $ac_n "(cached) $ac_c" 1>&6
5575 else
5576
5577
5578       ac_ext=C
5579 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5580 ac_cpp='$CXXCPP $CPPFLAGS'
5581 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5582 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5583 cross_compiling=$ac_cv_prog_cxx_cross
5584
5585       cat > conftest.$ac_ext <<EOF
5586 #line 5587 "configure"
5587 #include "confdefs.h"
5588 #include <math.h>
5589 int main() {
5590  __builtin_cosf(0);
5591 ; return 0; }
5592 EOF
5593 if { (eval echo configure:5594: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5594   rm -rf conftest*
5595   glibcpp_cv_func___builtin_cosf_use=yes
5596 else
5597   echo "configure: failed program was:" >&5
5598   cat conftest.$ac_ext >&5
5599   rm -rf conftest*
5600   glibcpp_cv_func___builtin_cosf_use=no
5601 fi
5602 rm -f conftest*
5603       ac_ext=c
5604 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5605 ac_cpp='$CPP $CPPFLAGS'
5606 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5607 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5608 cross_compiling=$ac_cv_prog_cc_cross
5609
5610
5611 fi
5612
5613   fi
5614   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
5615   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
5616     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
5617 echo "configure:5618: checking for __builtin_cosf linkage" >&5
5618     if test x${glibcpp_cv_func___builtin_cosf_link+set} != xset; then
5619       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
5620   echo $ac_n "(cached) $ac_c" 1>&6
5621 else
5622
5623         cat > conftest.$ac_ext <<EOF
5624 #line 5625 "configure"
5625 #include "confdefs.h"
5626 #include <math.h>
5627 int main() {
5628  __builtin_cosf(0);
5629 ; return 0; }
5630 EOF
5631 if { (eval echo configure:5632: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5632   rm -rf conftest*
5633   glibcpp_cv_func___builtin_cosf_link=yes
5634 else
5635   echo "configure: failed program was:" >&5
5636   cat conftest.$ac_ext >&5
5637   rm -rf conftest*
5638   glibcpp_cv_func___builtin_cosf_link=no
5639 fi
5640 rm -f conftest*
5641
5642 fi
5643
5644     fi
5645     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
5646     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
5647       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5648       cat >> confdefs.h <<EOF
5649 #define ${ac_tr_func} 1
5650 EOF
5651
5652     fi
5653   fi
5654
5655
5656   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
5657 echo "configure:5658: checking for __builtin_cos declaration" >&5
5658   if test x${glibcpp_cv_func___builtin_cos_use+set} != xset; then
5659     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
5660   echo $ac_n "(cached) $ac_c" 1>&6
5661 else
5662
5663
5664       ac_ext=C
5665 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5666 ac_cpp='$CXXCPP $CPPFLAGS'
5667 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5668 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5669 cross_compiling=$ac_cv_prog_cxx_cross
5670
5671       cat > conftest.$ac_ext <<EOF
5672 #line 5673 "configure"
5673 #include "confdefs.h"
5674 #include <math.h>
5675 int main() {
5676  __builtin_cos(0);
5677 ; return 0; }
5678 EOF
5679 if { (eval echo configure:5680: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5680   rm -rf conftest*
5681   glibcpp_cv_func___builtin_cos_use=yes
5682 else
5683   echo "configure: failed program was:" >&5
5684   cat conftest.$ac_ext >&5
5685   rm -rf conftest*
5686   glibcpp_cv_func___builtin_cos_use=no
5687 fi
5688 rm -f conftest*
5689       ac_ext=c
5690 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5691 ac_cpp='$CPP $CPPFLAGS'
5692 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5693 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5694 cross_compiling=$ac_cv_prog_cc_cross
5695
5696
5697 fi
5698
5699   fi
5700   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
5701   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
5702     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
5703 echo "configure:5704: checking for __builtin_cos linkage" >&5
5704     if test x${glibcpp_cv_func___builtin_cos_link+set} != xset; then
5705       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
5706   echo $ac_n "(cached) $ac_c" 1>&6
5707 else
5708
5709         cat > conftest.$ac_ext <<EOF
5710 #line 5711 "configure"
5711 #include "confdefs.h"
5712 #include <math.h>
5713 int main() {
5714  __builtin_cos(0);
5715 ; return 0; }
5716 EOF
5717 if { (eval echo configure:5718: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5718   rm -rf conftest*
5719   glibcpp_cv_func___builtin_cos_link=yes
5720 else
5721   echo "configure: failed program was:" >&5
5722   cat conftest.$ac_ext >&5
5723   rm -rf conftest*
5724   glibcpp_cv_func___builtin_cos_link=no
5725 fi
5726 rm -f conftest*
5727
5728 fi
5729
5730     fi
5731     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
5732     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
5733       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5734       cat >> confdefs.h <<EOF
5735 #define ${ac_tr_func} 1
5736 EOF
5737
5738     fi
5739   fi
5740
5741
5742   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
5743 echo "configure:5744: checking for __builtin_cosl declaration" >&5
5744   if test x${glibcpp_cv_func___builtin_cosl_use+set} != xset; then
5745     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
5746   echo $ac_n "(cached) $ac_c" 1>&6
5747 else
5748
5749
5750       ac_ext=C
5751 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5752 ac_cpp='$CXXCPP $CPPFLAGS'
5753 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5754 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5755 cross_compiling=$ac_cv_prog_cxx_cross
5756
5757       cat > conftest.$ac_ext <<EOF
5758 #line 5759 "configure"
5759 #include "confdefs.h"
5760 #include <math.h>
5761 int main() {
5762  __builtin_cosl(0);
5763 ; return 0; }
5764 EOF
5765 if { (eval echo configure:5766: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5766   rm -rf conftest*
5767   glibcpp_cv_func___builtin_cosl_use=yes
5768 else
5769   echo "configure: failed program was:" >&5
5770   cat conftest.$ac_ext >&5
5771   rm -rf conftest*
5772   glibcpp_cv_func___builtin_cosl_use=no
5773 fi
5774 rm -f conftest*
5775       ac_ext=c
5776 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5777 ac_cpp='$CPP $CPPFLAGS'
5778 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5779 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5780 cross_compiling=$ac_cv_prog_cc_cross
5781
5782
5783 fi
5784
5785   fi
5786   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
5787   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
5788     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
5789 echo "configure:5790: checking for __builtin_cosl linkage" >&5
5790     if test x${glibcpp_cv_func___builtin_cosl_link+set} != xset; then
5791       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
5792   echo $ac_n "(cached) $ac_c" 1>&6
5793 else
5794
5795         cat > conftest.$ac_ext <<EOF
5796 #line 5797 "configure"
5797 #include "confdefs.h"
5798 #include <math.h>
5799 int main() {
5800  __builtin_cosl(0);
5801 ; return 0; }
5802 EOF
5803 if { (eval echo configure:5804: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5804   rm -rf conftest*
5805   glibcpp_cv_func___builtin_cosl_link=yes
5806 else
5807   echo "configure: failed program was:" >&5
5808   cat conftest.$ac_ext >&5
5809   rm -rf conftest*
5810   glibcpp_cv_func___builtin_cosl_link=no
5811 fi
5812 rm -f conftest*
5813
5814 fi
5815
5816     fi
5817     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
5818     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
5819       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5820       cat >> confdefs.h <<EOF
5821 #define ${ac_tr_func} 1
5822 EOF
5823
5824     fi
5825   fi
5826
5827
5828               dummyvar=no
5829   if test x$dummyvar = x"yes"; then
5830     cat >> confdefs.h <<\EOF
5831 #define HAVE___BUILTIN_ABS 1
5832 EOF
5833
5834     cat >> confdefs.h <<\EOF
5835 #define HAVE___BUILTIN_LABS 1
5836 EOF
5837
5838     cat >> confdefs.h <<\EOF
5839 #define HAVE___BUILTIN_COS 1
5840 EOF
5841
5842     cat >> confdefs.h <<\EOF
5843 #define HAVE___BUILTIN_COSF 1
5844 EOF
5845
5846     cat >> confdefs.h <<\EOF
5847 #define HAVE___BUILTIN_COSL 1
5848 EOF
5849
5850     cat >> confdefs.h <<\EOF
5851 #define HAVE___BUILTIN_FABS 1
5852 EOF
5853
5854     cat >> confdefs.h <<\EOF
5855 #define HAVE___BUILTIN_FABSF 1
5856 EOF
5857
5858     cat >> confdefs.h <<\EOF
5859 #define HAVE___BUILTIN_FABSL 1
5860 EOF
5861
5862     cat >> confdefs.h <<\EOF
5863 #define HAVE___BUILTIN_SIN 1
5864 EOF
5865
5866     cat >> confdefs.h <<\EOF
5867 #define HAVE___BUILTIN_SINF 1
5868 EOF
5869
5870     cat >> confdefs.h <<\EOF
5871 #define HAVE___BUILTIN_SINL 1
5872 EOF
5873
5874     cat >> confdefs.h <<\EOF
5875 #define HAVE___BUILTIN_FSQRT 1
5876 EOF
5877
5878     cat >> confdefs.h <<\EOF
5879 #define HAVE___BUILTIN_SQRTF 1
5880 EOF
5881
5882     cat >> confdefs.h <<\EOF
5883 #define HAVE___BUILTIN_SQRTL 1
5884 EOF
5885
5886   fi
5887
5888
5889   ac_test_CXXFLAGS="${CXXFLAGS+set}"
5890   ac_save_CXXFLAGS="$CXXFLAGS"
5891   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
5892
5893     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
5894 echo "configure:5895: checking for sin in -lm" >&5
5895 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
5896 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
5897   echo $ac_n "(cached) $ac_c" 1>&6
5898 else
5899   ac_save_LIBS="$LIBS"
5900 LIBS="-lm  $LIBS"
5901 cat > conftest.$ac_ext <<EOF
5902 #line 5903 "configure"
5903 #include "confdefs.h"
5904 /* Override any gcc2 internal prototype to avoid an error.  */
5905 /* We use char because int might match the return type of a gcc2
5906     builtin and then its argument prototype would still apply.  */
5907 char sin();
5908
5909 int main() {
5910 sin()
5911 ; return 0; }
5912 EOF
5913 if { (eval echo configure:5914: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5914   rm -rf conftest*
5915   eval "ac_cv_lib_$ac_lib_var=yes"
5916 else
5917   echo "configure: failed program was:" >&5
5918   cat conftest.$ac_ext >&5
5919   rm -rf conftest*
5920   eval "ac_cv_lib_$ac_lib_var=no"
5921 fi
5922 rm -f conftest*
5923 LIBS="$ac_save_LIBS"
5924
5925 fi
5926 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
5927   echo "$ac_t""yes" 1>&6
5928   libm="-lm"
5929 else
5930   echo "$ac_t""no" 1>&6
5931 fi
5932
5933   ac_save_LIBS="$LIBS"
5934   LIBS="$LIBS $libm"
5935
5936
5937   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
5938 echo "configure:5939: checking for isinf declaration" >&5
5939   if test x${glibcpp_cv_func_isinf_use+set} != xset; then
5940     if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
5941   echo $ac_n "(cached) $ac_c" 1>&6
5942 else
5943
5944
5945       ac_ext=C
5946 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5947 ac_cpp='$CXXCPP $CPPFLAGS'
5948 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5949 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5950 cross_compiling=$ac_cv_prog_cxx_cross
5951
5952       cat > conftest.$ac_ext <<EOF
5953 #line 5954 "configure"
5954 #include "confdefs.h"
5955 #include <math.h>
5956 int main() {
5957  isinf(0);
5958 ; return 0; }
5959 EOF
5960 if { (eval echo configure:5961: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5961   rm -rf conftest*
5962   glibcpp_cv_func_isinf_use=yes
5963 else
5964   echo "configure: failed program was:" >&5
5965   cat conftest.$ac_ext >&5
5966   rm -rf conftest*
5967   glibcpp_cv_func_isinf_use=no
5968 fi
5969 rm -f conftest*
5970       ac_ext=c
5971 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5972 ac_cpp='$CPP $CPPFLAGS'
5973 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5974 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5975 cross_compiling=$ac_cv_prog_cc_cross
5976
5977
5978 fi
5979
5980   fi
5981   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
5982   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
5983     for ac_func in isinf
5984 do
5985 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5986 echo "configure:5987: checking for $ac_func" >&5
5987 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5988   echo $ac_n "(cached) $ac_c" 1>&6
5989 else
5990   cat > conftest.$ac_ext <<EOF
5991 #line 5992 "configure"
5992 #include "confdefs.h"
5993 /* System header to define __stub macros and hopefully few prototypes,
5994     which can conflict with char $ac_func(); below.  */
5995 #include <assert.h>
5996 /* Override any gcc2 internal prototype to avoid an error.  */
5997 /* We use char because int might match the return type of a gcc2
5998     builtin and then its argument prototype would still apply.  */
5999 char $ac_func();
6000
6001 int main() {
6002
6003 /* The GNU C library defines this for functions which it implements
6004     to always fail with ENOSYS.  Some functions are actually named
6005     something starting with __ and the normal name is an alias.  */
6006 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6007 choke me
6008 #else
6009 $ac_func();
6010 #endif
6011
6012 ; return 0; }
6013 EOF
6014 if { (eval echo configure:6015: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6015   rm -rf conftest*
6016   eval "ac_cv_func_$ac_func=yes"
6017 else
6018   echo "configure: failed program was:" >&5
6019   cat conftest.$ac_ext >&5
6020   rm -rf conftest*
6021   eval "ac_cv_func_$ac_func=no"
6022 fi
6023 rm -f conftest*
6024 fi
6025
6026 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6027   echo "$ac_t""yes" 1>&6
6028     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6029   cat >> confdefs.h <<EOF
6030 #define $ac_tr_func 1
6031 EOF
6032
6033 else
6034   echo "$ac_t""no" 1>&6
6035 fi
6036 done
6037
6038   fi
6039
6040
6041   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
6042 echo "configure:6043: checking for isnan declaration" >&5
6043   if test x${glibcpp_cv_func_isnan_use+set} != xset; then
6044     if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
6045   echo $ac_n "(cached) $ac_c" 1>&6
6046 else
6047
6048
6049       ac_ext=C
6050 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6051 ac_cpp='$CXXCPP $CPPFLAGS'
6052 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6053 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6054 cross_compiling=$ac_cv_prog_cxx_cross
6055
6056       cat > conftest.$ac_ext <<EOF
6057 #line 6058 "configure"
6058 #include "confdefs.h"
6059 #include <math.h>
6060 int main() {
6061  isnan(0);
6062 ; return 0; }
6063 EOF
6064 if { (eval echo configure:6065: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6065   rm -rf conftest*
6066   glibcpp_cv_func_isnan_use=yes
6067 else
6068   echo "configure: failed program was:" >&5
6069   cat conftest.$ac_ext >&5
6070   rm -rf conftest*
6071   glibcpp_cv_func_isnan_use=no
6072 fi
6073 rm -f conftest*
6074       ac_ext=c
6075 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6076 ac_cpp='$CPP $CPPFLAGS'
6077 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6078 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6079 cross_compiling=$ac_cv_prog_cc_cross
6080
6081
6082 fi
6083
6084   fi
6085   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
6086   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
6087     for ac_func in isnan
6088 do
6089 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6090 echo "configure:6091: checking for $ac_func" >&5
6091 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6092   echo $ac_n "(cached) $ac_c" 1>&6
6093 else
6094   cat > conftest.$ac_ext <<EOF
6095 #line 6096 "configure"
6096 #include "confdefs.h"
6097 /* System header to define __stub macros and hopefully few prototypes,
6098     which can conflict with char $ac_func(); below.  */
6099 #include <assert.h>
6100 /* Override any gcc2 internal prototype to avoid an error.  */
6101 /* We use char because int might match the return type of a gcc2
6102     builtin and then its argument prototype would still apply.  */
6103 char $ac_func();
6104
6105 int main() {
6106
6107 /* The GNU C library defines this for functions which it implements
6108     to always fail with ENOSYS.  Some functions are actually named
6109     something starting with __ and the normal name is an alias.  */
6110 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6111 choke me
6112 #else
6113 $ac_func();
6114 #endif
6115
6116 ; return 0; }
6117 EOF
6118 if { (eval echo configure:6119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6119   rm -rf conftest*
6120   eval "ac_cv_func_$ac_func=yes"
6121 else
6122   echo "configure: failed program was:" >&5
6123   cat conftest.$ac_ext >&5
6124   rm -rf conftest*
6125   eval "ac_cv_func_$ac_func=no"
6126 fi
6127 rm -f conftest*
6128 fi
6129
6130 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6131   echo "$ac_t""yes" 1>&6
6132     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6133   cat >> confdefs.h <<EOF
6134 #define $ac_tr_func 1
6135 EOF
6136
6137 else
6138   echo "$ac_t""no" 1>&6
6139 fi
6140 done
6141
6142   fi
6143
6144
6145   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
6146 echo "configure:6147: checking for finite declaration" >&5
6147   if test x${glibcpp_cv_func_finite_use+set} != xset; then
6148     if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
6149   echo $ac_n "(cached) $ac_c" 1>&6
6150 else
6151
6152
6153       ac_ext=C
6154 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6155 ac_cpp='$CXXCPP $CPPFLAGS'
6156 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6157 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6158 cross_compiling=$ac_cv_prog_cxx_cross
6159
6160       cat > conftest.$ac_ext <<EOF
6161 #line 6162 "configure"
6162 #include "confdefs.h"
6163 #include <math.h>
6164 int main() {
6165  finite(0);
6166 ; return 0; }
6167 EOF
6168 if { (eval echo configure:6169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6169   rm -rf conftest*
6170   glibcpp_cv_func_finite_use=yes
6171 else
6172   echo "configure: failed program was:" >&5
6173   cat conftest.$ac_ext >&5
6174   rm -rf conftest*
6175   glibcpp_cv_func_finite_use=no
6176 fi
6177 rm -f conftest*
6178       ac_ext=c
6179 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6180 ac_cpp='$CPP $CPPFLAGS'
6181 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6182 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6183 cross_compiling=$ac_cv_prog_cc_cross
6184
6185
6186 fi
6187
6188   fi
6189   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
6190   if test x$glibcpp_cv_func_finite_use = x"yes"; then
6191     for ac_func in finite
6192 do
6193 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6194 echo "configure:6195: checking for $ac_func" >&5
6195 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6196   echo $ac_n "(cached) $ac_c" 1>&6
6197 else
6198   cat > conftest.$ac_ext <<EOF
6199 #line 6200 "configure"
6200 #include "confdefs.h"
6201 /* System header to define __stub macros and hopefully few prototypes,
6202     which can conflict with char $ac_func(); below.  */
6203 #include <assert.h>
6204 /* Override any gcc2 internal prototype to avoid an error.  */
6205 /* We use char because int might match the return type of a gcc2
6206     builtin and then its argument prototype would still apply.  */
6207 char $ac_func();
6208
6209 int main() {
6210
6211 /* The GNU C library defines this for functions which it implements
6212     to always fail with ENOSYS.  Some functions are actually named
6213     something starting with __ and the normal name is an alias.  */
6214 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6215 choke me
6216 #else
6217 $ac_func();
6218 #endif
6219
6220 ; return 0; }
6221 EOF
6222 if { (eval echo configure:6223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6223   rm -rf conftest*
6224   eval "ac_cv_func_$ac_func=yes"
6225 else
6226   echo "configure: failed program was:" >&5
6227   cat conftest.$ac_ext >&5
6228   rm -rf conftest*
6229   eval "ac_cv_func_$ac_func=no"
6230 fi
6231 rm -f conftest*
6232 fi
6233
6234 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6235   echo "$ac_t""yes" 1>&6
6236     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6237   cat >> confdefs.h <<EOF
6238 #define $ac_tr_func 1
6239 EOF
6240
6241 else
6242   echo "$ac_t""no" 1>&6
6243 fi
6244 done
6245
6246   fi
6247
6248
6249   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
6250 echo "configure:6251: checking for copysign declaration" >&5
6251   if test x${glibcpp_cv_func_copysign_use+set} != xset; then
6252     if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
6253   echo $ac_n "(cached) $ac_c" 1>&6
6254 else
6255
6256
6257       ac_ext=C
6258 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6259 ac_cpp='$CXXCPP $CPPFLAGS'
6260 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6261 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6262 cross_compiling=$ac_cv_prog_cxx_cross
6263
6264       cat > conftest.$ac_ext <<EOF
6265 #line 6266 "configure"
6266 #include "confdefs.h"
6267 #include <math.h>
6268 int main() {
6269  copysign(0, 0);
6270 ; return 0; }
6271 EOF
6272 if { (eval echo configure:6273: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6273   rm -rf conftest*
6274   glibcpp_cv_func_copysign_use=yes
6275 else
6276   echo "configure: failed program was:" >&5
6277   cat conftest.$ac_ext >&5
6278   rm -rf conftest*
6279   glibcpp_cv_func_copysign_use=no
6280 fi
6281 rm -f conftest*
6282       ac_ext=c
6283 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6284 ac_cpp='$CPP $CPPFLAGS'
6285 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6286 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6287 cross_compiling=$ac_cv_prog_cc_cross
6288
6289
6290 fi
6291
6292   fi
6293   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
6294   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
6295     for ac_func in copysign
6296 do
6297 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6298 echo "configure:6299: checking for $ac_func" >&5
6299 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6300   echo $ac_n "(cached) $ac_c" 1>&6
6301 else
6302   cat > conftest.$ac_ext <<EOF
6303 #line 6304 "configure"
6304 #include "confdefs.h"
6305 /* System header to define __stub macros and hopefully few prototypes,
6306     which can conflict with char $ac_func(); below.  */
6307 #include <assert.h>
6308 /* Override any gcc2 internal prototype to avoid an error.  */
6309 /* We use char because int might match the return type of a gcc2
6310     builtin and then its argument prototype would still apply.  */
6311 char $ac_func();
6312
6313 int main() {
6314
6315 /* The GNU C library defines this for functions which it implements
6316     to always fail with ENOSYS.  Some functions are actually named
6317     something starting with __ and the normal name is an alias.  */
6318 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6319 choke me
6320 #else
6321 $ac_func();
6322 #endif
6323
6324 ; return 0; }
6325 EOF
6326 if { (eval echo configure:6327: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6327   rm -rf conftest*
6328   eval "ac_cv_func_$ac_func=yes"
6329 else
6330   echo "configure: failed program was:" >&5
6331   cat conftest.$ac_ext >&5
6332   rm -rf conftest*
6333   eval "ac_cv_func_$ac_func=no"
6334 fi
6335 rm -f conftest*
6336 fi
6337
6338 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6339   echo "$ac_t""yes" 1>&6
6340     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6341   cat >> confdefs.h <<EOF
6342 #define $ac_tr_func 1
6343 EOF
6344
6345 else
6346   echo "$ac_t""no" 1>&6
6347 fi
6348 done
6349
6350   fi
6351
6352
6353   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
6354 echo "configure:6355: checking for sincos declaration" >&5
6355   if test x${glibcpp_cv_func_sincos_use+set} != xset; then
6356     if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
6357   echo $ac_n "(cached) $ac_c" 1>&6
6358 else
6359
6360
6361       ac_ext=C
6362 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6363 ac_cpp='$CXXCPP $CPPFLAGS'
6364 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6365 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6366 cross_compiling=$ac_cv_prog_cxx_cross
6367
6368       cat > conftest.$ac_ext <<EOF
6369 #line 6370 "configure"
6370 #include "confdefs.h"
6371 #include <math.h>
6372 int main() {
6373  sincos(0, 0, 0);
6374 ; return 0; }
6375 EOF
6376 if { (eval echo configure:6377: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6377   rm -rf conftest*
6378   glibcpp_cv_func_sincos_use=yes
6379 else
6380   echo "configure: failed program was:" >&5
6381   cat conftest.$ac_ext >&5
6382   rm -rf conftest*
6383   glibcpp_cv_func_sincos_use=no
6384 fi
6385 rm -f conftest*
6386       ac_ext=c
6387 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6388 ac_cpp='$CPP $CPPFLAGS'
6389 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6390 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6391 cross_compiling=$ac_cv_prog_cc_cross
6392
6393
6394 fi
6395
6396   fi
6397   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
6398   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
6399     for ac_func in sincos
6400 do
6401 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6402 echo "configure:6403: checking for $ac_func" >&5
6403 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6404   echo $ac_n "(cached) $ac_c" 1>&6
6405 else
6406   cat > conftest.$ac_ext <<EOF
6407 #line 6408 "configure"
6408 #include "confdefs.h"
6409 /* System header to define __stub macros and hopefully few prototypes,
6410     which can conflict with char $ac_func(); below.  */
6411 #include <assert.h>
6412 /* Override any gcc2 internal prototype to avoid an error.  */
6413 /* We use char because int might match the return type of a gcc2
6414     builtin and then its argument prototype would still apply.  */
6415 char $ac_func();
6416
6417 int main() {
6418
6419 /* The GNU C library defines this for functions which it implements
6420     to always fail with ENOSYS.  Some functions are actually named
6421     something starting with __ and the normal name is an alias.  */
6422 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6423 choke me
6424 #else
6425 $ac_func();
6426 #endif
6427
6428 ; return 0; }
6429 EOF
6430 if { (eval echo configure:6431: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6431   rm -rf conftest*
6432   eval "ac_cv_func_$ac_func=yes"
6433 else
6434   echo "configure: failed program was:" >&5
6435   cat conftest.$ac_ext >&5
6436   rm -rf conftest*
6437   eval "ac_cv_func_$ac_func=no"
6438 fi
6439 rm -f conftest*
6440 fi
6441
6442 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6443   echo "$ac_t""yes" 1>&6
6444     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6445   cat >> confdefs.h <<EOF
6446 #define $ac_tr_func 1
6447 EOF
6448
6449 else
6450   echo "$ac_t""no" 1>&6
6451 fi
6452 done
6453
6454   fi
6455
6456
6457   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
6458 echo "configure:6459: checking for fpclass declaration" >&5
6459   if test x${glibcpp_cv_func_fpclass_use+set} != xset; then
6460     if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
6461   echo $ac_n "(cached) $ac_c" 1>&6
6462 else
6463
6464
6465       ac_ext=C
6466 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6467 ac_cpp='$CXXCPP $CPPFLAGS'
6468 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6469 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6470 cross_compiling=$ac_cv_prog_cxx_cross
6471
6472       cat > conftest.$ac_ext <<EOF
6473 #line 6474 "configure"
6474 #include "confdefs.h"
6475 #include <math.h>
6476 int main() {
6477  fpclass(0);
6478 ; return 0; }
6479 EOF
6480 if { (eval echo configure:6481: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6481   rm -rf conftest*
6482   glibcpp_cv_func_fpclass_use=yes
6483 else
6484   echo "configure: failed program was:" >&5
6485   cat conftest.$ac_ext >&5
6486   rm -rf conftest*
6487   glibcpp_cv_func_fpclass_use=no
6488 fi
6489 rm -f conftest*
6490       ac_ext=c
6491 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6492 ac_cpp='$CPP $CPPFLAGS'
6493 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6494 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6495 cross_compiling=$ac_cv_prog_cc_cross
6496
6497
6498 fi
6499
6500   fi
6501   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
6502   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
6503     for ac_func in fpclass
6504 do
6505 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6506 echo "configure:6507: checking for $ac_func" >&5
6507 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6508   echo $ac_n "(cached) $ac_c" 1>&6
6509 else
6510   cat > conftest.$ac_ext <<EOF
6511 #line 6512 "configure"
6512 #include "confdefs.h"
6513 /* System header to define __stub macros and hopefully few prototypes,
6514     which can conflict with char $ac_func(); below.  */
6515 #include <assert.h>
6516 /* Override any gcc2 internal prototype to avoid an error.  */
6517 /* We use char because int might match the return type of a gcc2
6518     builtin and then its argument prototype would still apply.  */
6519 char $ac_func();
6520
6521 int main() {
6522
6523 /* The GNU C library defines this for functions which it implements
6524     to always fail with ENOSYS.  Some functions are actually named
6525     something starting with __ and the normal name is an alias.  */
6526 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6527 choke me
6528 #else
6529 $ac_func();
6530 #endif
6531
6532 ; return 0; }
6533 EOF
6534 if { (eval echo configure:6535: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6535   rm -rf conftest*
6536   eval "ac_cv_func_$ac_func=yes"
6537 else
6538   echo "configure: failed program was:" >&5
6539   cat conftest.$ac_ext >&5
6540   rm -rf conftest*
6541   eval "ac_cv_func_$ac_func=no"
6542 fi
6543 rm -f conftest*
6544 fi
6545
6546 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6547   echo "$ac_t""yes" 1>&6
6548     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6549   cat >> confdefs.h <<EOF
6550 #define $ac_tr_func 1
6551 EOF
6552
6553 else
6554   echo "$ac_t""no" 1>&6
6555 fi
6556 done
6557
6558   fi
6559
6560
6561   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
6562 echo "configure:6563: checking for qfpclass declaration" >&5
6563   if test x${glibcpp_cv_func_qfpclass_use+set} != xset; then
6564     if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
6565   echo $ac_n "(cached) $ac_c" 1>&6
6566 else
6567
6568
6569       ac_ext=C
6570 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6571 ac_cpp='$CXXCPP $CPPFLAGS'
6572 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6573 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6574 cross_compiling=$ac_cv_prog_cxx_cross
6575
6576       cat > conftest.$ac_ext <<EOF
6577 #line 6578 "configure"
6578 #include "confdefs.h"
6579 #include <math.h>
6580 int main() {
6581  qfpclass(0);
6582 ; return 0; }
6583 EOF
6584 if { (eval echo configure:6585: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6585   rm -rf conftest*
6586   glibcpp_cv_func_qfpclass_use=yes
6587 else
6588   echo "configure: failed program was:" >&5
6589   cat conftest.$ac_ext >&5
6590   rm -rf conftest*
6591   glibcpp_cv_func_qfpclass_use=no
6592 fi
6593 rm -f conftest*
6594       ac_ext=c
6595 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6596 ac_cpp='$CPP $CPPFLAGS'
6597 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6598 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6599 cross_compiling=$ac_cv_prog_cc_cross
6600
6601
6602 fi
6603
6604   fi
6605   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
6606   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
6607     for ac_func in qfpclass
6608 do
6609 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6610 echo "configure:6611: checking for $ac_func" >&5
6611 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6612   echo $ac_n "(cached) $ac_c" 1>&6
6613 else
6614   cat > conftest.$ac_ext <<EOF
6615 #line 6616 "configure"
6616 #include "confdefs.h"
6617 /* System header to define __stub macros and hopefully few prototypes,
6618     which can conflict with char $ac_func(); below.  */
6619 #include <assert.h>
6620 /* Override any gcc2 internal prototype to avoid an error.  */
6621 /* We use char because int might match the return type of a gcc2
6622     builtin and then its argument prototype would still apply.  */
6623 char $ac_func();
6624
6625 int main() {
6626
6627 /* The GNU C library defines this for functions which it implements
6628     to always fail with ENOSYS.  Some functions are actually named
6629     something starting with __ and the normal name is an alias.  */
6630 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6631 choke me
6632 #else
6633 $ac_func();
6634 #endif
6635
6636 ; return 0; }
6637 EOF
6638 if { (eval echo configure:6639: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6639   rm -rf conftest*
6640   eval "ac_cv_func_$ac_func=yes"
6641 else
6642   echo "configure: failed program was:" >&5
6643   cat conftest.$ac_ext >&5
6644   rm -rf conftest*
6645   eval "ac_cv_func_$ac_func=no"
6646 fi
6647 rm -f conftest*
6648 fi
6649
6650 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6651   echo "$ac_t""yes" 1>&6
6652     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6653   cat >> confdefs.h <<EOF
6654 #define $ac_tr_func 1
6655 EOF
6656
6657 else
6658   echo "$ac_t""no" 1>&6
6659 fi
6660 done
6661
6662   fi
6663
6664
6665
6666   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
6667 echo "configure:6668: checking for isnanf declaration" >&5
6668   if test x${glibcpp_cv_func_isnanf_use+set} != xset; then
6669     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
6670   echo $ac_n "(cached) $ac_c" 1>&6
6671 else
6672
6673
6674       ac_ext=C
6675 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6676 ac_cpp='$CXXCPP $CPPFLAGS'
6677 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6678 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6679 cross_compiling=$ac_cv_prog_cxx_cross
6680
6681       cat > conftest.$ac_ext <<EOF
6682 #line 6683 "configure"
6683 #include "confdefs.h"
6684 #include <math.h>
6685 int main() {
6686  isnanf(0);
6687 ; return 0; }
6688 EOF
6689 if { (eval echo configure:6690: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6690   rm -rf conftest*
6691   glibcpp_cv_func_isnanf_use=yes
6692 else
6693   echo "configure: failed program was:" >&5
6694   cat conftest.$ac_ext >&5
6695   rm -rf conftest*
6696   glibcpp_cv_func_isnanf_use=no
6697 fi
6698 rm -f conftest*
6699       ac_ext=c
6700 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6701 ac_cpp='$CPP $CPPFLAGS'
6702 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6703 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6704 cross_compiling=$ac_cv_prog_cc_cross
6705
6706
6707 fi
6708
6709   fi
6710   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
6711   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
6712     for ac_func in isnanf
6713 do
6714 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6715 echo "configure:6716: checking for $ac_func" >&5
6716 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6717   echo $ac_n "(cached) $ac_c" 1>&6
6718 else
6719   cat > conftest.$ac_ext <<EOF
6720 #line 6721 "configure"
6721 #include "confdefs.h"
6722 /* System header to define __stub macros and hopefully few prototypes,
6723     which can conflict with char $ac_func(); below.  */
6724 #include <assert.h>
6725 /* Override any gcc2 internal prototype to avoid an error.  */
6726 /* We use char because int might match the return type of a gcc2
6727     builtin and then its argument prototype would still apply.  */
6728 char $ac_func();
6729
6730 int main() {
6731
6732 /* The GNU C library defines this for functions which it implements
6733     to always fail with ENOSYS.  Some functions are actually named
6734     something starting with __ and the normal name is an alias.  */
6735 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6736 choke me
6737 #else
6738 $ac_func();
6739 #endif
6740
6741 ; return 0; }
6742 EOF
6743 if { (eval echo configure:6744: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6744   rm -rf conftest*
6745   eval "ac_cv_func_$ac_func=yes"
6746 else
6747   echo "configure: failed program was:" >&5
6748   cat conftest.$ac_ext >&5
6749   rm -rf conftest*
6750   eval "ac_cv_func_$ac_func=no"
6751 fi
6752 rm -f conftest*
6753 fi
6754
6755 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6756   echo "$ac_t""yes" 1>&6
6757     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6758   cat >> confdefs.h <<EOF
6759 #define $ac_tr_func 1
6760 EOF
6761
6762 else
6763   echo "$ac_t""no" 1>&6
6764 fi
6765 done
6766
6767   fi
6768
6769
6770   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
6771 echo "configure:6772: checking for isinff declaration" >&5
6772   if test x${glibcpp_cv_func_isinff_use+set} != xset; then
6773     if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
6774   echo $ac_n "(cached) $ac_c" 1>&6
6775 else
6776
6777
6778       ac_ext=C
6779 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6780 ac_cpp='$CXXCPP $CPPFLAGS'
6781 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6782 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6783 cross_compiling=$ac_cv_prog_cxx_cross
6784
6785       cat > conftest.$ac_ext <<EOF
6786 #line 6787 "configure"
6787 #include "confdefs.h"
6788 #include <math.h>
6789 int main() {
6790  isinff(0);
6791 ; return 0; }
6792 EOF
6793 if { (eval echo configure:6794: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6794   rm -rf conftest*
6795   glibcpp_cv_func_isinff_use=yes
6796 else
6797   echo "configure: failed program was:" >&5
6798   cat conftest.$ac_ext >&5
6799   rm -rf conftest*
6800   glibcpp_cv_func_isinff_use=no
6801 fi
6802 rm -f conftest*
6803       ac_ext=c
6804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6805 ac_cpp='$CPP $CPPFLAGS'
6806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6808 cross_compiling=$ac_cv_prog_cc_cross
6809
6810
6811 fi
6812
6813   fi
6814   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
6815   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
6816     for ac_func in isinff
6817 do
6818 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6819 echo "configure:6820: checking for $ac_func" >&5
6820 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6821   echo $ac_n "(cached) $ac_c" 1>&6
6822 else
6823   cat > conftest.$ac_ext <<EOF
6824 #line 6825 "configure"
6825 #include "confdefs.h"
6826 /* System header to define __stub macros and hopefully few prototypes,
6827     which can conflict with char $ac_func(); below.  */
6828 #include <assert.h>
6829 /* Override any gcc2 internal prototype to avoid an error.  */
6830 /* We use char because int might match the return type of a gcc2
6831     builtin and then its argument prototype would still apply.  */
6832 char $ac_func();
6833
6834 int main() {
6835
6836 /* The GNU C library defines this for functions which it implements
6837     to always fail with ENOSYS.  Some functions are actually named
6838     something starting with __ and the normal name is an alias.  */
6839 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6840 choke me
6841 #else
6842 $ac_func();
6843 #endif
6844
6845 ; return 0; }
6846 EOF
6847 if { (eval echo configure:6848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6848   rm -rf conftest*
6849   eval "ac_cv_func_$ac_func=yes"
6850 else
6851   echo "configure: failed program was:" >&5
6852   cat conftest.$ac_ext >&5
6853   rm -rf conftest*
6854   eval "ac_cv_func_$ac_func=no"
6855 fi
6856 rm -f conftest*
6857 fi
6858
6859 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6860   echo "$ac_t""yes" 1>&6
6861     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6862   cat >> confdefs.h <<EOF
6863 #define $ac_tr_func 1
6864 EOF
6865
6866 else
6867   echo "$ac_t""no" 1>&6
6868 fi
6869 done
6870
6871   fi
6872
6873
6874   echo $ac_n "checking for copysignf declaration""... $ac_c" 1>&6
6875 echo "configure:6876: checking for copysignf declaration" >&5
6876   if test x${glibcpp_cv_func_copysignf_use+set} != xset; then
6877     if eval "test \"`echo '$''{'glibcpp_cv_func_copysignf_use'+set}'`\" = set"; then
6878   echo $ac_n "(cached) $ac_c" 1>&6
6879 else
6880
6881
6882       ac_ext=C
6883 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6884 ac_cpp='$CXXCPP $CPPFLAGS'
6885 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6886 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6887 cross_compiling=$ac_cv_prog_cxx_cross
6888
6889       cat > conftest.$ac_ext <<EOF
6890 #line 6891 "configure"
6891 #include "confdefs.h"
6892 #include <math.h>
6893 int main() {
6894  copysignf(0, 0);
6895 ; return 0; }
6896 EOF
6897 if { (eval echo configure:6898: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6898   rm -rf conftest*
6899   glibcpp_cv_func_copysignf_use=yes
6900 else
6901   echo "configure: failed program was:" >&5
6902   cat conftest.$ac_ext >&5
6903   rm -rf conftest*
6904   glibcpp_cv_func_copysignf_use=no
6905 fi
6906 rm -f conftest*
6907       ac_ext=c
6908 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6909 ac_cpp='$CPP $CPPFLAGS'
6910 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6911 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6912 cross_compiling=$ac_cv_prog_cc_cross
6913
6914
6915 fi
6916
6917   fi
6918   echo "$ac_t""$glibcpp_cv_func_copysignf_use" 1>&6
6919   if test x$glibcpp_cv_func_copysignf_use = x"yes"; then
6920     for ac_func in copysignf
6921 do
6922 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6923 echo "configure:6924: checking for $ac_func" >&5
6924 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6925   echo $ac_n "(cached) $ac_c" 1>&6
6926 else
6927   cat > conftest.$ac_ext <<EOF
6928 #line 6929 "configure"
6929 #include "confdefs.h"
6930 /* System header to define __stub macros and hopefully few prototypes,
6931     which can conflict with char $ac_func(); below.  */
6932 #include <assert.h>
6933 /* Override any gcc2 internal prototype to avoid an error.  */
6934 /* We use char because int might match the return type of a gcc2
6935     builtin and then its argument prototype would still apply.  */
6936 char $ac_func();
6937
6938 int main() {
6939
6940 /* The GNU C library defines this for functions which it implements
6941     to always fail with ENOSYS.  Some functions are actually named
6942     something starting with __ and the normal name is an alias.  */
6943 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6944 choke me
6945 #else
6946 $ac_func();
6947 #endif
6948
6949 ; return 0; }
6950 EOF
6951 if { (eval echo configure:6952: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6952   rm -rf conftest*
6953   eval "ac_cv_func_$ac_func=yes"
6954 else
6955   echo "configure: failed program was:" >&5
6956   cat conftest.$ac_ext >&5
6957   rm -rf conftest*
6958   eval "ac_cv_func_$ac_func=no"
6959 fi
6960 rm -f conftest*
6961 fi
6962
6963 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6964   echo "$ac_t""yes" 1>&6
6965     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6966   cat >> confdefs.h <<EOF
6967 #define $ac_tr_func 1
6968 EOF
6969
6970 else
6971   echo "$ac_t""no" 1>&6
6972 fi
6973 done
6974
6975   fi
6976
6977
6978   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
6979 echo "configure:6980: checking for acosf declaration" >&5
6980   if test x${glibcpp_cv_func_acosf_use+set} != xset; then
6981     if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
6982   echo $ac_n "(cached) $ac_c" 1>&6
6983 else
6984
6985
6986       ac_ext=C
6987 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6988 ac_cpp='$CXXCPP $CPPFLAGS'
6989 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6990 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6991 cross_compiling=$ac_cv_prog_cxx_cross
6992
6993       cat > conftest.$ac_ext <<EOF
6994 #line 6995 "configure"
6995 #include "confdefs.h"
6996 #include <math.h>
6997 int main() {
6998  acosf(0);
6999 ; return 0; }
7000 EOF
7001 if { (eval echo configure:7002: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7002   rm -rf conftest*
7003   glibcpp_cv_func_acosf_use=yes
7004 else
7005   echo "configure: failed program was:" >&5
7006   cat conftest.$ac_ext >&5
7007   rm -rf conftest*
7008   glibcpp_cv_func_acosf_use=no
7009 fi
7010 rm -f conftest*
7011       ac_ext=c
7012 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7013 ac_cpp='$CPP $CPPFLAGS'
7014 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7015 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7016 cross_compiling=$ac_cv_prog_cc_cross
7017
7018
7019 fi
7020
7021   fi
7022   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
7023   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
7024     for ac_func in acosf
7025 do
7026 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7027 echo "configure:7028: checking for $ac_func" >&5
7028 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7029   echo $ac_n "(cached) $ac_c" 1>&6
7030 else
7031   cat > conftest.$ac_ext <<EOF
7032 #line 7033 "configure"
7033 #include "confdefs.h"
7034 /* System header to define __stub macros and hopefully few prototypes,
7035     which can conflict with char $ac_func(); below.  */
7036 #include <assert.h>
7037 /* Override any gcc2 internal prototype to avoid an error.  */
7038 /* We use char because int might match the return type of a gcc2
7039     builtin and then its argument prototype would still apply.  */
7040 char $ac_func();
7041
7042 int main() {
7043
7044 /* The GNU C library defines this for functions which it implements
7045     to always fail with ENOSYS.  Some functions are actually named
7046     something starting with __ and the normal name is an alias.  */
7047 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7048 choke me
7049 #else
7050 $ac_func();
7051 #endif
7052
7053 ; return 0; }
7054 EOF
7055 if { (eval echo configure:7056: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7056   rm -rf conftest*
7057   eval "ac_cv_func_$ac_func=yes"
7058 else
7059   echo "configure: failed program was:" >&5
7060   cat conftest.$ac_ext >&5
7061   rm -rf conftest*
7062   eval "ac_cv_func_$ac_func=no"
7063 fi
7064 rm -f conftest*
7065 fi
7066
7067 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7068   echo "$ac_t""yes" 1>&6
7069     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7070   cat >> confdefs.h <<EOF
7071 #define $ac_tr_func 1
7072 EOF
7073
7074 else
7075   echo "$ac_t""no" 1>&6
7076 fi
7077 done
7078
7079   fi
7080
7081
7082   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
7083 echo "configure:7084: checking for asinf declaration" >&5
7084   if test x${glibcpp_cv_func_asinf_use+set} != xset; then
7085     if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
7086   echo $ac_n "(cached) $ac_c" 1>&6
7087 else
7088
7089
7090       ac_ext=C
7091 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7092 ac_cpp='$CXXCPP $CPPFLAGS'
7093 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7094 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7095 cross_compiling=$ac_cv_prog_cxx_cross
7096
7097       cat > conftest.$ac_ext <<EOF
7098 #line 7099 "configure"
7099 #include "confdefs.h"
7100 #include <math.h>
7101 int main() {
7102  asinf(0);
7103 ; return 0; }
7104 EOF
7105 if { (eval echo configure:7106: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7106   rm -rf conftest*
7107   glibcpp_cv_func_asinf_use=yes
7108 else
7109   echo "configure: failed program was:" >&5
7110   cat conftest.$ac_ext >&5
7111   rm -rf conftest*
7112   glibcpp_cv_func_asinf_use=no
7113 fi
7114 rm -f conftest*
7115       ac_ext=c
7116 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7117 ac_cpp='$CPP $CPPFLAGS'
7118 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7119 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7120 cross_compiling=$ac_cv_prog_cc_cross
7121
7122
7123 fi
7124
7125   fi
7126   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
7127   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
7128     for ac_func in asinf
7129 do
7130 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7131 echo "configure:7132: checking for $ac_func" >&5
7132 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7133   echo $ac_n "(cached) $ac_c" 1>&6
7134 else
7135   cat > conftest.$ac_ext <<EOF
7136 #line 7137 "configure"
7137 #include "confdefs.h"
7138 /* System header to define __stub macros and hopefully few prototypes,
7139     which can conflict with char $ac_func(); below.  */
7140 #include <assert.h>
7141 /* Override any gcc2 internal prototype to avoid an error.  */
7142 /* We use char because int might match the return type of a gcc2
7143     builtin and then its argument prototype would still apply.  */
7144 char $ac_func();
7145
7146 int main() {
7147
7148 /* The GNU C library defines this for functions which it implements
7149     to always fail with ENOSYS.  Some functions are actually named
7150     something starting with __ and the normal name is an alias.  */
7151 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7152 choke me
7153 #else
7154 $ac_func();
7155 #endif
7156
7157 ; return 0; }
7158 EOF
7159 if { (eval echo configure:7160: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7160   rm -rf conftest*
7161   eval "ac_cv_func_$ac_func=yes"
7162 else
7163   echo "configure: failed program was:" >&5
7164   cat conftest.$ac_ext >&5
7165   rm -rf conftest*
7166   eval "ac_cv_func_$ac_func=no"
7167 fi
7168 rm -f conftest*
7169 fi
7170
7171 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7172   echo "$ac_t""yes" 1>&6
7173     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7174   cat >> confdefs.h <<EOF
7175 #define $ac_tr_func 1
7176 EOF
7177
7178 else
7179   echo "$ac_t""no" 1>&6
7180 fi
7181 done
7182
7183   fi
7184
7185
7186   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
7187 echo "configure:7188: checking for atanf declaration" >&5
7188   if test x${glibcpp_cv_func_atanf_use+set} != xset; then
7189     if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
7190   echo $ac_n "(cached) $ac_c" 1>&6
7191 else
7192
7193
7194       ac_ext=C
7195 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7196 ac_cpp='$CXXCPP $CPPFLAGS'
7197 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7198 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7199 cross_compiling=$ac_cv_prog_cxx_cross
7200
7201       cat > conftest.$ac_ext <<EOF
7202 #line 7203 "configure"
7203 #include "confdefs.h"
7204 #include <math.h>
7205 int main() {
7206  atanf(0);
7207 ; return 0; }
7208 EOF
7209 if { (eval echo configure:7210: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7210   rm -rf conftest*
7211   glibcpp_cv_func_atanf_use=yes
7212 else
7213   echo "configure: failed program was:" >&5
7214   cat conftest.$ac_ext >&5
7215   rm -rf conftest*
7216   glibcpp_cv_func_atanf_use=no
7217 fi
7218 rm -f conftest*
7219       ac_ext=c
7220 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7221 ac_cpp='$CPP $CPPFLAGS'
7222 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7223 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7224 cross_compiling=$ac_cv_prog_cc_cross
7225
7226
7227 fi
7228
7229   fi
7230   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
7231   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
7232     for ac_func in atanf
7233 do
7234 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7235 echo "configure:7236: checking for $ac_func" >&5
7236 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7237   echo $ac_n "(cached) $ac_c" 1>&6
7238 else
7239   cat > conftest.$ac_ext <<EOF
7240 #line 7241 "configure"
7241 #include "confdefs.h"
7242 /* System header to define __stub macros and hopefully few prototypes,
7243     which can conflict with char $ac_func(); below.  */
7244 #include <assert.h>
7245 /* Override any gcc2 internal prototype to avoid an error.  */
7246 /* We use char because int might match the return type of a gcc2
7247     builtin and then its argument prototype would still apply.  */
7248 char $ac_func();
7249
7250 int main() {
7251
7252 /* The GNU C library defines this for functions which it implements
7253     to always fail with ENOSYS.  Some functions are actually named
7254     something starting with __ and the normal name is an alias.  */
7255 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7256 choke me
7257 #else
7258 $ac_func();
7259 #endif
7260
7261 ; return 0; }
7262 EOF
7263 if { (eval echo configure:7264: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7264   rm -rf conftest*
7265   eval "ac_cv_func_$ac_func=yes"
7266 else
7267   echo "configure: failed program was:" >&5
7268   cat conftest.$ac_ext >&5
7269   rm -rf conftest*
7270   eval "ac_cv_func_$ac_func=no"
7271 fi
7272 rm -f conftest*
7273 fi
7274
7275 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7276   echo "$ac_t""yes" 1>&6
7277     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7278   cat >> confdefs.h <<EOF
7279 #define $ac_tr_func 1
7280 EOF
7281
7282 else
7283   echo "$ac_t""no" 1>&6
7284 fi
7285 done
7286
7287   fi
7288
7289
7290   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
7291 echo "configure:7292: checking for atan2f declaration" >&5
7292   if test x${glibcpp_cv_func_atan2f_use+set} != xset; then
7293     if eval "test \"`echo '$''{'glibcpp_cv_func_atan2f_use'+set}'`\" = set"; then
7294   echo $ac_n "(cached) $ac_c" 1>&6
7295 else
7296
7297
7298       ac_ext=C
7299 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7300 ac_cpp='$CXXCPP $CPPFLAGS'
7301 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7302 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7303 cross_compiling=$ac_cv_prog_cxx_cross
7304
7305       cat > conftest.$ac_ext <<EOF
7306 #line 7307 "configure"
7307 #include "confdefs.h"
7308 #include <math.h>
7309 int main() {
7310  atan2f(0, 0);
7311 ; return 0; }
7312 EOF
7313 if { (eval echo configure:7314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7314   rm -rf conftest*
7315   glibcpp_cv_func_atan2f_use=yes
7316 else
7317   echo "configure: failed program was:" >&5
7318   cat conftest.$ac_ext >&5
7319   rm -rf conftest*
7320   glibcpp_cv_func_atan2f_use=no
7321 fi
7322 rm -f conftest*
7323       ac_ext=c
7324 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7325 ac_cpp='$CPP $CPPFLAGS'
7326 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7327 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7328 cross_compiling=$ac_cv_prog_cc_cross
7329
7330
7331 fi
7332
7333   fi
7334   echo "$ac_t""$glibcpp_cv_func_atan2f_use" 1>&6
7335   if test x$glibcpp_cv_func_atan2f_use = x"yes"; then
7336     for ac_func in atan2f
7337 do
7338 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7339 echo "configure:7340: checking for $ac_func" >&5
7340 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7341   echo $ac_n "(cached) $ac_c" 1>&6
7342 else
7343   cat > conftest.$ac_ext <<EOF
7344 #line 7345 "configure"
7345 #include "confdefs.h"
7346 /* System header to define __stub macros and hopefully few prototypes,
7347     which can conflict with char $ac_func(); below.  */
7348 #include <assert.h>
7349 /* Override any gcc2 internal prototype to avoid an error.  */
7350 /* We use char because int might match the return type of a gcc2
7351     builtin and then its argument prototype would still apply.  */
7352 char $ac_func();
7353
7354 int main() {
7355
7356 /* The GNU C library defines this for functions which it implements
7357     to always fail with ENOSYS.  Some functions are actually named
7358     something starting with __ and the normal name is an alias.  */
7359 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7360 choke me
7361 #else
7362 $ac_func();
7363 #endif
7364
7365 ; return 0; }
7366 EOF
7367 if { (eval echo configure:7368: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7368   rm -rf conftest*
7369   eval "ac_cv_func_$ac_func=yes"
7370 else
7371   echo "configure: failed program was:" >&5
7372   cat conftest.$ac_ext >&5
7373   rm -rf conftest*
7374   eval "ac_cv_func_$ac_func=no"
7375 fi
7376 rm -f conftest*
7377 fi
7378
7379 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7380   echo "$ac_t""yes" 1>&6
7381     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7382   cat >> confdefs.h <<EOF
7383 #define $ac_tr_func 1
7384 EOF
7385
7386 else
7387   echo "$ac_t""no" 1>&6
7388 fi
7389 done
7390
7391   fi
7392
7393
7394   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
7395 echo "configure:7396: checking for ceilf declaration" >&5
7396   if test x${glibcpp_cv_func_ceilf_use+set} != xset; then
7397     if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
7398   echo $ac_n "(cached) $ac_c" 1>&6
7399 else
7400
7401
7402       ac_ext=C
7403 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7404 ac_cpp='$CXXCPP $CPPFLAGS'
7405 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7406 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7407 cross_compiling=$ac_cv_prog_cxx_cross
7408
7409       cat > conftest.$ac_ext <<EOF
7410 #line 7411 "configure"
7411 #include "confdefs.h"
7412 #include <math.h>
7413 int main() {
7414  ceilf(0);
7415 ; return 0; }
7416 EOF
7417 if { (eval echo configure:7418: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7418   rm -rf conftest*
7419   glibcpp_cv_func_ceilf_use=yes
7420 else
7421   echo "configure: failed program was:" >&5
7422   cat conftest.$ac_ext >&5
7423   rm -rf conftest*
7424   glibcpp_cv_func_ceilf_use=no
7425 fi
7426 rm -f conftest*
7427       ac_ext=c
7428 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7429 ac_cpp='$CPP $CPPFLAGS'
7430 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7431 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7432 cross_compiling=$ac_cv_prog_cc_cross
7433
7434
7435 fi
7436
7437   fi
7438   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
7439   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
7440     for ac_func in ceilf
7441 do
7442 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7443 echo "configure:7444: checking for $ac_func" >&5
7444 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7445   echo $ac_n "(cached) $ac_c" 1>&6
7446 else
7447   cat > conftest.$ac_ext <<EOF
7448 #line 7449 "configure"
7449 #include "confdefs.h"
7450 /* System header to define __stub macros and hopefully few prototypes,
7451     which can conflict with char $ac_func(); below.  */
7452 #include <assert.h>
7453 /* Override any gcc2 internal prototype to avoid an error.  */
7454 /* We use char because int might match the return type of a gcc2
7455     builtin and then its argument prototype would still apply.  */
7456 char $ac_func();
7457
7458 int main() {
7459
7460 /* The GNU C library defines this for functions which it implements
7461     to always fail with ENOSYS.  Some functions are actually named
7462     something starting with __ and the normal name is an alias.  */
7463 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7464 choke me
7465 #else
7466 $ac_func();
7467 #endif
7468
7469 ; return 0; }
7470 EOF
7471 if { (eval echo configure:7472: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7472   rm -rf conftest*
7473   eval "ac_cv_func_$ac_func=yes"
7474 else
7475   echo "configure: failed program was:" >&5
7476   cat conftest.$ac_ext >&5
7477   rm -rf conftest*
7478   eval "ac_cv_func_$ac_func=no"
7479 fi
7480 rm -f conftest*
7481 fi
7482
7483 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7484   echo "$ac_t""yes" 1>&6
7485     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7486   cat >> confdefs.h <<EOF
7487 #define $ac_tr_func 1
7488 EOF
7489
7490 else
7491   echo "$ac_t""no" 1>&6
7492 fi
7493 done
7494
7495   fi
7496
7497
7498   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
7499 echo "configure:7500: checking for cosf declaration" >&5
7500   if test x${glibcpp_cv_func_cosf_use+set} != xset; then
7501     if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
7502   echo $ac_n "(cached) $ac_c" 1>&6
7503 else
7504
7505
7506       ac_ext=C
7507 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7508 ac_cpp='$CXXCPP $CPPFLAGS'
7509 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7510 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7511 cross_compiling=$ac_cv_prog_cxx_cross
7512
7513       cat > conftest.$ac_ext <<EOF
7514 #line 7515 "configure"
7515 #include "confdefs.h"
7516 #include <math.h>
7517 int main() {
7518  cosf(0);
7519 ; return 0; }
7520 EOF
7521 if { (eval echo configure:7522: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7522   rm -rf conftest*
7523   glibcpp_cv_func_cosf_use=yes
7524 else
7525   echo "configure: failed program was:" >&5
7526   cat conftest.$ac_ext >&5
7527   rm -rf conftest*
7528   glibcpp_cv_func_cosf_use=no
7529 fi
7530 rm -f conftest*
7531       ac_ext=c
7532 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7533 ac_cpp='$CPP $CPPFLAGS'
7534 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7535 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7536 cross_compiling=$ac_cv_prog_cc_cross
7537
7538
7539 fi
7540
7541   fi
7542   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
7543   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
7544     for ac_func in cosf
7545 do
7546 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7547 echo "configure:7548: checking for $ac_func" >&5
7548 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7549   echo $ac_n "(cached) $ac_c" 1>&6
7550 else
7551   cat > conftest.$ac_ext <<EOF
7552 #line 7553 "configure"
7553 #include "confdefs.h"
7554 /* System header to define __stub macros and hopefully few prototypes,
7555     which can conflict with char $ac_func(); below.  */
7556 #include <assert.h>
7557 /* Override any gcc2 internal prototype to avoid an error.  */
7558 /* We use char because int might match the return type of a gcc2
7559     builtin and then its argument prototype would still apply.  */
7560 char $ac_func();
7561
7562 int main() {
7563
7564 /* The GNU C library defines this for functions which it implements
7565     to always fail with ENOSYS.  Some functions are actually named
7566     something starting with __ and the normal name is an alias.  */
7567 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7568 choke me
7569 #else
7570 $ac_func();
7571 #endif
7572
7573 ; return 0; }
7574 EOF
7575 if { (eval echo configure:7576: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7576   rm -rf conftest*
7577   eval "ac_cv_func_$ac_func=yes"
7578 else
7579   echo "configure: failed program was:" >&5
7580   cat conftest.$ac_ext >&5
7581   rm -rf conftest*
7582   eval "ac_cv_func_$ac_func=no"
7583 fi
7584 rm -f conftest*
7585 fi
7586
7587 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7588   echo "$ac_t""yes" 1>&6
7589     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7590   cat >> confdefs.h <<EOF
7591 #define $ac_tr_func 1
7592 EOF
7593
7594 else
7595   echo "$ac_t""no" 1>&6
7596 fi
7597 done
7598
7599   fi
7600
7601
7602   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
7603 echo "configure:7604: checking for coshf declaration" >&5
7604   if test x${glibcpp_cv_func_coshf_use+set} != xset; then
7605     if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
7606   echo $ac_n "(cached) $ac_c" 1>&6
7607 else
7608
7609
7610       ac_ext=C
7611 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7612 ac_cpp='$CXXCPP $CPPFLAGS'
7613 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7614 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7615 cross_compiling=$ac_cv_prog_cxx_cross
7616
7617       cat > conftest.$ac_ext <<EOF
7618 #line 7619 "configure"
7619 #include "confdefs.h"
7620 #include <math.h>
7621 int main() {
7622  coshf(0);
7623 ; return 0; }
7624 EOF
7625 if { (eval echo configure:7626: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7626   rm -rf conftest*
7627   glibcpp_cv_func_coshf_use=yes
7628 else
7629   echo "configure: failed program was:" >&5
7630   cat conftest.$ac_ext >&5
7631   rm -rf conftest*
7632   glibcpp_cv_func_coshf_use=no
7633 fi
7634 rm -f conftest*
7635       ac_ext=c
7636 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7637 ac_cpp='$CPP $CPPFLAGS'
7638 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7639 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7640 cross_compiling=$ac_cv_prog_cc_cross
7641
7642
7643 fi
7644
7645   fi
7646   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
7647   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
7648     for ac_func in coshf
7649 do
7650 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7651 echo "configure:7652: checking for $ac_func" >&5
7652 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7653   echo $ac_n "(cached) $ac_c" 1>&6
7654 else
7655   cat > conftest.$ac_ext <<EOF
7656 #line 7657 "configure"
7657 #include "confdefs.h"
7658 /* System header to define __stub macros and hopefully few prototypes,
7659     which can conflict with char $ac_func(); below.  */
7660 #include <assert.h>
7661 /* Override any gcc2 internal prototype to avoid an error.  */
7662 /* We use char because int might match the return type of a gcc2
7663     builtin and then its argument prototype would still apply.  */
7664 char $ac_func();
7665
7666 int main() {
7667
7668 /* The GNU C library defines this for functions which it implements
7669     to always fail with ENOSYS.  Some functions are actually named
7670     something starting with __ and the normal name is an alias.  */
7671 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7672 choke me
7673 #else
7674 $ac_func();
7675 #endif
7676
7677 ; return 0; }
7678 EOF
7679 if { (eval echo configure:7680: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7680   rm -rf conftest*
7681   eval "ac_cv_func_$ac_func=yes"
7682 else
7683   echo "configure: failed program was:" >&5
7684   cat conftest.$ac_ext >&5
7685   rm -rf conftest*
7686   eval "ac_cv_func_$ac_func=no"
7687 fi
7688 rm -f conftest*
7689 fi
7690
7691 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7692   echo "$ac_t""yes" 1>&6
7693     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7694   cat >> confdefs.h <<EOF
7695 #define $ac_tr_func 1
7696 EOF
7697
7698 else
7699   echo "$ac_t""no" 1>&6
7700 fi
7701 done
7702
7703   fi
7704
7705
7706   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
7707 echo "configure:7708: checking for expf declaration" >&5
7708   if test x${glibcpp_cv_func_expf_use+set} != xset; then
7709     if eval "test \"`echo '$''{'glibcpp_cv_func_expf_use'+set}'`\" = set"; then
7710   echo $ac_n "(cached) $ac_c" 1>&6
7711 else
7712
7713
7714       ac_ext=C
7715 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7716 ac_cpp='$CXXCPP $CPPFLAGS'
7717 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7718 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7719 cross_compiling=$ac_cv_prog_cxx_cross
7720
7721       cat > conftest.$ac_ext <<EOF
7722 #line 7723 "configure"
7723 #include "confdefs.h"
7724 #include <math.h>
7725 int main() {
7726  expf(0);
7727 ; return 0; }
7728 EOF
7729 if { (eval echo configure:7730: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7730   rm -rf conftest*
7731   glibcpp_cv_func_expf_use=yes
7732 else
7733   echo "configure: failed program was:" >&5
7734   cat conftest.$ac_ext >&5
7735   rm -rf conftest*
7736   glibcpp_cv_func_expf_use=no
7737 fi
7738 rm -f conftest*
7739       ac_ext=c
7740 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7741 ac_cpp='$CPP $CPPFLAGS'
7742 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7743 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7744 cross_compiling=$ac_cv_prog_cc_cross
7745
7746
7747 fi
7748
7749   fi
7750   echo "$ac_t""$glibcpp_cv_func_expf_use" 1>&6
7751   if test x$glibcpp_cv_func_expf_use = x"yes"; then
7752     for ac_func in expf
7753 do
7754 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7755 echo "configure:7756: checking for $ac_func" >&5
7756 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7757   echo $ac_n "(cached) $ac_c" 1>&6
7758 else
7759   cat > conftest.$ac_ext <<EOF
7760 #line 7761 "configure"
7761 #include "confdefs.h"
7762 /* System header to define __stub macros and hopefully few prototypes,
7763     which can conflict with char $ac_func(); below.  */
7764 #include <assert.h>
7765 /* Override any gcc2 internal prototype to avoid an error.  */
7766 /* We use char because int might match the return type of a gcc2
7767     builtin and then its argument prototype would still apply.  */
7768 char $ac_func();
7769
7770 int main() {
7771
7772 /* The GNU C library defines this for functions which it implements
7773     to always fail with ENOSYS.  Some functions are actually named
7774     something starting with __ and the normal name is an alias.  */
7775 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7776 choke me
7777 #else
7778 $ac_func();
7779 #endif
7780
7781 ; return 0; }
7782 EOF
7783 if { (eval echo configure:7784: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7784   rm -rf conftest*
7785   eval "ac_cv_func_$ac_func=yes"
7786 else
7787   echo "configure: failed program was:" >&5
7788   cat conftest.$ac_ext >&5
7789   rm -rf conftest*
7790   eval "ac_cv_func_$ac_func=no"
7791 fi
7792 rm -f conftest*
7793 fi
7794
7795 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7796   echo "$ac_t""yes" 1>&6
7797     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7798   cat >> confdefs.h <<EOF
7799 #define $ac_tr_func 1
7800 EOF
7801
7802 else
7803   echo "$ac_t""no" 1>&6
7804 fi
7805 done
7806
7807   fi
7808
7809
7810   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
7811 echo "configure:7812: checking for fabsf declaration" >&5
7812   if test x${glibcpp_cv_func_fabsf_use+set} != xset; then
7813     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
7814   echo $ac_n "(cached) $ac_c" 1>&6
7815 else
7816
7817
7818       ac_ext=C
7819 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7820 ac_cpp='$CXXCPP $CPPFLAGS'
7821 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7822 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7823 cross_compiling=$ac_cv_prog_cxx_cross
7824
7825       cat > conftest.$ac_ext <<EOF
7826 #line 7827 "configure"
7827 #include "confdefs.h"
7828 #include <math.h>
7829 int main() {
7830  fabsf(0);
7831 ; return 0; }
7832 EOF
7833 if { (eval echo configure:7834: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7834   rm -rf conftest*
7835   glibcpp_cv_func_fabsf_use=yes
7836 else
7837   echo "configure: failed program was:" >&5
7838   cat conftest.$ac_ext >&5
7839   rm -rf conftest*
7840   glibcpp_cv_func_fabsf_use=no
7841 fi
7842 rm -f conftest*
7843       ac_ext=c
7844 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7845 ac_cpp='$CPP $CPPFLAGS'
7846 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7847 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7848 cross_compiling=$ac_cv_prog_cc_cross
7849
7850
7851 fi
7852
7853   fi
7854   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
7855   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
7856     for ac_func in fabsf
7857 do
7858 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7859 echo "configure:7860: checking for $ac_func" >&5
7860 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7861   echo $ac_n "(cached) $ac_c" 1>&6
7862 else
7863   cat > conftest.$ac_ext <<EOF
7864 #line 7865 "configure"
7865 #include "confdefs.h"
7866 /* System header to define __stub macros and hopefully few prototypes,
7867     which can conflict with char $ac_func(); below.  */
7868 #include <assert.h>
7869 /* Override any gcc2 internal prototype to avoid an error.  */
7870 /* We use char because int might match the return type of a gcc2
7871     builtin and then its argument prototype would still apply.  */
7872 char $ac_func();
7873
7874 int main() {
7875
7876 /* The GNU C library defines this for functions which it implements
7877     to always fail with ENOSYS.  Some functions are actually named
7878     something starting with __ and the normal name is an alias.  */
7879 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7880 choke me
7881 #else
7882 $ac_func();
7883 #endif
7884
7885 ; return 0; }
7886 EOF
7887 if { (eval echo configure:7888: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7888   rm -rf conftest*
7889   eval "ac_cv_func_$ac_func=yes"
7890 else
7891   echo "configure: failed program was:" >&5
7892   cat conftest.$ac_ext >&5
7893   rm -rf conftest*
7894   eval "ac_cv_func_$ac_func=no"
7895 fi
7896 rm -f conftest*
7897 fi
7898
7899 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7900   echo "$ac_t""yes" 1>&6
7901     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7902   cat >> confdefs.h <<EOF
7903 #define $ac_tr_func 1
7904 EOF
7905
7906 else
7907   echo "$ac_t""no" 1>&6
7908 fi
7909 done
7910
7911   fi
7912
7913
7914   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
7915 echo "configure:7916: checking for floorf declaration" >&5
7916   if test x${glibcpp_cv_func_floorf_use+set} != xset; then
7917     if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
7918   echo $ac_n "(cached) $ac_c" 1>&6
7919 else
7920
7921
7922       ac_ext=C
7923 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7924 ac_cpp='$CXXCPP $CPPFLAGS'
7925 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7926 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7927 cross_compiling=$ac_cv_prog_cxx_cross
7928
7929       cat > conftest.$ac_ext <<EOF
7930 #line 7931 "configure"
7931 #include "confdefs.h"
7932 #include <math.h>
7933 int main() {
7934  floorf(0);
7935 ; return 0; }
7936 EOF
7937 if { (eval echo configure:7938: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7938   rm -rf conftest*
7939   glibcpp_cv_func_floorf_use=yes
7940 else
7941   echo "configure: failed program was:" >&5
7942   cat conftest.$ac_ext >&5
7943   rm -rf conftest*
7944   glibcpp_cv_func_floorf_use=no
7945 fi
7946 rm -f conftest*
7947       ac_ext=c
7948 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7949 ac_cpp='$CPP $CPPFLAGS'
7950 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7951 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7952 cross_compiling=$ac_cv_prog_cc_cross
7953
7954
7955 fi
7956
7957   fi
7958   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
7959   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
7960     for ac_func in floorf
7961 do
7962 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7963 echo "configure:7964: checking for $ac_func" >&5
7964 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7965   echo $ac_n "(cached) $ac_c" 1>&6
7966 else
7967   cat > conftest.$ac_ext <<EOF
7968 #line 7969 "configure"
7969 #include "confdefs.h"
7970 /* System header to define __stub macros and hopefully few prototypes,
7971     which can conflict with char $ac_func(); below.  */
7972 #include <assert.h>
7973 /* Override any gcc2 internal prototype to avoid an error.  */
7974 /* We use char because int might match the return type of a gcc2
7975     builtin and then its argument prototype would still apply.  */
7976 char $ac_func();
7977
7978 int main() {
7979
7980 /* The GNU C library defines this for functions which it implements
7981     to always fail with ENOSYS.  Some functions are actually named
7982     something starting with __ and the normal name is an alias.  */
7983 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7984 choke me
7985 #else
7986 $ac_func();
7987 #endif
7988
7989 ; return 0; }
7990 EOF
7991 if { (eval echo configure:7992: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7992   rm -rf conftest*
7993   eval "ac_cv_func_$ac_func=yes"
7994 else
7995   echo "configure: failed program was:" >&5
7996   cat conftest.$ac_ext >&5
7997   rm -rf conftest*
7998   eval "ac_cv_func_$ac_func=no"
7999 fi
8000 rm -f conftest*
8001 fi
8002
8003 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8004   echo "$ac_t""yes" 1>&6
8005     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8006   cat >> confdefs.h <<EOF
8007 #define $ac_tr_func 1
8008 EOF
8009
8010 else
8011   echo "$ac_t""no" 1>&6
8012 fi
8013 done
8014
8015   fi
8016
8017
8018   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
8019 echo "configure:8020: checking for fmodf declaration" >&5
8020   if test x${glibcpp_cv_func_fmodf_use+set} != xset; then
8021     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
8022   echo $ac_n "(cached) $ac_c" 1>&6
8023 else
8024
8025
8026       ac_ext=C
8027 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8028 ac_cpp='$CXXCPP $CPPFLAGS'
8029 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8030 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8031 cross_compiling=$ac_cv_prog_cxx_cross
8032
8033       cat > conftest.$ac_ext <<EOF
8034 #line 8035 "configure"
8035 #include "confdefs.h"
8036 #include <math.h>
8037 int main() {
8038  fmodf(0, 0);
8039 ; return 0; }
8040 EOF
8041 if { (eval echo configure:8042: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8042   rm -rf conftest*
8043   glibcpp_cv_func_fmodf_use=yes
8044 else
8045   echo "configure: failed program was:" >&5
8046   cat conftest.$ac_ext >&5
8047   rm -rf conftest*
8048   glibcpp_cv_func_fmodf_use=no
8049 fi
8050 rm -f conftest*
8051       ac_ext=c
8052 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8053 ac_cpp='$CPP $CPPFLAGS'
8054 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8055 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8056 cross_compiling=$ac_cv_prog_cc_cross
8057
8058
8059 fi
8060
8061   fi
8062   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
8063   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
8064     for ac_func in fmodf
8065 do
8066 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8067 echo "configure:8068: checking for $ac_func" >&5
8068 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8069   echo $ac_n "(cached) $ac_c" 1>&6
8070 else
8071   cat > conftest.$ac_ext <<EOF
8072 #line 8073 "configure"
8073 #include "confdefs.h"
8074 /* System header to define __stub macros and hopefully few prototypes,
8075     which can conflict with char $ac_func(); below.  */
8076 #include <assert.h>
8077 /* Override any gcc2 internal prototype to avoid an error.  */
8078 /* We use char because int might match the return type of a gcc2
8079     builtin and then its argument prototype would still apply.  */
8080 char $ac_func();
8081
8082 int main() {
8083
8084 /* The GNU C library defines this for functions which it implements
8085     to always fail with ENOSYS.  Some functions are actually named
8086     something starting with __ and the normal name is an alias.  */
8087 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8088 choke me
8089 #else
8090 $ac_func();
8091 #endif
8092
8093 ; return 0; }
8094 EOF
8095 if { (eval echo configure:8096: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8096   rm -rf conftest*
8097   eval "ac_cv_func_$ac_func=yes"
8098 else
8099   echo "configure: failed program was:" >&5
8100   cat conftest.$ac_ext >&5
8101   rm -rf conftest*
8102   eval "ac_cv_func_$ac_func=no"
8103 fi
8104 rm -f conftest*
8105 fi
8106
8107 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8108   echo "$ac_t""yes" 1>&6
8109     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8110   cat >> confdefs.h <<EOF
8111 #define $ac_tr_func 1
8112 EOF
8113
8114 else
8115   echo "$ac_t""no" 1>&6
8116 fi
8117 done
8118
8119   fi
8120
8121
8122   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
8123 echo "configure:8124: checking for frexpf declaration" >&5
8124   if test x${glibcpp_cv_func_frexpf_use+set} != xset; then
8125     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
8126   echo $ac_n "(cached) $ac_c" 1>&6
8127 else
8128
8129
8130       ac_ext=C
8131 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8132 ac_cpp='$CXXCPP $CPPFLAGS'
8133 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8134 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8135 cross_compiling=$ac_cv_prog_cxx_cross
8136
8137       cat > conftest.$ac_ext <<EOF
8138 #line 8139 "configure"
8139 #include "confdefs.h"
8140 #include <math.h>
8141 int main() {
8142  frexpf(0, 0);
8143 ; return 0; }
8144 EOF
8145 if { (eval echo configure:8146: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8146   rm -rf conftest*
8147   glibcpp_cv_func_frexpf_use=yes
8148 else
8149   echo "configure: failed program was:" >&5
8150   cat conftest.$ac_ext >&5
8151   rm -rf conftest*
8152   glibcpp_cv_func_frexpf_use=no
8153 fi
8154 rm -f conftest*
8155       ac_ext=c
8156 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8157 ac_cpp='$CPP $CPPFLAGS'
8158 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8159 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8160 cross_compiling=$ac_cv_prog_cc_cross
8161
8162
8163 fi
8164
8165   fi
8166   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
8167   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
8168     for ac_func in frexpf
8169 do
8170 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8171 echo "configure:8172: checking for $ac_func" >&5
8172 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8173   echo $ac_n "(cached) $ac_c" 1>&6
8174 else
8175   cat > conftest.$ac_ext <<EOF
8176 #line 8177 "configure"
8177 #include "confdefs.h"
8178 /* System header to define __stub macros and hopefully few prototypes,
8179     which can conflict with char $ac_func(); below.  */
8180 #include <assert.h>
8181 /* Override any gcc2 internal prototype to avoid an error.  */
8182 /* We use char because int might match the return type of a gcc2
8183     builtin and then its argument prototype would still apply.  */
8184 char $ac_func();
8185
8186 int main() {
8187
8188 /* The GNU C library defines this for functions which it implements
8189     to always fail with ENOSYS.  Some functions are actually named
8190     something starting with __ and the normal name is an alias.  */
8191 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8192 choke me
8193 #else
8194 $ac_func();
8195 #endif
8196
8197 ; return 0; }
8198 EOF
8199 if { (eval echo configure:8200: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8200   rm -rf conftest*
8201   eval "ac_cv_func_$ac_func=yes"
8202 else
8203   echo "configure: failed program was:" >&5
8204   cat conftest.$ac_ext >&5
8205   rm -rf conftest*
8206   eval "ac_cv_func_$ac_func=no"
8207 fi
8208 rm -f conftest*
8209 fi
8210
8211 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8212   echo "$ac_t""yes" 1>&6
8213     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8214   cat >> confdefs.h <<EOF
8215 #define $ac_tr_func 1
8216 EOF
8217
8218 else
8219   echo "$ac_t""no" 1>&6
8220 fi
8221 done
8222
8223   fi
8224
8225
8226   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
8227 echo "configure:8228: checking for ldexpf declaration" >&5
8228   if test x${glibcpp_cv_func_ldexpf_use+set} != xset; then
8229     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
8230   echo $ac_n "(cached) $ac_c" 1>&6
8231 else
8232
8233
8234       ac_ext=C
8235 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8236 ac_cpp='$CXXCPP $CPPFLAGS'
8237 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8238 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8239 cross_compiling=$ac_cv_prog_cxx_cross
8240
8241       cat > conftest.$ac_ext <<EOF
8242 #line 8243 "configure"
8243 #include "confdefs.h"
8244 #include <math.h>
8245 int main() {
8246  ldexpf(0, 0);
8247 ; return 0; }
8248 EOF
8249 if { (eval echo configure:8250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8250   rm -rf conftest*
8251   glibcpp_cv_func_ldexpf_use=yes
8252 else
8253   echo "configure: failed program was:" >&5
8254   cat conftest.$ac_ext >&5
8255   rm -rf conftest*
8256   glibcpp_cv_func_ldexpf_use=no
8257 fi
8258 rm -f conftest*
8259       ac_ext=c
8260 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8261 ac_cpp='$CPP $CPPFLAGS'
8262 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8263 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8264 cross_compiling=$ac_cv_prog_cc_cross
8265
8266
8267 fi
8268
8269   fi
8270   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
8271   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
8272     for ac_func in ldexpf
8273 do
8274 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8275 echo "configure:8276: checking for $ac_func" >&5
8276 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8277   echo $ac_n "(cached) $ac_c" 1>&6
8278 else
8279   cat > conftest.$ac_ext <<EOF
8280 #line 8281 "configure"
8281 #include "confdefs.h"
8282 /* System header to define __stub macros and hopefully few prototypes,
8283     which can conflict with char $ac_func(); below.  */
8284 #include <assert.h>
8285 /* Override any gcc2 internal prototype to avoid an error.  */
8286 /* We use char because int might match the return type of a gcc2
8287     builtin and then its argument prototype would still apply.  */
8288 char $ac_func();
8289
8290 int main() {
8291
8292 /* The GNU C library defines this for functions which it implements
8293     to always fail with ENOSYS.  Some functions are actually named
8294     something starting with __ and the normal name is an alias.  */
8295 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8296 choke me
8297 #else
8298 $ac_func();
8299 #endif
8300
8301 ; return 0; }
8302 EOF
8303 if { (eval echo configure:8304: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8304   rm -rf conftest*
8305   eval "ac_cv_func_$ac_func=yes"
8306 else
8307   echo "configure: failed program was:" >&5
8308   cat conftest.$ac_ext >&5
8309   rm -rf conftest*
8310   eval "ac_cv_func_$ac_func=no"
8311 fi
8312 rm -f conftest*
8313 fi
8314
8315 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8316   echo "$ac_t""yes" 1>&6
8317     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8318   cat >> confdefs.h <<EOF
8319 #define $ac_tr_func 1
8320 EOF
8321
8322 else
8323   echo "$ac_t""no" 1>&6
8324 fi
8325 done
8326
8327   fi
8328
8329
8330   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
8331 echo "configure:8332: checking for logf declaration" >&5
8332   if test x${glibcpp_cv_func_logf_use+set} != xset; then
8333     if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
8334   echo $ac_n "(cached) $ac_c" 1>&6
8335 else
8336
8337
8338       ac_ext=C
8339 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8340 ac_cpp='$CXXCPP $CPPFLAGS'
8341 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8342 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8343 cross_compiling=$ac_cv_prog_cxx_cross
8344
8345       cat > conftest.$ac_ext <<EOF
8346 #line 8347 "configure"
8347 #include "confdefs.h"
8348 #include <math.h>
8349 int main() {
8350  logf(0);
8351 ; return 0; }
8352 EOF
8353 if { (eval echo configure:8354: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8354   rm -rf conftest*
8355   glibcpp_cv_func_logf_use=yes
8356 else
8357   echo "configure: failed program was:" >&5
8358   cat conftest.$ac_ext >&5
8359   rm -rf conftest*
8360   glibcpp_cv_func_logf_use=no
8361 fi
8362 rm -f conftest*
8363       ac_ext=c
8364 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8365 ac_cpp='$CPP $CPPFLAGS'
8366 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8367 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8368 cross_compiling=$ac_cv_prog_cc_cross
8369
8370
8371 fi
8372
8373   fi
8374   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
8375   if test x$glibcpp_cv_func_logf_use = x"yes"; then
8376     for ac_func in logf
8377 do
8378 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8379 echo "configure:8380: checking for $ac_func" >&5
8380 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8381   echo $ac_n "(cached) $ac_c" 1>&6
8382 else
8383   cat > conftest.$ac_ext <<EOF
8384 #line 8385 "configure"
8385 #include "confdefs.h"
8386 /* System header to define __stub macros and hopefully few prototypes,
8387     which can conflict with char $ac_func(); below.  */
8388 #include <assert.h>
8389 /* Override any gcc2 internal prototype to avoid an error.  */
8390 /* We use char because int might match the return type of a gcc2
8391     builtin and then its argument prototype would still apply.  */
8392 char $ac_func();
8393
8394 int main() {
8395
8396 /* The GNU C library defines this for functions which it implements
8397     to always fail with ENOSYS.  Some functions are actually named
8398     something starting with __ and the normal name is an alias.  */
8399 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8400 choke me
8401 #else
8402 $ac_func();
8403 #endif
8404
8405 ; return 0; }
8406 EOF
8407 if { (eval echo configure:8408: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8408   rm -rf conftest*
8409   eval "ac_cv_func_$ac_func=yes"
8410 else
8411   echo "configure: failed program was:" >&5
8412   cat conftest.$ac_ext >&5
8413   rm -rf conftest*
8414   eval "ac_cv_func_$ac_func=no"
8415 fi
8416 rm -f conftest*
8417 fi
8418
8419 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8420   echo "$ac_t""yes" 1>&6
8421     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8422   cat >> confdefs.h <<EOF
8423 #define $ac_tr_func 1
8424 EOF
8425
8426 else
8427   echo "$ac_t""no" 1>&6
8428 fi
8429 done
8430
8431   fi
8432
8433
8434   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
8435 echo "configure:8436: checking for log10f declaration" >&5
8436   if test x${glibcpp_cv_func_log10f_use+set} != xset; then
8437     if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
8438   echo $ac_n "(cached) $ac_c" 1>&6
8439 else
8440
8441
8442       ac_ext=C
8443 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8444 ac_cpp='$CXXCPP $CPPFLAGS'
8445 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8446 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8447 cross_compiling=$ac_cv_prog_cxx_cross
8448
8449       cat > conftest.$ac_ext <<EOF
8450 #line 8451 "configure"
8451 #include "confdefs.h"
8452 #include <math.h>
8453 int main() {
8454  log10f(0);
8455 ; return 0; }
8456 EOF
8457 if { (eval echo configure:8458: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8458   rm -rf conftest*
8459   glibcpp_cv_func_log10f_use=yes
8460 else
8461   echo "configure: failed program was:" >&5
8462   cat conftest.$ac_ext >&5
8463   rm -rf conftest*
8464   glibcpp_cv_func_log10f_use=no
8465 fi
8466 rm -f conftest*
8467       ac_ext=c
8468 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8469 ac_cpp='$CPP $CPPFLAGS'
8470 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8471 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8472 cross_compiling=$ac_cv_prog_cc_cross
8473
8474
8475 fi
8476
8477   fi
8478   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
8479   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
8480     for ac_func in log10f
8481 do
8482 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8483 echo "configure:8484: checking for $ac_func" >&5
8484 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8485   echo $ac_n "(cached) $ac_c" 1>&6
8486 else
8487   cat > conftest.$ac_ext <<EOF
8488 #line 8489 "configure"
8489 #include "confdefs.h"
8490 /* System header to define __stub macros and hopefully few prototypes,
8491     which can conflict with char $ac_func(); below.  */
8492 #include <assert.h>
8493 /* Override any gcc2 internal prototype to avoid an error.  */
8494 /* We use char because int might match the return type of a gcc2
8495     builtin and then its argument prototype would still apply.  */
8496 char $ac_func();
8497
8498 int main() {
8499
8500 /* The GNU C library defines this for functions which it implements
8501     to always fail with ENOSYS.  Some functions are actually named
8502     something starting with __ and the normal name is an alias.  */
8503 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8504 choke me
8505 #else
8506 $ac_func();
8507 #endif
8508
8509 ; return 0; }
8510 EOF
8511 if { (eval echo configure:8512: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8512   rm -rf conftest*
8513   eval "ac_cv_func_$ac_func=yes"
8514 else
8515   echo "configure: failed program was:" >&5
8516   cat conftest.$ac_ext >&5
8517   rm -rf conftest*
8518   eval "ac_cv_func_$ac_func=no"
8519 fi
8520 rm -f conftest*
8521 fi
8522
8523 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8524   echo "$ac_t""yes" 1>&6
8525     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8526   cat >> confdefs.h <<EOF
8527 #define $ac_tr_func 1
8528 EOF
8529
8530 else
8531   echo "$ac_t""no" 1>&6
8532 fi
8533 done
8534
8535   fi
8536
8537
8538   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
8539 echo "configure:8540: checking for modff declaration" >&5
8540   if test x${glibcpp_cv_func_modff_use+set} != xset; then
8541     if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
8542   echo $ac_n "(cached) $ac_c" 1>&6
8543 else
8544
8545
8546       ac_ext=C
8547 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8548 ac_cpp='$CXXCPP $CPPFLAGS'
8549 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8550 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8551 cross_compiling=$ac_cv_prog_cxx_cross
8552
8553       cat > conftest.$ac_ext <<EOF
8554 #line 8555 "configure"
8555 #include "confdefs.h"
8556 #include <math.h>
8557 int main() {
8558  modff(0, 0);
8559 ; return 0; }
8560 EOF
8561 if { (eval echo configure:8562: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8562   rm -rf conftest*
8563   glibcpp_cv_func_modff_use=yes
8564 else
8565   echo "configure: failed program was:" >&5
8566   cat conftest.$ac_ext >&5
8567   rm -rf conftest*
8568   glibcpp_cv_func_modff_use=no
8569 fi
8570 rm -f conftest*
8571       ac_ext=c
8572 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8573 ac_cpp='$CPP $CPPFLAGS'
8574 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8575 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8576 cross_compiling=$ac_cv_prog_cc_cross
8577
8578
8579 fi
8580
8581   fi
8582   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
8583   if test x$glibcpp_cv_func_modff_use = x"yes"; then
8584     for ac_func in modff
8585 do
8586 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8587 echo "configure:8588: checking for $ac_func" >&5
8588 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8589   echo $ac_n "(cached) $ac_c" 1>&6
8590 else
8591   cat > conftest.$ac_ext <<EOF
8592 #line 8593 "configure"
8593 #include "confdefs.h"
8594 /* System header to define __stub macros and hopefully few prototypes,
8595     which can conflict with char $ac_func(); below.  */
8596 #include <assert.h>
8597 /* Override any gcc2 internal prototype to avoid an error.  */
8598 /* We use char because int might match the return type of a gcc2
8599     builtin and then its argument prototype would still apply.  */
8600 char $ac_func();
8601
8602 int main() {
8603
8604 /* The GNU C library defines this for functions which it implements
8605     to always fail with ENOSYS.  Some functions are actually named
8606     something starting with __ and the normal name is an alias.  */
8607 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8608 choke me
8609 #else
8610 $ac_func();
8611 #endif
8612
8613 ; return 0; }
8614 EOF
8615 if { (eval echo configure:8616: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8616   rm -rf conftest*
8617   eval "ac_cv_func_$ac_func=yes"
8618 else
8619   echo "configure: failed program was:" >&5
8620   cat conftest.$ac_ext >&5
8621   rm -rf conftest*
8622   eval "ac_cv_func_$ac_func=no"
8623 fi
8624 rm -f conftest*
8625 fi
8626
8627 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8628   echo "$ac_t""yes" 1>&6
8629     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8630   cat >> confdefs.h <<EOF
8631 #define $ac_tr_func 1
8632 EOF
8633
8634 else
8635   echo "$ac_t""no" 1>&6
8636 fi
8637 done
8638
8639   fi
8640
8641
8642   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
8643 echo "configure:8644: checking for powf declaration" >&5
8644   if test x${glibcpp_cv_func_powf_use+set} != xset; then
8645     if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
8646   echo $ac_n "(cached) $ac_c" 1>&6
8647 else
8648
8649
8650       ac_ext=C
8651 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8652 ac_cpp='$CXXCPP $CPPFLAGS'
8653 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8654 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8655 cross_compiling=$ac_cv_prog_cxx_cross
8656
8657       cat > conftest.$ac_ext <<EOF
8658 #line 8659 "configure"
8659 #include "confdefs.h"
8660 #include <math.h>
8661 int main() {
8662  powf(0, 0);
8663 ; return 0; }
8664 EOF
8665 if { (eval echo configure:8666: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8666   rm -rf conftest*
8667   glibcpp_cv_func_powf_use=yes
8668 else
8669   echo "configure: failed program was:" >&5
8670   cat conftest.$ac_ext >&5
8671   rm -rf conftest*
8672   glibcpp_cv_func_powf_use=no
8673 fi
8674 rm -f conftest*
8675       ac_ext=c
8676 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8677 ac_cpp='$CPP $CPPFLAGS'
8678 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8679 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8680 cross_compiling=$ac_cv_prog_cc_cross
8681
8682
8683 fi
8684
8685   fi
8686   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
8687   if test x$glibcpp_cv_func_powf_use = x"yes"; then
8688     for ac_func in powf
8689 do
8690 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8691 echo "configure:8692: checking for $ac_func" >&5
8692 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8693   echo $ac_n "(cached) $ac_c" 1>&6
8694 else
8695   cat > conftest.$ac_ext <<EOF
8696 #line 8697 "configure"
8697 #include "confdefs.h"
8698 /* System header to define __stub macros and hopefully few prototypes,
8699     which can conflict with char $ac_func(); below.  */
8700 #include <assert.h>
8701 /* Override any gcc2 internal prototype to avoid an error.  */
8702 /* We use char because int might match the return type of a gcc2
8703     builtin and then its argument prototype would still apply.  */
8704 char $ac_func();
8705
8706 int main() {
8707
8708 /* The GNU C library defines this for functions which it implements
8709     to always fail with ENOSYS.  Some functions are actually named
8710     something starting with __ and the normal name is an alias.  */
8711 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8712 choke me
8713 #else
8714 $ac_func();
8715 #endif
8716
8717 ; return 0; }
8718 EOF
8719 if { (eval echo configure:8720: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8720   rm -rf conftest*
8721   eval "ac_cv_func_$ac_func=yes"
8722 else
8723   echo "configure: failed program was:" >&5
8724   cat conftest.$ac_ext >&5
8725   rm -rf conftest*
8726   eval "ac_cv_func_$ac_func=no"
8727 fi
8728 rm -f conftest*
8729 fi
8730
8731 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8732   echo "$ac_t""yes" 1>&6
8733     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8734   cat >> confdefs.h <<EOF
8735 #define $ac_tr_func 1
8736 EOF
8737
8738 else
8739   echo "$ac_t""no" 1>&6
8740 fi
8741 done
8742
8743   fi
8744
8745
8746   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
8747 echo "configure:8748: checking for sinf declaration" >&5
8748   if test x${glibcpp_cv_func_sinf_use+set} != xset; then
8749     if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
8750   echo $ac_n "(cached) $ac_c" 1>&6
8751 else
8752
8753
8754       ac_ext=C
8755 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8756 ac_cpp='$CXXCPP $CPPFLAGS'
8757 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8758 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8759 cross_compiling=$ac_cv_prog_cxx_cross
8760
8761       cat > conftest.$ac_ext <<EOF
8762 #line 8763 "configure"
8763 #include "confdefs.h"
8764 #include <math.h>
8765 int main() {
8766  sinf(0);
8767 ; return 0; }
8768 EOF
8769 if { (eval echo configure:8770: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8770   rm -rf conftest*
8771   glibcpp_cv_func_sinf_use=yes
8772 else
8773   echo "configure: failed program was:" >&5
8774   cat conftest.$ac_ext >&5
8775   rm -rf conftest*
8776   glibcpp_cv_func_sinf_use=no
8777 fi
8778 rm -f conftest*
8779       ac_ext=c
8780 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8781 ac_cpp='$CPP $CPPFLAGS'
8782 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8783 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8784 cross_compiling=$ac_cv_prog_cc_cross
8785
8786
8787 fi
8788
8789   fi
8790   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
8791   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
8792     for ac_func in sinf
8793 do
8794 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8795 echo "configure:8796: checking for $ac_func" >&5
8796 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8797   echo $ac_n "(cached) $ac_c" 1>&6
8798 else
8799   cat > conftest.$ac_ext <<EOF
8800 #line 8801 "configure"
8801 #include "confdefs.h"
8802 /* System header to define __stub macros and hopefully few prototypes,
8803     which can conflict with char $ac_func(); below.  */
8804 #include <assert.h>
8805 /* Override any gcc2 internal prototype to avoid an error.  */
8806 /* We use char because int might match the return type of a gcc2
8807     builtin and then its argument prototype would still apply.  */
8808 char $ac_func();
8809
8810 int main() {
8811
8812 /* The GNU C library defines this for functions which it implements
8813     to always fail with ENOSYS.  Some functions are actually named
8814     something starting with __ and the normal name is an alias.  */
8815 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8816 choke me
8817 #else
8818 $ac_func();
8819 #endif
8820
8821 ; return 0; }
8822 EOF
8823 if { (eval echo configure:8824: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8824   rm -rf conftest*
8825   eval "ac_cv_func_$ac_func=yes"
8826 else
8827   echo "configure: failed program was:" >&5
8828   cat conftest.$ac_ext >&5
8829   rm -rf conftest*
8830   eval "ac_cv_func_$ac_func=no"
8831 fi
8832 rm -f conftest*
8833 fi
8834
8835 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8836   echo "$ac_t""yes" 1>&6
8837     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8838   cat >> confdefs.h <<EOF
8839 #define $ac_tr_func 1
8840 EOF
8841
8842 else
8843   echo "$ac_t""no" 1>&6
8844 fi
8845 done
8846
8847   fi
8848
8849
8850   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
8851 echo "configure:8852: checking for sinhf declaration" >&5
8852   if test x${glibcpp_cv_func_sinhf_use+set} != xset; then
8853     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
8854   echo $ac_n "(cached) $ac_c" 1>&6
8855 else
8856
8857
8858       ac_ext=C
8859 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8860 ac_cpp='$CXXCPP $CPPFLAGS'
8861 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8862 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8863 cross_compiling=$ac_cv_prog_cxx_cross
8864
8865       cat > conftest.$ac_ext <<EOF
8866 #line 8867 "configure"
8867 #include "confdefs.h"
8868 #include <math.h>
8869 int main() {
8870  sinhf(0);
8871 ; return 0; }
8872 EOF
8873 if { (eval echo configure:8874: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8874   rm -rf conftest*
8875   glibcpp_cv_func_sinhf_use=yes
8876 else
8877   echo "configure: failed program was:" >&5
8878   cat conftest.$ac_ext >&5
8879   rm -rf conftest*
8880   glibcpp_cv_func_sinhf_use=no
8881 fi
8882 rm -f conftest*
8883       ac_ext=c
8884 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8885 ac_cpp='$CPP $CPPFLAGS'
8886 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8887 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8888 cross_compiling=$ac_cv_prog_cc_cross
8889
8890
8891 fi
8892
8893   fi
8894   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
8895   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
8896     for ac_func in sinhf
8897 do
8898 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8899 echo "configure:8900: checking for $ac_func" >&5
8900 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8901   echo $ac_n "(cached) $ac_c" 1>&6
8902 else
8903   cat > conftest.$ac_ext <<EOF
8904 #line 8905 "configure"
8905 #include "confdefs.h"
8906 /* System header to define __stub macros and hopefully few prototypes,
8907     which can conflict with char $ac_func(); below.  */
8908 #include <assert.h>
8909 /* Override any gcc2 internal prototype to avoid an error.  */
8910 /* We use char because int might match the return type of a gcc2
8911     builtin and then its argument prototype would still apply.  */
8912 char $ac_func();
8913
8914 int main() {
8915
8916 /* The GNU C library defines this for functions which it implements
8917     to always fail with ENOSYS.  Some functions are actually named
8918     something starting with __ and the normal name is an alias.  */
8919 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8920 choke me
8921 #else
8922 $ac_func();
8923 #endif
8924
8925 ; return 0; }
8926 EOF
8927 if { (eval echo configure:8928: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8928   rm -rf conftest*
8929   eval "ac_cv_func_$ac_func=yes"
8930 else
8931   echo "configure: failed program was:" >&5
8932   cat conftest.$ac_ext >&5
8933   rm -rf conftest*
8934   eval "ac_cv_func_$ac_func=no"
8935 fi
8936 rm -f conftest*
8937 fi
8938
8939 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8940   echo "$ac_t""yes" 1>&6
8941     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8942   cat >> confdefs.h <<EOF
8943 #define $ac_tr_func 1
8944 EOF
8945
8946 else
8947   echo "$ac_t""no" 1>&6
8948 fi
8949 done
8950
8951   fi
8952
8953
8954   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
8955 echo "configure:8956: checking for sqrtf declaration" >&5
8956   if test x${glibcpp_cv_func_sqrtf_use+set} != xset; then
8957     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
8958   echo $ac_n "(cached) $ac_c" 1>&6
8959 else
8960
8961
8962       ac_ext=C
8963 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8964 ac_cpp='$CXXCPP $CPPFLAGS'
8965 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8966 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8967 cross_compiling=$ac_cv_prog_cxx_cross
8968
8969       cat > conftest.$ac_ext <<EOF
8970 #line 8971 "configure"
8971 #include "confdefs.h"
8972 #include <math.h>
8973 int main() {
8974  sqrtf(0);
8975 ; return 0; }
8976 EOF
8977 if { (eval echo configure:8978: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8978   rm -rf conftest*
8979   glibcpp_cv_func_sqrtf_use=yes
8980 else
8981   echo "configure: failed program was:" >&5
8982   cat conftest.$ac_ext >&5
8983   rm -rf conftest*
8984   glibcpp_cv_func_sqrtf_use=no
8985 fi
8986 rm -f conftest*
8987       ac_ext=c
8988 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8989 ac_cpp='$CPP $CPPFLAGS'
8990 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8991 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8992 cross_compiling=$ac_cv_prog_cc_cross
8993
8994
8995 fi
8996
8997   fi
8998   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
8999   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
9000     for ac_func in sqrtf
9001 do
9002 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9003 echo "configure:9004: checking for $ac_func" >&5
9004 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9005   echo $ac_n "(cached) $ac_c" 1>&6
9006 else
9007   cat > conftest.$ac_ext <<EOF
9008 #line 9009 "configure"
9009 #include "confdefs.h"
9010 /* System header to define __stub macros and hopefully few prototypes,
9011     which can conflict with char $ac_func(); below.  */
9012 #include <assert.h>
9013 /* Override any gcc2 internal prototype to avoid an error.  */
9014 /* We use char because int might match the return type of a gcc2
9015     builtin and then its argument prototype would still apply.  */
9016 char $ac_func();
9017
9018 int main() {
9019
9020 /* The GNU C library defines this for functions which it implements
9021     to always fail with ENOSYS.  Some functions are actually named
9022     something starting with __ and the normal name is an alias.  */
9023 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9024 choke me
9025 #else
9026 $ac_func();
9027 #endif
9028
9029 ; return 0; }
9030 EOF
9031 if { (eval echo configure:9032: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9032   rm -rf conftest*
9033   eval "ac_cv_func_$ac_func=yes"
9034 else
9035   echo "configure: failed program was:" >&5
9036   cat conftest.$ac_ext >&5
9037   rm -rf conftest*
9038   eval "ac_cv_func_$ac_func=no"
9039 fi
9040 rm -f conftest*
9041 fi
9042
9043 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9044   echo "$ac_t""yes" 1>&6
9045     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9046   cat >> confdefs.h <<EOF
9047 #define $ac_tr_func 1
9048 EOF
9049
9050 else
9051   echo "$ac_t""no" 1>&6
9052 fi
9053 done
9054
9055   fi
9056
9057
9058   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
9059 echo "configure:9060: checking for tanf declaration" >&5
9060   if test x${glibcpp_cv_func_tanf_use+set} != xset; then
9061     if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
9062   echo $ac_n "(cached) $ac_c" 1>&6
9063 else
9064
9065
9066       ac_ext=C
9067 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9068 ac_cpp='$CXXCPP $CPPFLAGS'
9069 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9070 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9071 cross_compiling=$ac_cv_prog_cxx_cross
9072
9073       cat > conftest.$ac_ext <<EOF
9074 #line 9075 "configure"
9075 #include "confdefs.h"
9076 #include <math.h>
9077 int main() {
9078  tanf(0);
9079 ; return 0; }
9080 EOF
9081 if { (eval echo configure:9082: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9082   rm -rf conftest*
9083   glibcpp_cv_func_tanf_use=yes
9084 else
9085   echo "configure: failed program was:" >&5
9086   cat conftest.$ac_ext >&5
9087   rm -rf conftest*
9088   glibcpp_cv_func_tanf_use=no
9089 fi
9090 rm -f conftest*
9091       ac_ext=c
9092 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9093 ac_cpp='$CPP $CPPFLAGS'
9094 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9095 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9096 cross_compiling=$ac_cv_prog_cc_cross
9097
9098
9099 fi
9100
9101   fi
9102   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
9103   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
9104     for ac_func in tanf
9105 do
9106 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9107 echo "configure:9108: checking for $ac_func" >&5
9108 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9109   echo $ac_n "(cached) $ac_c" 1>&6
9110 else
9111   cat > conftest.$ac_ext <<EOF
9112 #line 9113 "configure"
9113 #include "confdefs.h"
9114 /* System header to define __stub macros and hopefully few prototypes,
9115     which can conflict with char $ac_func(); below.  */
9116 #include <assert.h>
9117 /* Override any gcc2 internal prototype to avoid an error.  */
9118 /* We use char because int might match the return type of a gcc2
9119     builtin and then its argument prototype would still apply.  */
9120 char $ac_func();
9121
9122 int main() {
9123
9124 /* The GNU C library defines this for functions which it implements
9125     to always fail with ENOSYS.  Some functions are actually named
9126     something starting with __ and the normal name is an alias.  */
9127 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9128 choke me
9129 #else
9130 $ac_func();
9131 #endif
9132
9133 ; return 0; }
9134 EOF
9135 if { (eval echo configure:9136: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9136   rm -rf conftest*
9137   eval "ac_cv_func_$ac_func=yes"
9138 else
9139   echo "configure: failed program was:" >&5
9140   cat conftest.$ac_ext >&5
9141   rm -rf conftest*
9142   eval "ac_cv_func_$ac_func=no"
9143 fi
9144 rm -f conftest*
9145 fi
9146
9147 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9148   echo "$ac_t""yes" 1>&6
9149     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9150   cat >> confdefs.h <<EOF
9151 #define $ac_tr_func 1
9152 EOF
9153
9154 else
9155   echo "$ac_t""no" 1>&6
9156 fi
9157 done
9158
9159   fi
9160
9161
9162   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
9163 echo "configure:9164: checking for tanhf declaration" >&5
9164   if test x${glibcpp_cv_func_tanhf_use+set} != xset; then
9165     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
9166   echo $ac_n "(cached) $ac_c" 1>&6
9167 else
9168
9169
9170       ac_ext=C
9171 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9172 ac_cpp='$CXXCPP $CPPFLAGS'
9173 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9174 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9175 cross_compiling=$ac_cv_prog_cxx_cross
9176
9177       cat > conftest.$ac_ext <<EOF
9178 #line 9179 "configure"
9179 #include "confdefs.h"
9180 #include <math.h>
9181 int main() {
9182  tanhf(0);
9183 ; return 0; }
9184 EOF
9185 if { (eval echo configure:9186: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9186   rm -rf conftest*
9187   glibcpp_cv_func_tanhf_use=yes
9188 else
9189   echo "configure: failed program was:" >&5
9190   cat conftest.$ac_ext >&5
9191   rm -rf conftest*
9192   glibcpp_cv_func_tanhf_use=no
9193 fi
9194 rm -f conftest*
9195       ac_ext=c
9196 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9197 ac_cpp='$CPP $CPPFLAGS'
9198 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9199 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9200 cross_compiling=$ac_cv_prog_cc_cross
9201
9202
9203 fi
9204
9205   fi
9206   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
9207   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
9208     for ac_func in tanhf
9209 do
9210 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9211 echo "configure:9212: checking for $ac_func" >&5
9212 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9213   echo $ac_n "(cached) $ac_c" 1>&6
9214 else
9215   cat > conftest.$ac_ext <<EOF
9216 #line 9217 "configure"
9217 #include "confdefs.h"
9218 /* System header to define __stub macros and hopefully few prototypes,
9219     which can conflict with char $ac_func(); below.  */
9220 #include <assert.h>
9221 /* Override any gcc2 internal prototype to avoid an error.  */
9222 /* We use char because int might match the return type of a gcc2
9223     builtin and then its argument prototype would still apply.  */
9224 char $ac_func();
9225
9226 int main() {
9227
9228 /* The GNU C library defines this for functions which it implements
9229     to always fail with ENOSYS.  Some functions are actually named
9230     something starting with __ and the normal name is an alias.  */
9231 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9232 choke me
9233 #else
9234 $ac_func();
9235 #endif
9236
9237 ; return 0; }
9238 EOF
9239 if { (eval echo configure:9240: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9240   rm -rf conftest*
9241   eval "ac_cv_func_$ac_func=yes"
9242 else
9243   echo "configure: failed program was:" >&5
9244   cat conftest.$ac_ext >&5
9245   rm -rf conftest*
9246   eval "ac_cv_func_$ac_func=no"
9247 fi
9248 rm -f conftest*
9249 fi
9250
9251 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9252   echo "$ac_t""yes" 1>&6
9253     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9254   cat >> confdefs.h <<EOF
9255 #define $ac_tr_func 1
9256 EOF
9257
9258 else
9259   echo "$ac_t""no" 1>&6
9260 fi
9261 done
9262
9263   fi
9264
9265
9266   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
9267 echo "configure:9268: checking for sincosf declaration" >&5
9268   if test x${glibcpp_cv_func_sincosf_use+set} != xset; then
9269     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
9270   echo $ac_n "(cached) $ac_c" 1>&6
9271 else
9272
9273
9274       ac_ext=C
9275 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9276 ac_cpp='$CXXCPP $CPPFLAGS'
9277 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9278 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9279 cross_compiling=$ac_cv_prog_cxx_cross
9280
9281       cat > conftest.$ac_ext <<EOF
9282 #line 9283 "configure"
9283 #include "confdefs.h"
9284 #include <math.h>
9285 int main() {
9286  sincosf(0, 0, 0);
9287 ; return 0; }
9288 EOF
9289 if { (eval echo configure:9290: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9290   rm -rf conftest*
9291   glibcpp_cv_func_sincosf_use=yes
9292 else
9293   echo "configure: failed program was:" >&5
9294   cat conftest.$ac_ext >&5
9295   rm -rf conftest*
9296   glibcpp_cv_func_sincosf_use=no
9297 fi
9298 rm -f conftest*
9299       ac_ext=c
9300 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9301 ac_cpp='$CPP $CPPFLAGS'
9302 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9303 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9304 cross_compiling=$ac_cv_prog_cc_cross
9305
9306
9307 fi
9308
9309   fi
9310   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
9311   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
9312     for ac_func in sincosf
9313 do
9314 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9315 echo "configure:9316: checking for $ac_func" >&5
9316 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9317   echo $ac_n "(cached) $ac_c" 1>&6
9318 else
9319   cat > conftest.$ac_ext <<EOF
9320 #line 9321 "configure"
9321 #include "confdefs.h"
9322 /* System header to define __stub macros and hopefully few prototypes,
9323     which can conflict with char $ac_func(); below.  */
9324 #include <assert.h>
9325 /* Override any gcc2 internal prototype to avoid an error.  */
9326 /* We use char because int might match the return type of a gcc2
9327     builtin and then its argument prototype would still apply.  */
9328 char $ac_func();
9329
9330 int main() {
9331
9332 /* The GNU C library defines this for functions which it implements
9333     to always fail with ENOSYS.  Some functions are actually named
9334     something starting with __ and the normal name is an alias.  */
9335 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9336 choke me
9337 #else
9338 $ac_func();
9339 #endif
9340
9341 ; return 0; }
9342 EOF
9343 if { (eval echo configure:9344: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9344   rm -rf conftest*
9345   eval "ac_cv_func_$ac_func=yes"
9346 else
9347   echo "configure: failed program was:" >&5
9348   cat conftest.$ac_ext >&5
9349   rm -rf conftest*
9350   eval "ac_cv_func_$ac_func=no"
9351 fi
9352 rm -f conftest*
9353 fi
9354
9355 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9356   echo "$ac_t""yes" 1>&6
9357     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9358   cat >> confdefs.h <<EOF
9359 #define $ac_tr_func 1
9360 EOF
9361
9362 else
9363   echo "$ac_t""no" 1>&6
9364 fi
9365 done
9366
9367   fi
9368
9369
9370   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
9371 echo "configure:9372: checking for finitef declaration" >&5
9372   if test x${glibcpp_cv_func_finitef_use+set} != xset; then
9373     if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
9374   echo $ac_n "(cached) $ac_c" 1>&6
9375 else
9376
9377
9378       ac_ext=C
9379 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9380 ac_cpp='$CXXCPP $CPPFLAGS'
9381 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9382 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9383 cross_compiling=$ac_cv_prog_cxx_cross
9384
9385       cat > conftest.$ac_ext <<EOF
9386 #line 9387 "configure"
9387 #include "confdefs.h"
9388 #include <math.h>
9389 int main() {
9390  finitef(0);
9391 ; return 0; }
9392 EOF
9393 if { (eval echo configure:9394: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9394   rm -rf conftest*
9395   glibcpp_cv_func_finitef_use=yes
9396 else
9397   echo "configure: failed program was:" >&5
9398   cat conftest.$ac_ext >&5
9399   rm -rf conftest*
9400   glibcpp_cv_func_finitef_use=no
9401 fi
9402 rm -f conftest*
9403       ac_ext=c
9404 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9405 ac_cpp='$CPP $CPPFLAGS'
9406 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9407 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9408 cross_compiling=$ac_cv_prog_cc_cross
9409
9410
9411 fi
9412
9413   fi
9414   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
9415   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
9416     for ac_func in finitef
9417 do
9418 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9419 echo "configure:9420: checking for $ac_func" >&5
9420 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9421   echo $ac_n "(cached) $ac_c" 1>&6
9422 else
9423   cat > conftest.$ac_ext <<EOF
9424 #line 9425 "configure"
9425 #include "confdefs.h"
9426 /* System header to define __stub macros and hopefully few prototypes,
9427     which can conflict with char $ac_func(); below.  */
9428 #include <assert.h>
9429 /* Override any gcc2 internal prototype to avoid an error.  */
9430 /* We use char because int might match the return type of a gcc2
9431     builtin and then its argument prototype would still apply.  */
9432 char $ac_func();
9433
9434 int main() {
9435
9436 /* The GNU C library defines this for functions which it implements
9437     to always fail with ENOSYS.  Some functions are actually named
9438     something starting with __ and the normal name is an alias.  */
9439 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9440 choke me
9441 #else
9442 $ac_func();
9443 #endif
9444
9445 ; return 0; }
9446 EOF
9447 if { (eval echo configure:9448: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9448   rm -rf conftest*
9449   eval "ac_cv_func_$ac_func=yes"
9450 else
9451   echo "configure: failed program was:" >&5
9452   cat conftest.$ac_ext >&5
9453   rm -rf conftest*
9454   eval "ac_cv_func_$ac_func=no"
9455 fi
9456 rm -f conftest*
9457 fi
9458
9459 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9460   echo "$ac_t""yes" 1>&6
9461     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9462   cat >> confdefs.h <<EOF
9463 #define $ac_tr_func 1
9464 EOF
9465
9466 else
9467   echo "$ac_t""no" 1>&6
9468 fi
9469 done
9470
9471   fi
9472
9473
9474
9475   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
9476 echo "configure:9477: checking for isnanl declaration" >&5
9477   if test x${glibcpp_cv_func_isnanl_use+set} != xset; then
9478     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
9479   echo $ac_n "(cached) $ac_c" 1>&6
9480 else
9481
9482
9483       ac_ext=C
9484 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9485 ac_cpp='$CXXCPP $CPPFLAGS'
9486 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9487 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9488 cross_compiling=$ac_cv_prog_cxx_cross
9489
9490       cat > conftest.$ac_ext <<EOF
9491 #line 9492 "configure"
9492 #include "confdefs.h"
9493 #include <math.h>
9494 int main() {
9495  isnanl(0);
9496 ; return 0; }
9497 EOF
9498 if { (eval echo configure:9499: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9499   rm -rf conftest*
9500   glibcpp_cv_func_isnanl_use=yes
9501 else
9502   echo "configure: failed program was:" >&5
9503   cat conftest.$ac_ext >&5
9504   rm -rf conftest*
9505   glibcpp_cv_func_isnanl_use=no
9506 fi
9507 rm -f conftest*
9508       ac_ext=c
9509 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9510 ac_cpp='$CPP $CPPFLAGS'
9511 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9512 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9513 cross_compiling=$ac_cv_prog_cc_cross
9514
9515
9516 fi
9517
9518   fi
9519   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
9520   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
9521     for ac_func in isnanl
9522 do
9523 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9524 echo "configure:9525: checking for $ac_func" >&5
9525 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9526   echo $ac_n "(cached) $ac_c" 1>&6
9527 else
9528   cat > conftest.$ac_ext <<EOF
9529 #line 9530 "configure"
9530 #include "confdefs.h"
9531 /* System header to define __stub macros and hopefully few prototypes,
9532     which can conflict with char $ac_func(); below.  */
9533 #include <assert.h>
9534 /* Override any gcc2 internal prototype to avoid an error.  */
9535 /* We use char because int might match the return type of a gcc2
9536     builtin and then its argument prototype would still apply.  */
9537 char $ac_func();
9538
9539 int main() {
9540
9541 /* The GNU C library defines this for functions which it implements
9542     to always fail with ENOSYS.  Some functions are actually named
9543     something starting with __ and the normal name is an alias.  */
9544 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9545 choke me
9546 #else
9547 $ac_func();
9548 #endif
9549
9550 ; return 0; }
9551 EOF
9552 if { (eval echo configure:9553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9553   rm -rf conftest*
9554   eval "ac_cv_func_$ac_func=yes"
9555 else
9556   echo "configure: failed program was:" >&5
9557   cat conftest.$ac_ext >&5
9558   rm -rf conftest*
9559   eval "ac_cv_func_$ac_func=no"
9560 fi
9561 rm -f conftest*
9562 fi
9563
9564 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9565   echo "$ac_t""yes" 1>&6
9566     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9567   cat >> confdefs.h <<EOF
9568 #define $ac_tr_func 1
9569 EOF
9570
9571 else
9572   echo "$ac_t""no" 1>&6
9573 fi
9574 done
9575
9576   fi
9577
9578
9579   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
9580 echo "configure:9581: checking for isinfl declaration" >&5
9581   if test x${glibcpp_cv_func_isinfl_use+set} != xset; then
9582     if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
9583   echo $ac_n "(cached) $ac_c" 1>&6
9584 else
9585
9586
9587       ac_ext=C
9588 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9589 ac_cpp='$CXXCPP $CPPFLAGS'
9590 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9591 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9592 cross_compiling=$ac_cv_prog_cxx_cross
9593
9594       cat > conftest.$ac_ext <<EOF
9595 #line 9596 "configure"
9596 #include "confdefs.h"
9597 #include <math.h>
9598 int main() {
9599  isinfl(0);
9600 ; return 0; }
9601 EOF
9602 if { (eval echo configure:9603: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9603   rm -rf conftest*
9604   glibcpp_cv_func_isinfl_use=yes
9605 else
9606   echo "configure: failed program was:" >&5
9607   cat conftest.$ac_ext >&5
9608   rm -rf conftest*
9609   glibcpp_cv_func_isinfl_use=no
9610 fi
9611 rm -f conftest*
9612       ac_ext=c
9613 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9614 ac_cpp='$CPP $CPPFLAGS'
9615 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9616 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9617 cross_compiling=$ac_cv_prog_cc_cross
9618
9619
9620 fi
9621
9622   fi
9623   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
9624   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
9625     for ac_func in isinfl
9626 do
9627 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9628 echo "configure:9629: checking for $ac_func" >&5
9629 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9630   echo $ac_n "(cached) $ac_c" 1>&6
9631 else
9632   cat > conftest.$ac_ext <<EOF
9633 #line 9634 "configure"
9634 #include "confdefs.h"
9635 /* System header to define __stub macros and hopefully few prototypes,
9636     which can conflict with char $ac_func(); below.  */
9637 #include <assert.h>
9638 /* Override any gcc2 internal prototype to avoid an error.  */
9639 /* We use char because int might match the return type of a gcc2
9640     builtin and then its argument prototype would still apply.  */
9641 char $ac_func();
9642
9643 int main() {
9644
9645 /* The GNU C library defines this for functions which it implements
9646     to always fail with ENOSYS.  Some functions are actually named
9647     something starting with __ and the normal name is an alias.  */
9648 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9649 choke me
9650 #else
9651 $ac_func();
9652 #endif
9653
9654 ; return 0; }
9655 EOF
9656 if { (eval echo configure:9657: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9657   rm -rf conftest*
9658   eval "ac_cv_func_$ac_func=yes"
9659 else
9660   echo "configure: failed program was:" >&5
9661   cat conftest.$ac_ext >&5
9662   rm -rf conftest*
9663   eval "ac_cv_func_$ac_func=no"
9664 fi
9665 rm -f conftest*
9666 fi
9667
9668 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9669   echo "$ac_t""yes" 1>&6
9670     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9671   cat >> confdefs.h <<EOF
9672 #define $ac_tr_func 1
9673 EOF
9674
9675 else
9676   echo "$ac_t""no" 1>&6
9677 fi
9678 done
9679
9680   fi
9681
9682
9683   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
9684 echo "configure:9685: checking for copysignl declaration" >&5
9685   if test x${glibcpp_cv_func_copysignl_use+set} != xset; then
9686     if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
9687   echo $ac_n "(cached) $ac_c" 1>&6
9688 else
9689
9690
9691       ac_ext=C
9692 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9693 ac_cpp='$CXXCPP $CPPFLAGS'
9694 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9695 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9696 cross_compiling=$ac_cv_prog_cxx_cross
9697
9698       cat > conftest.$ac_ext <<EOF
9699 #line 9700 "configure"
9700 #include "confdefs.h"
9701 #include <math.h>
9702 int main() {
9703  copysignl(0, 0);
9704 ; return 0; }
9705 EOF
9706 if { (eval echo configure:9707: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9707   rm -rf conftest*
9708   glibcpp_cv_func_copysignl_use=yes
9709 else
9710   echo "configure: failed program was:" >&5
9711   cat conftest.$ac_ext >&5
9712   rm -rf conftest*
9713   glibcpp_cv_func_copysignl_use=no
9714 fi
9715 rm -f conftest*
9716       ac_ext=c
9717 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9718 ac_cpp='$CPP $CPPFLAGS'
9719 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9720 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9721 cross_compiling=$ac_cv_prog_cc_cross
9722
9723
9724 fi
9725
9726   fi
9727   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
9728   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
9729     for ac_func in copysignl
9730 do
9731 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9732 echo "configure:9733: checking for $ac_func" >&5
9733 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9734   echo $ac_n "(cached) $ac_c" 1>&6
9735 else
9736   cat > conftest.$ac_ext <<EOF
9737 #line 9738 "configure"
9738 #include "confdefs.h"
9739 /* System header to define __stub macros and hopefully few prototypes,
9740     which can conflict with char $ac_func(); below.  */
9741 #include <assert.h>
9742 /* Override any gcc2 internal prototype to avoid an error.  */
9743 /* We use char because int might match the return type of a gcc2
9744     builtin and then its argument prototype would still apply.  */
9745 char $ac_func();
9746
9747 int main() {
9748
9749 /* The GNU C library defines this for functions which it implements
9750     to always fail with ENOSYS.  Some functions are actually named
9751     something starting with __ and the normal name is an alias.  */
9752 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9753 choke me
9754 #else
9755 $ac_func();
9756 #endif
9757
9758 ; return 0; }
9759 EOF
9760 if { (eval echo configure:9761: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9761   rm -rf conftest*
9762   eval "ac_cv_func_$ac_func=yes"
9763 else
9764   echo "configure: failed program was:" >&5
9765   cat conftest.$ac_ext >&5
9766   rm -rf conftest*
9767   eval "ac_cv_func_$ac_func=no"
9768 fi
9769 rm -f conftest*
9770 fi
9771
9772 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9773   echo "$ac_t""yes" 1>&6
9774     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9775   cat >> confdefs.h <<EOF
9776 #define $ac_tr_func 1
9777 EOF
9778
9779 else
9780   echo "$ac_t""no" 1>&6
9781 fi
9782 done
9783
9784   fi
9785
9786
9787   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
9788 echo "configure:9789: checking for acosl declaration" >&5
9789   if test x${glibcpp_cv_func_acosl_use+set} != xset; then
9790     if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
9791   echo $ac_n "(cached) $ac_c" 1>&6
9792 else
9793
9794
9795       ac_ext=C
9796 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9797 ac_cpp='$CXXCPP $CPPFLAGS'
9798 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9799 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9800 cross_compiling=$ac_cv_prog_cxx_cross
9801
9802       cat > conftest.$ac_ext <<EOF
9803 #line 9804 "configure"
9804 #include "confdefs.h"
9805 #include <math.h>
9806 int main() {
9807  acosl(0);
9808 ; return 0; }
9809 EOF
9810 if { (eval echo configure:9811: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9811   rm -rf conftest*
9812   glibcpp_cv_func_acosl_use=yes
9813 else
9814   echo "configure: failed program was:" >&5
9815   cat conftest.$ac_ext >&5
9816   rm -rf conftest*
9817   glibcpp_cv_func_acosl_use=no
9818 fi
9819 rm -f conftest*
9820       ac_ext=c
9821 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9822 ac_cpp='$CPP $CPPFLAGS'
9823 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9824 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9825 cross_compiling=$ac_cv_prog_cc_cross
9826
9827
9828 fi
9829
9830   fi
9831   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
9832   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
9833     for ac_func in acosl
9834 do
9835 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9836 echo "configure:9837: checking for $ac_func" >&5
9837 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9838   echo $ac_n "(cached) $ac_c" 1>&6
9839 else
9840   cat > conftest.$ac_ext <<EOF
9841 #line 9842 "configure"
9842 #include "confdefs.h"
9843 /* System header to define __stub macros and hopefully few prototypes,
9844     which can conflict with char $ac_func(); below.  */
9845 #include <assert.h>
9846 /* Override any gcc2 internal prototype to avoid an error.  */
9847 /* We use char because int might match the return type of a gcc2
9848     builtin and then its argument prototype would still apply.  */
9849 char $ac_func();
9850
9851 int main() {
9852
9853 /* The GNU C library defines this for functions which it implements
9854     to always fail with ENOSYS.  Some functions are actually named
9855     something starting with __ and the normal name is an alias.  */
9856 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9857 choke me
9858 #else
9859 $ac_func();
9860 #endif
9861
9862 ; return 0; }
9863 EOF
9864 if { (eval echo configure:9865: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9865   rm -rf conftest*
9866   eval "ac_cv_func_$ac_func=yes"
9867 else
9868   echo "configure: failed program was:" >&5
9869   cat conftest.$ac_ext >&5
9870   rm -rf conftest*
9871   eval "ac_cv_func_$ac_func=no"
9872 fi
9873 rm -f conftest*
9874 fi
9875
9876 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9877   echo "$ac_t""yes" 1>&6
9878     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9879   cat >> confdefs.h <<EOF
9880 #define $ac_tr_func 1
9881 EOF
9882
9883 else
9884   echo "$ac_t""no" 1>&6
9885 fi
9886 done
9887
9888   fi
9889
9890
9891   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
9892 echo "configure:9893: checking for asinl declaration" >&5
9893   if test x${glibcpp_cv_func_asinl_use+set} != xset; then
9894     if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
9895   echo $ac_n "(cached) $ac_c" 1>&6
9896 else
9897
9898
9899       ac_ext=C
9900 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9901 ac_cpp='$CXXCPP $CPPFLAGS'
9902 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9903 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9904 cross_compiling=$ac_cv_prog_cxx_cross
9905
9906       cat > conftest.$ac_ext <<EOF
9907 #line 9908 "configure"
9908 #include "confdefs.h"
9909 #include <math.h>
9910 int main() {
9911  asinl(0);
9912 ; return 0; }
9913 EOF
9914 if { (eval echo configure:9915: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9915   rm -rf conftest*
9916   glibcpp_cv_func_asinl_use=yes
9917 else
9918   echo "configure: failed program was:" >&5
9919   cat conftest.$ac_ext >&5
9920   rm -rf conftest*
9921   glibcpp_cv_func_asinl_use=no
9922 fi
9923 rm -f conftest*
9924       ac_ext=c
9925 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9926 ac_cpp='$CPP $CPPFLAGS'
9927 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9928 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9929 cross_compiling=$ac_cv_prog_cc_cross
9930
9931
9932 fi
9933
9934   fi
9935   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
9936   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
9937     for ac_func in asinl
9938 do
9939 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9940 echo "configure:9941: checking for $ac_func" >&5
9941 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9942   echo $ac_n "(cached) $ac_c" 1>&6
9943 else
9944   cat > conftest.$ac_ext <<EOF
9945 #line 9946 "configure"
9946 #include "confdefs.h"
9947 /* System header to define __stub macros and hopefully few prototypes,
9948     which can conflict with char $ac_func(); below.  */
9949 #include <assert.h>
9950 /* Override any gcc2 internal prototype to avoid an error.  */
9951 /* We use char because int might match the return type of a gcc2
9952     builtin and then its argument prototype would still apply.  */
9953 char $ac_func();
9954
9955 int main() {
9956
9957 /* The GNU C library defines this for functions which it implements
9958     to always fail with ENOSYS.  Some functions are actually named
9959     something starting with __ and the normal name is an alias.  */
9960 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9961 choke me
9962 #else
9963 $ac_func();
9964 #endif
9965
9966 ; return 0; }
9967 EOF
9968 if { (eval echo configure:9969: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9969   rm -rf conftest*
9970   eval "ac_cv_func_$ac_func=yes"
9971 else
9972   echo "configure: failed program was:" >&5
9973   cat conftest.$ac_ext >&5
9974   rm -rf conftest*
9975   eval "ac_cv_func_$ac_func=no"
9976 fi
9977 rm -f conftest*
9978 fi
9979
9980 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9981   echo "$ac_t""yes" 1>&6
9982     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9983   cat >> confdefs.h <<EOF
9984 #define $ac_tr_func 1
9985 EOF
9986
9987 else
9988   echo "$ac_t""no" 1>&6
9989 fi
9990 done
9991
9992   fi
9993
9994
9995   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
9996 echo "configure:9997: checking for atanl declaration" >&5
9997   if test x${glibcpp_cv_func_atanl_use+set} != xset; then
9998     if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
9999   echo $ac_n "(cached) $ac_c" 1>&6
10000 else
10001
10002
10003       ac_ext=C
10004 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10005 ac_cpp='$CXXCPP $CPPFLAGS'
10006 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10007 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10008 cross_compiling=$ac_cv_prog_cxx_cross
10009
10010       cat > conftest.$ac_ext <<EOF
10011 #line 10012 "configure"
10012 #include "confdefs.h"
10013 #include <math.h>
10014 int main() {
10015  atanl(0);
10016 ; return 0; }
10017 EOF
10018 if { (eval echo configure:10019: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10019   rm -rf conftest*
10020   glibcpp_cv_func_atanl_use=yes
10021 else
10022   echo "configure: failed program was:" >&5
10023   cat conftest.$ac_ext >&5
10024   rm -rf conftest*
10025   glibcpp_cv_func_atanl_use=no
10026 fi
10027 rm -f conftest*
10028       ac_ext=c
10029 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10030 ac_cpp='$CPP $CPPFLAGS'
10031 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10032 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10033 cross_compiling=$ac_cv_prog_cc_cross
10034
10035
10036 fi
10037
10038   fi
10039   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
10040   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
10041     for ac_func in atanl
10042 do
10043 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10044 echo "configure:10045: checking for $ac_func" >&5
10045 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10046   echo $ac_n "(cached) $ac_c" 1>&6
10047 else
10048   cat > conftest.$ac_ext <<EOF
10049 #line 10050 "configure"
10050 #include "confdefs.h"
10051 /* System header to define __stub macros and hopefully few prototypes,
10052     which can conflict with char $ac_func(); below.  */
10053 #include <assert.h>
10054 /* Override any gcc2 internal prototype to avoid an error.  */
10055 /* We use char because int might match the return type of a gcc2
10056     builtin and then its argument prototype would still apply.  */
10057 char $ac_func();
10058
10059 int main() {
10060
10061 /* The GNU C library defines this for functions which it implements
10062     to always fail with ENOSYS.  Some functions are actually named
10063     something starting with __ and the normal name is an alias.  */
10064 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10065 choke me
10066 #else
10067 $ac_func();
10068 #endif
10069
10070 ; return 0; }
10071 EOF
10072 if { (eval echo configure:10073: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10073   rm -rf conftest*
10074   eval "ac_cv_func_$ac_func=yes"
10075 else
10076   echo "configure: failed program was:" >&5
10077   cat conftest.$ac_ext >&5
10078   rm -rf conftest*
10079   eval "ac_cv_func_$ac_func=no"
10080 fi
10081 rm -f conftest*
10082 fi
10083
10084 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10085   echo "$ac_t""yes" 1>&6
10086     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10087   cat >> confdefs.h <<EOF
10088 #define $ac_tr_func 1
10089 EOF
10090
10091 else
10092   echo "$ac_t""no" 1>&6
10093 fi
10094 done
10095
10096   fi
10097
10098
10099   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
10100 echo "configure:10101: checking for atan2l declaration" >&5
10101   if test x${glibcpp_cv_func_atan2l_use+set} != xset; then
10102     if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
10103   echo $ac_n "(cached) $ac_c" 1>&6
10104 else
10105
10106
10107       ac_ext=C
10108 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10109 ac_cpp='$CXXCPP $CPPFLAGS'
10110 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10111 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10112 cross_compiling=$ac_cv_prog_cxx_cross
10113
10114       cat > conftest.$ac_ext <<EOF
10115 #line 10116 "configure"
10116 #include "confdefs.h"
10117 #include <math.h>
10118 int main() {
10119  atan2l(0, 0);
10120 ; return 0; }
10121 EOF
10122 if { (eval echo configure:10123: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10123   rm -rf conftest*
10124   glibcpp_cv_func_atan2l_use=yes
10125 else
10126   echo "configure: failed program was:" >&5
10127   cat conftest.$ac_ext >&5
10128   rm -rf conftest*
10129   glibcpp_cv_func_atan2l_use=no
10130 fi
10131 rm -f conftest*
10132       ac_ext=c
10133 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10134 ac_cpp='$CPP $CPPFLAGS'
10135 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10136 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10137 cross_compiling=$ac_cv_prog_cc_cross
10138
10139
10140 fi
10141
10142   fi
10143   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
10144   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
10145     for ac_func in atan2l
10146 do
10147 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10148 echo "configure:10149: checking for $ac_func" >&5
10149 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10150   echo $ac_n "(cached) $ac_c" 1>&6
10151 else
10152   cat > conftest.$ac_ext <<EOF
10153 #line 10154 "configure"
10154 #include "confdefs.h"
10155 /* System header to define __stub macros and hopefully few prototypes,
10156     which can conflict with char $ac_func(); below.  */
10157 #include <assert.h>
10158 /* Override any gcc2 internal prototype to avoid an error.  */
10159 /* We use char because int might match the return type of a gcc2
10160     builtin and then its argument prototype would still apply.  */
10161 char $ac_func();
10162
10163 int main() {
10164
10165 /* The GNU C library defines this for functions which it implements
10166     to always fail with ENOSYS.  Some functions are actually named
10167     something starting with __ and the normal name is an alias.  */
10168 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10169 choke me
10170 #else
10171 $ac_func();
10172 #endif
10173
10174 ; return 0; }
10175 EOF
10176 if { (eval echo configure:10177: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10177   rm -rf conftest*
10178   eval "ac_cv_func_$ac_func=yes"
10179 else
10180   echo "configure: failed program was:" >&5
10181   cat conftest.$ac_ext >&5
10182   rm -rf conftest*
10183   eval "ac_cv_func_$ac_func=no"
10184 fi
10185 rm -f conftest*
10186 fi
10187
10188 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10189   echo "$ac_t""yes" 1>&6
10190     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10191   cat >> confdefs.h <<EOF
10192 #define $ac_tr_func 1
10193 EOF
10194
10195 else
10196   echo "$ac_t""no" 1>&6
10197 fi
10198 done
10199
10200   fi
10201
10202
10203   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
10204 echo "configure:10205: checking for ceill declaration" >&5
10205   if test x${glibcpp_cv_func_ceill_use+set} != xset; then
10206     if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
10207   echo $ac_n "(cached) $ac_c" 1>&6
10208 else
10209
10210
10211       ac_ext=C
10212 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10213 ac_cpp='$CXXCPP $CPPFLAGS'
10214 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10215 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10216 cross_compiling=$ac_cv_prog_cxx_cross
10217
10218       cat > conftest.$ac_ext <<EOF
10219 #line 10220 "configure"
10220 #include "confdefs.h"
10221 #include <math.h>
10222 int main() {
10223  ceill(0);
10224 ; return 0; }
10225 EOF
10226 if { (eval echo configure:10227: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10227   rm -rf conftest*
10228   glibcpp_cv_func_ceill_use=yes
10229 else
10230   echo "configure: failed program was:" >&5
10231   cat conftest.$ac_ext >&5
10232   rm -rf conftest*
10233   glibcpp_cv_func_ceill_use=no
10234 fi
10235 rm -f conftest*
10236       ac_ext=c
10237 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10238 ac_cpp='$CPP $CPPFLAGS'
10239 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10240 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10241 cross_compiling=$ac_cv_prog_cc_cross
10242
10243
10244 fi
10245
10246   fi
10247   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
10248   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
10249     for ac_func in ceill
10250 do
10251 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10252 echo "configure:10253: checking for $ac_func" >&5
10253 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10254   echo $ac_n "(cached) $ac_c" 1>&6
10255 else
10256   cat > conftest.$ac_ext <<EOF
10257 #line 10258 "configure"
10258 #include "confdefs.h"
10259 /* System header to define __stub macros and hopefully few prototypes,
10260     which can conflict with char $ac_func(); below.  */
10261 #include <assert.h>
10262 /* Override any gcc2 internal prototype to avoid an error.  */
10263 /* We use char because int might match the return type of a gcc2
10264     builtin and then its argument prototype would still apply.  */
10265 char $ac_func();
10266
10267 int main() {
10268
10269 /* The GNU C library defines this for functions which it implements
10270     to always fail with ENOSYS.  Some functions are actually named
10271     something starting with __ and the normal name is an alias.  */
10272 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10273 choke me
10274 #else
10275 $ac_func();
10276 #endif
10277
10278 ; return 0; }
10279 EOF
10280 if { (eval echo configure:10281: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10281   rm -rf conftest*
10282   eval "ac_cv_func_$ac_func=yes"
10283 else
10284   echo "configure: failed program was:" >&5
10285   cat conftest.$ac_ext >&5
10286   rm -rf conftest*
10287   eval "ac_cv_func_$ac_func=no"
10288 fi
10289 rm -f conftest*
10290 fi
10291
10292 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10293   echo "$ac_t""yes" 1>&6
10294     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10295   cat >> confdefs.h <<EOF
10296 #define $ac_tr_func 1
10297 EOF
10298
10299 else
10300   echo "$ac_t""no" 1>&6
10301 fi
10302 done
10303
10304   fi
10305
10306
10307   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
10308 echo "configure:10309: checking for cosl declaration" >&5
10309   if test x${glibcpp_cv_func_cosl_use+set} != xset; then
10310     if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_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  cosl(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_cosl_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_cosl_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   fi
10351   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
10352   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
10353     for ac_func in cosl
10354 do
10355 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10356 echo "configure:10357: checking for $ac_func" >&5
10357 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10358   echo $ac_n "(cached) $ac_c" 1>&6
10359 else
10360   cat > conftest.$ac_ext <<EOF
10361 #line 10362 "configure"
10362 #include "confdefs.h"
10363 /* System header to define __stub macros and hopefully few prototypes,
10364     which can conflict with char $ac_func(); below.  */
10365 #include <assert.h>
10366 /* Override any gcc2 internal prototype to avoid an error.  */
10367 /* We use char because int might match the return type of a gcc2
10368     builtin and then its argument prototype would still apply.  */
10369 char $ac_func();
10370
10371 int main() {
10372
10373 /* The GNU C library defines this for functions which it implements
10374     to always fail with ENOSYS.  Some functions are actually named
10375     something starting with __ and the normal name is an alias.  */
10376 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10377 choke me
10378 #else
10379 $ac_func();
10380 #endif
10381
10382 ; return 0; }
10383 EOF
10384 if { (eval echo configure:10385: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10385   rm -rf conftest*
10386   eval "ac_cv_func_$ac_func=yes"
10387 else
10388   echo "configure: failed program was:" >&5
10389   cat conftest.$ac_ext >&5
10390   rm -rf conftest*
10391   eval "ac_cv_func_$ac_func=no"
10392 fi
10393 rm -f conftest*
10394 fi
10395
10396 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10397   echo "$ac_t""yes" 1>&6
10398     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10399   cat >> confdefs.h <<EOF
10400 #define $ac_tr_func 1
10401 EOF
10402
10403 else
10404   echo "$ac_t""no" 1>&6
10405 fi
10406 done
10407
10408   fi
10409
10410
10411   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
10412 echo "configure:10413: checking for coshl declaration" >&5
10413   if test x${glibcpp_cv_func_coshl_use+set} != xset; then
10414     if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
10415   echo $ac_n "(cached) $ac_c" 1>&6
10416 else
10417
10418
10419       ac_ext=C
10420 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10421 ac_cpp='$CXXCPP $CPPFLAGS'
10422 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10423 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10424 cross_compiling=$ac_cv_prog_cxx_cross
10425
10426       cat > conftest.$ac_ext <<EOF
10427 #line 10428 "configure"
10428 #include "confdefs.h"
10429 #include <math.h>
10430 int main() {
10431  coshl(0);
10432 ; return 0; }
10433 EOF
10434 if { (eval echo configure:10435: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10435   rm -rf conftest*
10436   glibcpp_cv_func_coshl_use=yes
10437 else
10438   echo "configure: failed program was:" >&5
10439   cat conftest.$ac_ext >&5
10440   rm -rf conftest*
10441   glibcpp_cv_func_coshl_use=no
10442 fi
10443 rm -f conftest*
10444       ac_ext=c
10445 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10446 ac_cpp='$CPP $CPPFLAGS'
10447 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10448 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10449 cross_compiling=$ac_cv_prog_cc_cross
10450
10451
10452 fi
10453
10454   fi
10455   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
10456   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
10457     for ac_func in coshl
10458 do
10459 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10460 echo "configure:10461: checking for $ac_func" >&5
10461 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10462   echo $ac_n "(cached) $ac_c" 1>&6
10463 else
10464   cat > conftest.$ac_ext <<EOF
10465 #line 10466 "configure"
10466 #include "confdefs.h"
10467 /* System header to define __stub macros and hopefully few prototypes,
10468     which can conflict with char $ac_func(); below.  */
10469 #include <assert.h>
10470 /* Override any gcc2 internal prototype to avoid an error.  */
10471 /* We use char because int might match the return type of a gcc2
10472     builtin and then its argument prototype would still apply.  */
10473 char $ac_func();
10474
10475 int main() {
10476
10477 /* The GNU C library defines this for functions which it implements
10478     to always fail with ENOSYS.  Some functions are actually named
10479     something starting with __ and the normal name is an alias.  */
10480 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10481 choke me
10482 #else
10483 $ac_func();
10484 #endif
10485
10486 ; return 0; }
10487 EOF
10488 if { (eval echo configure:10489: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10489   rm -rf conftest*
10490   eval "ac_cv_func_$ac_func=yes"
10491 else
10492   echo "configure: failed program was:" >&5
10493   cat conftest.$ac_ext >&5
10494   rm -rf conftest*
10495   eval "ac_cv_func_$ac_func=no"
10496 fi
10497 rm -f conftest*
10498 fi
10499
10500 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10501   echo "$ac_t""yes" 1>&6
10502     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10503   cat >> confdefs.h <<EOF
10504 #define $ac_tr_func 1
10505 EOF
10506
10507 else
10508   echo "$ac_t""no" 1>&6
10509 fi
10510 done
10511
10512   fi
10513
10514
10515   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
10516 echo "configure:10517: checking for expl declaration" >&5
10517   if test x${glibcpp_cv_func_expl_use+set} != xset; then
10518     if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
10519   echo $ac_n "(cached) $ac_c" 1>&6
10520 else
10521
10522
10523       ac_ext=C
10524 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10525 ac_cpp='$CXXCPP $CPPFLAGS'
10526 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10527 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10528 cross_compiling=$ac_cv_prog_cxx_cross
10529
10530       cat > conftest.$ac_ext <<EOF
10531 #line 10532 "configure"
10532 #include "confdefs.h"
10533 #include <math.h>
10534 int main() {
10535  expl(0);
10536 ; return 0; }
10537 EOF
10538 if { (eval echo configure:10539: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10539   rm -rf conftest*
10540   glibcpp_cv_func_expl_use=yes
10541 else
10542   echo "configure: failed program was:" >&5
10543   cat conftest.$ac_ext >&5
10544   rm -rf conftest*
10545   glibcpp_cv_func_expl_use=no
10546 fi
10547 rm -f conftest*
10548       ac_ext=c
10549 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10550 ac_cpp='$CPP $CPPFLAGS'
10551 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10552 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10553 cross_compiling=$ac_cv_prog_cc_cross
10554
10555
10556 fi
10557
10558   fi
10559   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
10560   if test x$glibcpp_cv_func_expl_use = x"yes"; then
10561     for ac_func in expl
10562 do
10563 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10564 echo "configure:10565: checking for $ac_func" >&5
10565 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10566   echo $ac_n "(cached) $ac_c" 1>&6
10567 else
10568   cat > conftest.$ac_ext <<EOF
10569 #line 10570 "configure"
10570 #include "confdefs.h"
10571 /* System header to define __stub macros and hopefully few prototypes,
10572     which can conflict with char $ac_func(); below.  */
10573 #include <assert.h>
10574 /* Override any gcc2 internal prototype to avoid an error.  */
10575 /* We use char because int might match the return type of a gcc2
10576     builtin and then its argument prototype would still apply.  */
10577 char $ac_func();
10578
10579 int main() {
10580
10581 /* The GNU C library defines this for functions which it implements
10582     to always fail with ENOSYS.  Some functions are actually named
10583     something starting with __ and the normal name is an alias.  */
10584 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10585 choke me
10586 #else
10587 $ac_func();
10588 #endif
10589
10590 ; return 0; }
10591 EOF
10592 if { (eval echo configure:10593: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10593   rm -rf conftest*
10594   eval "ac_cv_func_$ac_func=yes"
10595 else
10596   echo "configure: failed program was:" >&5
10597   cat conftest.$ac_ext >&5
10598   rm -rf conftest*
10599   eval "ac_cv_func_$ac_func=no"
10600 fi
10601 rm -f conftest*
10602 fi
10603
10604 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10605   echo "$ac_t""yes" 1>&6
10606     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10607   cat >> confdefs.h <<EOF
10608 #define $ac_tr_func 1
10609 EOF
10610
10611 else
10612   echo "$ac_t""no" 1>&6
10613 fi
10614 done
10615
10616   fi
10617
10618
10619   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
10620 echo "configure:10621: checking for fabsl declaration" >&5
10621   if test x${glibcpp_cv_func_fabsl_use+set} != xset; then
10622     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
10623   echo $ac_n "(cached) $ac_c" 1>&6
10624 else
10625
10626
10627       ac_ext=C
10628 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10629 ac_cpp='$CXXCPP $CPPFLAGS'
10630 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10631 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10632 cross_compiling=$ac_cv_prog_cxx_cross
10633
10634       cat > conftest.$ac_ext <<EOF
10635 #line 10636 "configure"
10636 #include "confdefs.h"
10637 #include <math.h>
10638 int main() {
10639  fabsl(0);
10640 ; return 0; }
10641 EOF
10642 if { (eval echo configure:10643: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10643   rm -rf conftest*
10644   glibcpp_cv_func_fabsl_use=yes
10645 else
10646   echo "configure: failed program was:" >&5
10647   cat conftest.$ac_ext >&5
10648   rm -rf conftest*
10649   glibcpp_cv_func_fabsl_use=no
10650 fi
10651 rm -f conftest*
10652       ac_ext=c
10653 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10654 ac_cpp='$CPP $CPPFLAGS'
10655 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10656 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10657 cross_compiling=$ac_cv_prog_cc_cross
10658
10659
10660 fi
10661
10662   fi
10663   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
10664   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
10665     for ac_func in fabsl
10666 do
10667 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10668 echo "configure:10669: checking for $ac_func" >&5
10669 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10670   echo $ac_n "(cached) $ac_c" 1>&6
10671 else
10672   cat > conftest.$ac_ext <<EOF
10673 #line 10674 "configure"
10674 #include "confdefs.h"
10675 /* System header to define __stub macros and hopefully few prototypes,
10676     which can conflict with char $ac_func(); below.  */
10677 #include <assert.h>
10678 /* Override any gcc2 internal prototype to avoid an error.  */
10679 /* We use char because int might match the return type of a gcc2
10680     builtin and then its argument prototype would still apply.  */
10681 char $ac_func();
10682
10683 int main() {
10684
10685 /* The GNU C library defines this for functions which it implements
10686     to always fail with ENOSYS.  Some functions are actually named
10687     something starting with __ and the normal name is an alias.  */
10688 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10689 choke me
10690 #else
10691 $ac_func();
10692 #endif
10693
10694 ; return 0; }
10695 EOF
10696 if { (eval echo configure:10697: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10697   rm -rf conftest*
10698   eval "ac_cv_func_$ac_func=yes"
10699 else
10700   echo "configure: failed program was:" >&5
10701   cat conftest.$ac_ext >&5
10702   rm -rf conftest*
10703   eval "ac_cv_func_$ac_func=no"
10704 fi
10705 rm -f conftest*
10706 fi
10707
10708 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10709   echo "$ac_t""yes" 1>&6
10710     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10711   cat >> confdefs.h <<EOF
10712 #define $ac_tr_func 1
10713 EOF
10714
10715 else
10716   echo "$ac_t""no" 1>&6
10717 fi
10718 done
10719
10720   fi
10721
10722
10723   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
10724 echo "configure:10725: checking for floorl declaration" >&5
10725   if test x${glibcpp_cv_func_floorl_use+set} != xset; then
10726     if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
10727   echo $ac_n "(cached) $ac_c" 1>&6
10728 else
10729
10730
10731       ac_ext=C
10732 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10733 ac_cpp='$CXXCPP $CPPFLAGS'
10734 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10735 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10736 cross_compiling=$ac_cv_prog_cxx_cross
10737
10738       cat > conftest.$ac_ext <<EOF
10739 #line 10740 "configure"
10740 #include "confdefs.h"
10741 #include <math.h>
10742 int main() {
10743  floorl(0);
10744 ; return 0; }
10745 EOF
10746 if { (eval echo configure:10747: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10747   rm -rf conftest*
10748   glibcpp_cv_func_floorl_use=yes
10749 else
10750   echo "configure: failed program was:" >&5
10751   cat conftest.$ac_ext >&5
10752   rm -rf conftest*
10753   glibcpp_cv_func_floorl_use=no
10754 fi
10755 rm -f conftest*
10756       ac_ext=c
10757 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10758 ac_cpp='$CPP $CPPFLAGS'
10759 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10760 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10761 cross_compiling=$ac_cv_prog_cc_cross
10762
10763
10764 fi
10765
10766   fi
10767   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
10768   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
10769     for ac_func in floorl
10770 do
10771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10772 echo "configure:10773: checking for $ac_func" >&5
10773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10774   echo $ac_n "(cached) $ac_c" 1>&6
10775 else
10776   cat > conftest.$ac_ext <<EOF
10777 #line 10778 "configure"
10778 #include "confdefs.h"
10779 /* System header to define __stub macros and hopefully few prototypes,
10780     which can conflict with char $ac_func(); below.  */
10781 #include <assert.h>
10782 /* Override any gcc2 internal prototype to avoid an error.  */
10783 /* We use char because int might match the return type of a gcc2
10784     builtin and then its argument prototype would still apply.  */
10785 char $ac_func();
10786
10787 int main() {
10788
10789 /* The GNU C library defines this for functions which it implements
10790     to always fail with ENOSYS.  Some functions are actually named
10791     something starting with __ and the normal name is an alias.  */
10792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10793 choke me
10794 #else
10795 $ac_func();
10796 #endif
10797
10798 ; return 0; }
10799 EOF
10800 if { (eval echo configure:10801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10801   rm -rf conftest*
10802   eval "ac_cv_func_$ac_func=yes"
10803 else
10804   echo "configure: failed program was:" >&5
10805   cat conftest.$ac_ext >&5
10806   rm -rf conftest*
10807   eval "ac_cv_func_$ac_func=no"
10808 fi
10809 rm -f conftest*
10810 fi
10811
10812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10813   echo "$ac_t""yes" 1>&6
10814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10815   cat >> confdefs.h <<EOF
10816 #define $ac_tr_func 1
10817 EOF
10818
10819 else
10820   echo "$ac_t""no" 1>&6
10821 fi
10822 done
10823
10824   fi
10825
10826
10827   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
10828 echo "configure:10829: checking for fmodl declaration" >&5
10829   if test x${glibcpp_cv_func_fmodl_use+set} != xset; then
10830     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
10831   echo $ac_n "(cached) $ac_c" 1>&6
10832 else
10833
10834
10835       ac_ext=C
10836 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10837 ac_cpp='$CXXCPP $CPPFLAGS'
10838 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10839 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10840 cross_compiling=$ac_cv_prog_cxx_cross
10841
10842       cat > conftest.$ac_ext <<EOF
10843 #line 10844 "configure"
10844 #include "confdefs.h"
10845 #include <math.h>
10846 int main() {
10847  fmodl(0, 0);
10848 ; return 0; }
10849 EOF
10850 if { (eval echo configure:10851: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10851   rm -rf conftest*
10852   glibcpp_cv_func_fmodl_use=yes
10853 else
10854   echo "configure: failed program was:" >&5
10855   cat conftest.$ac_ext >&5
10856   rm -rf conftest*
10857   glibcpp_cv_func_fmodl_use=no
10858 fi
10859 rm -f conftest*
10860       ac_ext=c
10861 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10862 ac_cpp='$CPP $CPPFLAGS'
10863 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10864 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10865 cross_compiling=$ac_cv_prog_cc_cross
10866
10867
10868 fi
10869
10870   fi
10871   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
10872   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
10873     for ac_func in fmodl
10874 do
10875 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10876 echo "configure:10877: checking for $ac_func" >&5
10877 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10878   echo $ac_n "(cached) $ac_c" 1>&6
10879 else
10880   cat > conftest.$ac_ext <<EOF
10881 #line 10882 "configure"
10882 #include "confdefs.h"
10883 /* System header to define __stub macros and hopefully few prototypes,
10884     which can conflict with char $ac_func(); below.  */
10885 #include <assert.h>
10886 /* Override any gcc2 internal prototype to avoid an error.  */
10887 /* We use char because int might match the return type of a gcc2
10888     builtin and then its argument prototype would still apply.  */
10889 char $ac_func();
10890
10891 int main() {
10892
10893 /* The GNU C library defines this for functions which it implements
10894     to always fail with ENOSYS.  Some functions are actually named
10895     something starting with __ and the normal name is an alias.  */
10896 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10897 choke me
10898 #else
10899 $ac_func();
10900 #endif
10901
10902 ; return 0; }
10903 EOF
10904 if { (eval echo configure:10905: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10905   rm -rf conftest*
10906   eval "ac_cv_func_$ac_func=yes"
10907 else
10908   echo "configure: failed program was:" >&5
10909   cat conftest.$ac_ext >&5
10910   rm -rf conftest*
10911   eval "ac_cv_func_$ac_func=no"
10912 fi
10913 rm -f conftest*
10914 fi
10915
10916 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10917   echo "$ac_t""yes" 1>&6
10918     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10919   cat >> confdefs.h <<EOF
10920 #define $ac_tr_func 1
10921 EOF
10922
10923 else
10924   echo "$ac_t""no" 1>&6
10925 fi
10926 done
10927
10928   fi
10929
10930
10931   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
10932 echo "configure:10933: checking for frexpl declaration" >&5
10933   if test x${glibcpp_cv_func_frexpl_use+set} != xset; then
10934     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
10935   echo $ac_n "(cached) $ac_c" 1>&6
10936 else
10937
10938
10939       ac_ext=C
10940 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10941 ac_cpp='$CXXCPP $CPPFLAGS'
10942 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10943 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10944 cross_compiling=$ac_cv_prog_cxx_cross
10945
10946       cat > conftest.$ac_ext <<EOF
10947 #line 10948 "configure"
10948 #include "confdefs.h"
10949 #include <math.h>
10950 int main() {
10951  frexpl(0, 0);
10952 ; return 0; }
10953 EOF
10954 if { (eval echo configure:10955: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10955   rm -rf conftest*
10956   glibcpp_cv_func_frexpl_use=yes
10957 else
10958   echo "configure: failed program was:" >&5
10959   cat conftest.$ac_ext >&5
10960   rm -rf conftest*
10961   glibcpp_cv_func_frexpl_use=no
10962 fi
10963 rm -f conftest*
10964       ac_ext=c
10965 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10966 ac_cpp='$CPP $CPPFLAGS'
10967 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10968 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10969 cross_compiling=$ac_cv_prog_cc_cross
10970
10971
10972 fi
10973
10974   fi
10975   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
10976   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
10977     for ac_func in frexpl
10978 do
10979 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10980 echo "configure:10981: checking for $ac_func" >&5
10981 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10982   echo $ac_n "(cached) $ac_c" 1>&6
10983 else
10984   cat > conftest.$ac_ext <<EOF
10985 #line 10986 "configure"
10986 #include "confdefs.h"
10987 /* System header to define __stub macros and hopefully few prototypes,
10988     which can conflict with char $ac_func(); below.  */
10989 #include <assert.h>
10990 /* Override any gcc2 internal prototype to avoid an error.  */
10991 /* We use char because int might match the return type of a gcc2
10992     builtin and then its argument prototype would still apply.  */
10993 char $ac_func();
10994
10995 int main() {
10996
10997 /* The GNU C library defines this for functions which it implements
10998     to always fail with ENOSYS.  Some functions are actually named
10999     something starting with __ and the normal name is an alias.  */
11000 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11001 choke me
11002 #else
11003 $ac_func();
11004 #endif
11005
11006 ; return 0; }
11007 EOF
11008 if { (eval echo configure:11009: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11009   rm -rf conftest*
11010   eval "ac_cv_func_$ac_func=yes"
11011 else
11012   echo "configure: failed program was:" >&5
11013   cat conftest.$ac_ext >&5
11014   rm -rf conftest*
11015   eval "ac_cv_func_$ac_func=no"
11016 fi
11017 rm -f conftest*
11018 fi
11019
11020 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11021   echo "$ac_t""yes" 1>&6
11022     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11023   cat >> confdefs.h <<EOF
11024 #define $ac_tr_func 1
11025 EOF
11026
11027 else
11028   echo "$ac_t""no" 1>&6
11029 fi
11030 done
11031
11032   fi
11033
11034
11035   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
11036 echo "configure:11037: checking for ldexpl declaration" >&5
11037   if test x${glibcpp_cv_func_ldexpl_use+set} != xset; then
11038     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
11039   echo $ac_n "(cached) $ac_c" 1>&6
11040 else
11041
11042
11043       ac_ext=C
11044 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11045 ac_cpp='$CXXCPP $CPPFLAGS'
11046 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11047 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11048 cross_compiling=$ac_cv_prog_cxx_cross
11049
11050       cat > conftest.$ac_ext <<EOF
11051 #line 11052 "configure"
11052 #include "confdefs.h"
11053 #include <math.h>
11054 int main() {
11055  ldexpl(0, 0);
11056 ; return 0; }
11057 EOF
11058 if { (eval echo configure:11059: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11059   rm -rf conftest*
11060   glibcpp_cv_func_ldexpl_use=yes
11061 else
11062   echo "configure: failed program was:" >&5
11063   cat conftest.$ac_ext >&5
11064   rm -rf conftest*
11065   glibcpp_cv_func_ldexpl_use=no
11066 fi
11067 rm -f conftest*
11068       ac_ext=c
11069 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11070 ac_cpp='$CPP $CPPFLAGS'
11071 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11072 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11073 cross_compiling=$ac_cv_prog_cc_cross
11074
11075
11076 fi
11077
11078   fi
11079   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
11080   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
11081     for ac_func in ldexpl
11082 do
11083 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11084 echo "configure:11085: checking for $ac_func" >&5
11085 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11086   echo $ac_n "(cached) $ac_c" 1>&6
11087 else
11088   cat > conftest.$ac_ext <<EOF
11089 #line 11090 "configure"
11090 #include "confdefs.h"
11091 /* System header to define __stub macros and hopefully few prototypes,
11092     which can conflict with char $ac_func(); below.  */
11093 #include <assert.h>
11094 /* Override any gcc2 internal prototype to avoid an error.  */
11095 /* We use char because int might match the return type of a gcc2
11096     builtin and then its argument prototype would still apply.  */
11097 char $ac_func();
11098
11099 int main() {
11100
11101 /* The GNU C library defines this for functions which it implements
11102     to always fail with ENOSYS.  Some functions are actually named
11103     something starting with __ and the normal name is an alias.  */
11104 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11105 choke me
11106 #else
11107 $ac_func();
11108 #endif
11109
11110 ; return 0; }
11111 EOF
11112 if { (eval echo configure:11113: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11113   rm -rf conftest*
11114   eval "ac_cv_func_$ac_func=yes"
11115 else
11116   echo "configure: failed program was:" >&5
11117   cat conftest.$ac_ext >&5
11118   rm -rf conftest*
11119   eval "ac_cv_func_$ac_func=no"
11120 fi
11121 rm -f conftest*
11122 fi
11123
11124 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11125   echo "$ac_t""yes" 1>&6
11126     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11127   cat >> confdefs.h <<EOF
11128 #define $ac_tr_func 1
11129 EOF
11130
11131 else
11132   echo "$ac_t""no" 1>&6
11133 fi
11134 done
11135
11136   fi
11137
11138
11139   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
11140 echo "configure:11141: checking for logl declaration" >&5
11141   if test x${glibcpp_cv_func_logl_use+set} != xset; then
11142     if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
11143   echo $ac_n "(cached) $ac_c" 1>&6
11144 else
11145
11146
11147       ac_ext=C
11148 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11149 ac_cpp='$CXXCPP $CPPFLAGS'
11150 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11151 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11152 cross_compiling=$ac_cv_prog_cxx_cross
11153
11154       cat > conftest.$ac_ext <<EOF
11155 #line 11156 "configure"
11156 #include "confdefs.h"
11157 #include <math.h>
11158 int main() {
11159  logl(0);
11160 ; return 0; }
11161 EOF
11162 if { (eval echo configure:11163: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11163   rm -rf conftest*
11164   glibcpp_cv_func_logl_use=yes
11165 else
11166   echo "configure: failed program was:" >&5
11167   cat conftest.$ac_ext >&5
11168   rm -rf conftest*
11169   glibcpp_cv_func_logl_use=no
11170 fi
11171 rm -f conftest*
11172       ac_ext=c
11173 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11174 ac_cpp='$CPP $CPPFLAGS'
11175 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11176 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11177 cross_compiling=$ac_cv_prog_cc_cross
11178
11179
11180 fi
11181
11182   fi
11183   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
11184   if test x$glibcpp_cv_func_logl_use = x"yes"; then
11185     for ac_func in logl
11186 do
11187 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11188 echo "configure:11189: checking for $ac_func" >&5
11189 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11190   echo $ac_n "(cached) $ac_c" 1>&6
11191 else
11192   cat > conftest.$ac_ext <<EOF
11193 #line 11194 "configure"
11194 #include "confdefs.h"
11195 /* System header to define __stub macros and hopefully few prototypes,
11196     which can conflict with char $ac_func(); below.  */
11197 #include <assert.h>
11198 /* Override any gcc2 internal prototype to avoid an error.  */
11199 /* We use char because int might match the return type of a gcc2
11200     builtin and then its argument prototype would still apply.  */
11201 char $ac_func();
11202
11203 int main() {
11204
11205 /* The GNU C library defines this for functions which it implements
11206     to always fail with ENOSYS.  Some functions are actually named
11207     something starting with __ and the normal name is an alias.  */
11208 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11209 choke me
11210 #else
11211 $ac_func();
11212 #endif
11213
11214 ; return 0; }
11215 EOF
11216 if { (eval echo configure:11217: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11217   rm -rf conftest*
11218   eval "ac_cv_func_$ac_func=yes"
11219 else
11220   echo "configure: failed program was:" >&5
11221   cat conftest.$ac_ext >&5
11222   rm -rf conftest*
11223   eval "ac_cv_func_$ac_func=no"
11224 fi
11225 rm -f conftest*
11226 fi
11227
11228 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11229   echo "$ac_t""yes" 1>&6
11230     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11231   cat >> confdefs.h <<EOF
11232 #define $ac_tr_func 1
11233 EOF
11234
11235 else
11236   echo "$ac_t""no" 1>&6
11237 fi
11238 done
11239
11240   fi
11241
11242
11243   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
11244 echo "configure:11245: checking for log10l declaration" >&5
11245   if test x${glibcpp_cv_func_log10l_use+set} != xset; then
11246     if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
11247   echo $ac_n "(cached) $ac_c" 1>&6
11248 else
11249
11250
11251       ac_ext=C
11252 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11253 ac_cpp='$CXXCPP $CPPFLAGS'
11254 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11255 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11256 cross_compiling=$ac_cv_prog_cxx_cross
11257
11258       cat > conftest.$ac_ext <<EOF
11259 #line 11260 "configure"
11260 #include "confdefs.h"
11261 #include <math.h>
11262 int main() {
11263  log10l(0);
11264 ; return 0; }
11265 EOF
11266 if { (eval echo configure:11267: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11267   rm -rf conftest*
11268   glibcpp_cv_func_log10l_use=yes
11269 else
11270   echo "configure: failed program was:" >&5
11271   cat conftest.$ac_ext >&5
11272   rm -rf conftest*
11273   glibcpp_cv_func_log10l_use=no
11274 fi
11275 rm -f conftest*
11276       ac_ext=c
11277 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11278 ac_cpp='$CPP $CPPFLAGS'
11279 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11280 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11281 cross_compiling=$ac_cv_prog_cc_cross
11282
11283
11284 fi
11285
11286   fi
11287   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
11288   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
11289     for ac_func in log10l
11290 do
11291 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11292 echo "configure:11293: checking for $ac_func" >&5
11293 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11294   echo $ac_n "(cached) $ac_c" 1>&6
11295 else
11296   cat > conftest.$ac_ext <<EOF
11297 #line 11298 "configure"
11298 #include "confdefs.h"
11299 /* System header to define __stub macros and hopefully few prototypes,
11300     which can conflict with char $ac_func(); below.  */
11301 #include <assert.h>
11302 /* Override any gcc2 internal prototype to avoid an error.  */
11303 /* We use char because int might match the return type of a gcc2
11304     builtin and then its argument prototype would still apply.  */
11305 char $ac_func();
11306
11307 int main() {
11308
11309 /* The GNU C library defines this for functions which it implements
11310     to always fail with ENOSYS.  Some functions are actually named
11311     something starting with __ and the normal name is an alias.  */
11312 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11313 choke me
11314 #else
11315 $ac_func();
11316 #endif
11317
11318 ; return 0; }
11319 EOF
11320 if { (eval echo configure:11321: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11321   rm -rf conftest*
11322   eval "ac_cv_func_$ac_func=yes"
11323 else
11324   echo "configure: failed program was:" >&5
11325   cat conftest.$ac_ext >&5
11326   rm -rf conftest*
11327   eval "ac_cv_func_$ac_func=no"
11328 fi
11329 rm -f conftest*
11330 fi
11331
11332 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11333   echo "$ac_t""yes" 1>&6
11334     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11335   cat >> confdefs.h <<EOF
11336 #define $ac_tr_func 1
11337 EOF
11338
11339 else
11340   echo "$ac_t""no" 1>&6
11341 fi
11342 done
11343
11344   fi
11345
11346
11347   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
11348 echo "configure:11349: checking for modfl declaration" >&5
11349   if test x${glibcpp_cv_func_modfl_use+set} != xset; then
11350     if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
11351   echo $ac_n "(cached) $ac_c" 1>&6
11352 else
11353
11354
11355       ac_ext=C
11356 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11357 ac_cpp='$CXXCPP $CPPFLAGS'
11358 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11359 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11360 cross_compiling=$ac_cv_prog_cxx_cross
11361
11362       cat > conftest.$ac_ext <<EOF
11363 #line 11364 "configure"
11364 #include "confdefs.h"
11365 #include <math.h>
11366 int main() {
11367  modfl(0, 0);
11368 ; return 0; }
11369 EOF
11370 if { (eval echo configure:11371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11371   rm -rf conftest*
11372   glibcpp_cv_func_modfl_use=yes
11373 else
11374   echo "configure: failed program was:" >&5
11375   cat conftest.$ac_ext >&5
11376   rm -rf conftest*
11377   glibcpp_cv_func_modfl_use=no
11378 fi
11379 rm -f conftest*
11380       ac_ext=c
11381 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11382 ac_cpp='$CPP $CPPFLAGS'
11383 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11384 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11385 cross_compiling=$ac_cv_prog_cc_cross
11386
11387
11388 fi
11389
11390   fi
11391   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
11392   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
11393     for ac_func in modfl
11394 do
11395 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11396 echo "configure:11397: checking for $ac_func" >&5
11397 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11398   echo $ac_n "(cached) $ac_c" 1>&6
11399 else
11400   cat > conftest.$ac_ext <<EOF
11401 #line 11402 "configure"
11402 #include "confdefs.h"
11403 /* System header to define __stub macros and hopefully few prototypes,
11404     which can conflict with char $ac_func(); below.  */
11405 #include <assert.h>
11406 /* Override any gcc2 internal prototype to avoid an error.  */
11407 /* We use char because int might match the return type of a gcc2
11408     builtin and then its argument prototype would still apply.  */
11409 char $ac_func();
11410
11411 int main() {
11412
11413 /* The GNU C library defines this for functions which it implements
11414     to always fail with ENOSYS.  Some functions are actually named
11415     something starting with __ and the normal name is an alias.  */
11416 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11417 choke me
11418 #else
11419 $ac_func();
11420 #endif
11421
11422 ; return 0; }
11423 EOF
11424 if { (eval echo configure:11425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11425   rm -rf conftest*
11426   eval "ac_cv_func_$ac_func=yes"
11427 else
11428   echo "configure: failed program was:" >&5
11429   cat conftest.$ac_ext >&5
11430   rm -rf conftest*
11431   eval "ac_cv_func_$ac_func=no"
11432 fi
11433 rm -f conftest*
11434 fi
11435
11436 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11437   echo "$ac_t""yes" 1>&6
11438     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11439   cat >> confdefs.h <<EOF
11440 #define $ac_tr_func 1
11441 EOF
11442
11443 else
11444   echo "$ac_t""no" 1>&6
11445 fi
11446 done
11447
11448   fi
11449
11450
11451   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
11452 echo "configure:11453: checking for powl declaration" >&5
11453   if test x${glibcpp_cv_func_powl_use+set} != xset; then
11454     if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
11455   echo $ac_n "(cached) $ac_c" 1>&6
11456 else
11457
11458
11459       ac_ext=C
11460 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11461 ac_cpp='$CXXCPP $CPPFLAGS'
11462 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11463 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11464 cross_compiling=$ac_cv_prog_cxx_cross
11465
11466       cat > conftest.$ac_ext <<EOF
11467 #line 11468 "configure"
11468 #include "confdefs.h"
11469 #include <math.h>
11470 int main() {
11471  powl(0, 0);
11472 ; return 0; }
11473 EOF
11474 if { (eval echo configure:11475: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11475   rm -rf conftest*
11476   glibcpp_cv_func_powl_use=yes
11477 else
11478   echo "configure: failed program was:" >&5
11479   cat conftest.$ac_ext >&5
11480   rm -rf conftest*
11481   glibcpp_cv_func_powl_use=no
11482 fi
11483 rm -f conftest*
11484       ac_ext=c
11485 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11486 ac_cpp='$CPP $CPPFLAGS'
11487 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11488 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11489 cross_compiling=$ac_cv_prog_cc_cross
11490
11491
11492 fi
11493
11494   fi
11495   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
11496   if test x$glibcpp_cv_func_powl_use = x"yes"; then
11497     for ac_func in powl
11498 do
11499 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11500 echo "configure:11501: checking for $ac_func" >&5
11501 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11502   echo $ac_n "(cached) $ac_c" 1>&6
11503 else
11504   cat > conftest.$ac_ext <<EOF
11505 #line 11506 "configure"
11506 #include "confdefs.h"
11507 /* System header to define __stub macros and hopefully few prototypes,
11508     which can conflict with char $ac_func(); below.  */
11509 #include <assert.h>
11510 /* Override any gcc2 internal prototype to avoid an error.  */
11511 /* We use char because int might match the return type of a gcc2
11512     builtin and then its argument prototype would still apply.  */
11513 char $ac_func();
11514
11515 int main() {
11516
11517 /* The GNU C library defines this for functions which it implements
11518     to always fail with ENOSYS.  Some functions are actually named
11519     something starting with __ and the normal name is an alias.  */
11520 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11521 choke me
11522 #else
11523 $ac_func();
11524 #endif
11525
11526 ; return 0; }
11527 EOF
11528 if { (eval echo configure:11529: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11529   rm -rf conftest*
11530   eval "ac_cv_func_$ac_func=yes"
11531 else
11532   echo "configure: failed program was:" >&5
11533   cat conftest.$ac_ext >&5
11534   rm -rf conftest*
11535   eval "ac_cv_func_$ac_func=no"
11536 fi
11537 rm -f conftest*
11538 fi
11539
11540 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11541   echo "$ac_t""yes" 1>&6
11542     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11543   cat >> confdefs.h <<EOF
11544 #define $ac_tr_func 1
11545 EOF
11546
11547 else
11548   echo "$ac_t""no" 1>&6
11549 fi
11550 done
11551
11552   fi
11553
11554
11555   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
11556 echo "configure:11557: checking for sinl declaration" >&5
11557   if test x${glibcpp_cv_func_sinl_use+set} != xset; then
11558     if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
11559   echo $ac_n "(cached) $ac_c" 1>&6
11560 else
11561
11562
11563       ac_ext=C
11564 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11565 ac_cpp='$CXXCPP $CPPFLAGS'
11566 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11567 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11568 cross_compiling=$ac_cv_prog_cxx_cross
11569
11570       cat > conftest.$ac_ext <<EOF
11571 #line 11572 "configure"
11572 #include "confdefs.h"
11573 #include <math.h>
11574 int main() {
11575  sinl(0);
11576 ; return 0; }
11577 EOF
11578 if { (eval echo configure:11579: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11579   rm -rf conftest*
11580   glibcpp_cv_func_sinl_use=yes
11581 else
11582   echo "configure: failed program was:" >&5
11583   cat conftest.$ac_ext >&5
11584   rm -rf conftest*
11585   glibcpp_cv_func_sinl_use=no
11586 fi
11587 rm -f conftest*
11588       ac_ext=c
11589 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11590 ac_cpp='$CPP $CPPFLAGS'
11591 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11592 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11593 cross_compiling=$ac_cv_prog_cc_cross
11594
11595
11596 fi
11597
11598   fi
11599   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
11600   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
11601     for ac_func in sinl
11602 do
11603 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11604 echo "configure:11605: checking for $ac_func" >&5
11605 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11606   echo $ac_n "(cached) $ac_c" 1>&6
11607 else
11608   cat > conftest.$ac_ext <<EOF
11609 #line 11610 "configure"
11610 #include "confdefs.h"
11611 /* System header to define __stub macros and hopefully few prototypes,
11612     which can conflict with char $ac_func(); below.  */
11613 #include <assert.h>
11614 /* Override any gcc2 internal prototype to avoid an error.  */
11615 /* We use char because int might match the return type of a gcc2
11616     builtin and then its argument prototype would still apply.  */
11617 char $ac_func();
11618
11619 int main() {
11620
11621 /* The GNU C library defines this for functions which it implements
11622     to always fail with ENOSYS.  Some functions are actually named
11623     something starting with __ and the normal name is an alias.  */
11624 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11625 choke me
11626 #else
11627 $ac_func();
11628 #endif
11629
11630 ; return 0; }
11631 EOF
11632 if { (eval echo configure:11633: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11633   rm -rf conftest*
11634   eval "ac_cv_func_$ac_func=yes"
11635 else
11636   echo "configure: failed program was:" >&5
11637   cat conftest.$ac_ext >&5
11638   rm -rf conftest*
11639   eval "ac_cv_func_$ac_func=no"
11640 fi
11641 rm -f conftest*
11642 fi
11643
11644 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11645   echo "$ac_t""yes" 1>&6
11646     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11647   cat >> confdefs.h <<EOF
11648 #define $ac_tr_func 1
11649 EOF
11650
11651 else
11652   echo "$ac_t""no" 1>&6
11653 fi
11654 done
11655
11656   fi
11657
11658
11659   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
11660 echo "configure:11661: checking for sinhl declaration" >&5
11661   if test x${glibcpp_cv_func_sinhl_use+set} != xset; then
11662     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
11663   echo $ac_n "(cached) $ac_c" 1>&6
11664 else
11665
11666
11667       ac_ext=C
11668 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11669 ac_cpp='$CXXCPP $CPPFLAGS'
11670 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11671 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11672 cross_compiling=$ac_cv_prog_cxx_cross
11673
11674       cat > conftest.$ac_ext <<EOF
11675 #line 11676 "configure"
11676 #include "confdefs.h"
11677 #include <math.h>
11678 int main() {
11679  sinhl(0);
11680 ; return 0; }
11681 EOF
11682 if { (eval echo configure:11683: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11683   rm -rf conftest*
11684   glibcpp_cv_func_sinhl_use=yes
11685 else
11686   echo "configure: failed program was:" >&5
11687   cat conftest.$ac_ext >&5
11688   rm -rf conftest*
11689   glibcpp_cv_func_sinhl_use=no
11690 fi
11691 rm -f conftest*
11692       ac_ext=c
11693 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11694 ac_cpp='$CPP $CPPFLAGS'
11695 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11696 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11697 cross_compiling=$ac_cv_prog_cc_cross
11698
11699
11700 fi
11701
11702   fi
11703   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
11704   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
11705     for ac_func in sinhl
11706 do
11707 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11708 echo "configure:11709: checking for $ac_func" >&5
11709 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11710   echo $ac_n "(cached) $ac_c" 1>&6
11711 else
11712   cat > conftest.$ac_ext <<EOF
11713 #line 11714 "configure"
11714 #include "confdefs.h"
11715 /* System header to define __stub macros and hopefully few prototypes,
11716     which can conflict with char $ac_func(); below.  */
11717 #include <assert.h>
11718 /* Override any gcc2 internal prototype to avoid an error.  */
11719 /* We use char because int might match the return type of a gcc2
11720     builtin and then its argument prototype would still apply.  */
11721 char $ac_func();
11722
11723 int main() {
11724
11725 /* The GNU C library defines this for functions which it implements
11726     to always fail with ENOSYS.  Some functions are actually named
11727     something starting with __ and the normal name is an alias.  */
11728 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11729 choke me
11730 #else
11731 $ac_func();
11732 #endif
11733
11734 ; return 0; }
11735 EOF
11736 if { (eval echo configure:11737: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11737   rm -rf conftest*
11738   eval "ac_cv_func_$ac_func=yes"
11739 else
11740   echo "configure: failed program was:" >&5
11741   cat conftest.$ac_ext >&5
11742   rm -rf conftest*
11743   eval "ac_cv_func_$ac_func=no"
11744 fi
11745 rm -f conftest*
11746 fi
11747
11748 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11749   echo "$ac_t""yes" 1>&6
11750     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11751   cat >> confdefs.h <<EOF
11752 #define $ac_tr_func 1
11753 EOF
11754
11755 else
11756   echo "$ac_t""no" 1>&6
11757 fi
11758 done
11759
11760   fi
11761
11762
11763   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
11764 echo "configure:11765: checking for sqrtl declaration" >&5
11765   if test x${glibcpp_cv_func_sqrtl_use+set} != xset; then
11766     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
11767   echo $ac_n "(cached) $ac_c" 1>&6
11768 else
11769
11770
11771       ac_ext=C
11772 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11773 ac_cpp='$CXXCPP $CPPFLAGS'
11774 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11775 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11776 cross_compiling=$ac_cv_prog_cxx_cross
11777
11778       cat > conftest.$ac_ext <<EOF
11779 #line 11780 "configure"
11780 #include "confdefs.h"
11781 #include <math.h>
11782 int main() {
11783  sqrtl(0);
11784 ; return 0; }
11785 EOF
11786 if { (eval echo configure:11787: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11787   rm -rf conftest*
11788   glibcpp_cv_func_sqrtl_use=yes
11789 else
11790   echo "configure: failed program was:" >&5
11791   cat conftest.$ac_ext >&5
11792   rm -rf conftest*
11793   glibcpp_cv_func_sqrtl_use=no
11794 fi
11795 rm -f conftest*
11796       ac_ext=c
11797 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11798 ac_cpp='$CPP $CPPFLAGS'
11799 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11800 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11801 cross_compiling=$ac_cv_prog_cc_cross
11802
11803
11804 fi
11805
11806   fi
11807   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
11808   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
11809     for ac_func in sqrtl
11810 do
11811 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11812 echo "configure:11813: checking for $ac_func" >&5
11813 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11814   echo $ac_n "(cached) $ac_c" 1>&6
11815 else
11816   cat > conftest.$ac_ext <<EOF
11817 #line 11818 "configure"
11818 #include "confdefs.h"
11819 /* System header to define __stub macros and hopefully few prototypes,
11820     which can conflict with char $ac_func(); below.  */
11821 #include <assert.h>
11822 /* Override any gcc2 internal prototype to avoid an error.  */
11823 /* We use char because int might match the return type of a gcc2
11824     builtin and then its argument prototype would still apply.  */
11825 char $ac_func();
11826
11827 int main() {
11828
11829 /* The GNU C library defines this for functions which it implements
11830     to always fail with ENOSYS.  Some functions are actually named
11831     something starting with __ and the normal name is an alias.  */
11832 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11833 choke me
11834 #else
11835 $ac_func();
11836 #endif
11837
11838 ; return 0; }
11839 EOF
11840 if { (eval echo configure:11841: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11841   rm -rf conftest*
11842   eval "ac_cv_func_$ac_func=yes"
11843 else
11844   echo "configure: failed program was:" >&5
11845   cat conftest.$ac_ext >&5
11846   rm -rf conftest*
11847   eval "ac_cv_func_$ac_func=no"
11848 fi
11849 rm -f conftest*
11850 fi
11851
11852 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11853   echo "$ac_t""yes" 1>&6
11854     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11855   cat >> confdefs.h <<EOF
11856 #define $ac_tr_func 1
11857 EOF
11858
11859 else
11860   echo "$ac_t""no" 1>&6
11861 fi
11862 done
11863
11864   fi
11865
11866
11867   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
11868 echo "configure:11869: checking for tanl declaration" >&5
11869   if test x${glibcpp_cv_func_tanl_use+set} != xset; then
11870     if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
11871   echo $ac_n "(cached) $ac_c" 1>&6
11872 else
11873
11874
11875       ac_ext=C
11876 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11877 ac_cpp='$CXXCPP $CPPFLAGS'
11878 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11879 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11880 cross_compiling=$ac_cv_prog_cxx_cross
11881
11882       cat > conftest.$ac_ext <<EOF
11883 #line 11884 "configure"
11884 #include "confdefs.h"
11885 #include <math.h>
11886 int main() {
11887  tanl(0);
11888 ; return 0; }
11889 EOF
11890 if { (eval echo configure:11891: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11891   rm -rf conftest*
11892   glibcpp_cv_func_tanl_use=yes
11893 else
11894   echo "configure: failed program was:" >&5
11895   cat conftest.$ac_ext >&5
11896   rm -rf conftest*
11897   glibcpp_cv_func_tanl_use=no
11898 fi
11899 rm -f conftest*
11900       ac_ext=c
11901 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11902 ac_cpp='$CPP $CPPFLAGS'
11903 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11904 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11905 cross_compiling=$ac_cv_prog_cc_cross
11906
11907
11908 fi
11909
11910   fi
11911   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
11912   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
11913     for ac_func in tanl
11914 do
11915 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11916 echo "configure:11917: checking for $ac_func" >&5
11917 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11918   echo $ac_n "(cached) $ac_c" 1>&6
11919 else
11920   cat > conftest.$ac_ext <<EOF
11921 #line 11922 "configure"
11922 #include "confdefs.h"
11923 /* System header to define __stub macros and hopefully few prototypes,
11924     which can conflict with char $ac_func(); below.  */
11925 #include <assert.h>
11926 /* Override any gcc2 internal prototype to avoid an error.  */
11927 /* We use char because int might match the return type of a gcc2
11928     builtin and then its argument prototype would still apply.  */
11929 char $ac_func();
11930
11931 int main() {
11932
11933 /* The GNU C library defines this for functions which it implements
11934     to always fail with ENOSYS.  Some functions are actually named
11935     something starting with __ and the normal name is an alias.  */
11936 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11937 choke me
11938 #else
11939 $ac_func();
11940 #endif
11941
11942 ; return 0; }
11943 EOF
11944 if { (eval echo configure:11945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11945   rm -rf conftest*
11946   eval "ac_cv_func_$ac_func=yes"
11947 else
11948   echo "configure: failed program was:" >&5
11949   cat conftest.$ac_ext >&5
11950   rm -rf conftest*
11951   eval "ac_cv_func_$ac_func=no"
11952 fi
11953 rm -f conftest*
11954 fi
11955
11956 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11957   echo "$ac_t""yes" 1>&6
11958     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11959   cat >> confdefs.h <<EOF
11960 #define $ac_tr_func 1
11961 EOF
11962
11963 else
11964   echo "$ac_t""no" 1>&6
11965 fi
11966 done
11967
11968   fi
11969
11970
11971   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
11972 echo "configure:11973: checking for tanhl declaration" >&5
11973   if test x${glibcpp_cv_func_tanhl_use+set} != xset; then
11974     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
11975   echo $ac_n "(cached) $ac_c" 1>&6
11976 else
11977
11978
11979       ac_ext=C
11980 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11981 ac_cpp='$CXXCPP $CPPFLAGS'
11982 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11983 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11984 cross_compiling=$ac_cv_prog_cxx_cross
11985
11986       cat > conftest.$ac_ext <<EOF
11987 #line 11988 "configure"
11988 #include "confdefs.h"
11989 #include <math.h>
11990 int main() {
11991  tanhl(0);
11992 ; return 0; }
11993 EOF
11994 if { (eval echo configure:11995: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11995   rm -rf conftest*
11996   glibcpp_cv_func_tanhl_use=yes
11997 else
11998   echo "configure: failed program was:" >&5
11999   cat conftest.$ac_ext >&5
12000   rm -rf conftest*
12001   glibcpp_cv_func_tanhl_use=no
12002 fi
12003 rm -f conftest*
12004       ac_ext=c
12005 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12006 ac_cpp='$CPP $CPPFLAGS'
12007 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12008 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12009 cross_compiling=$ac_cv_prog_cc_cross
12010
12011
12012 fi
12013
12014   fi
12015   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
12016   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
12017     for ac_func in tanhl
12018 do
12019 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12020 echo "configure:12021: checking for $ac_func" >&5
12021 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12022   echo $ac_n "(cached) $ac_c" 1>&6
12023 else
12024   cat > conftest.$ac_ext <<EOF
12025 #line 12026 "configure"
12026 #include "confdefs.h"
12027 /* System header to define __stub macros and hopefully few prototypes,
12028     which can conflict with char $ac_func(); below.  */
12029 #include <assert.h>
12030 /* Override any gcc2 internal prototype to avoid an error.  */
12031 /* We use char because int might match the return type of a gcc2
12032     builtin and then its argument prototype would still apply.  */
12033 char $ac_func();
12034
12035 int main() {
12036
12037 /* The GNU C library defines this for functions which it implements
12038     to always fail with ENOSYS.  Some functions are actually named
12039     something starting with __ and the normal name is an alias.  */
12040 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12041 choke me
12042 #else
12043 $ac_func();
12044 #endif
12045
12046 ; return 0; }
12047 EOF
12048 if { (eval echo configure:12049: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12049   rm -rf conftest*
12050   eval "ac_cv_func_$ac_func=yes"
12051 else
12052   echo "configure: failed program was:" >&5
12053   cat conftest.$ac_ext >&5
12054   rm -rf conftest*
12055   eval "ac_cv_func_$ac_func=no"
12056 fi
12057 rm -f conftest*
12058 fi
12059
12060 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12061   echo "$ac_t""yes" 1>&6
12062     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12063   cat >> confdefs.h <<EOF
12064 #define $ac_tr_func 1
12065 EOF
12066
12067 else
12068   echo "$ac_t""no" 1>&6
12069 fi
12070 done
12071
12072   fi
12073
12074
12075   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
12076 echo "configure:12077: checking for sincosl declaration" >&5
12077   if test x${glibcpp_cv_func_sincosl_use+set} != xset; then
12078     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
12079   echo $ac_n "(cached) $ac_c" 1>&6
12080 else
12081
12082
12083       ac_ext=C
12084 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12085 ac_cpp='$CXXCPP $CPPFLAGS'
12086 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12087 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12088 cross_compiling=$ac_cv_prog_cxx_cross
12089
12090       cat > conftest.$ac_ext <<EOF
12091 #line 12092 "configure"
12092 #include "confdefs.h"
12093 #include <math.h>
12094 int main() {
12095  sincosl(0, 0, 0);
12096 ; return 0; }
12097 EOF
12098 if { (eval echo configure:12099: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12099   rm -rf conftest*
12100   glibcpp_cv_func_sincosl_use=yes
12101 else
12102   echo "configure: failed program was:" >&5
12103   cat conftest.$ac_ext >&5
12104   rm -rf conftest*
12105   glibcpp_cv_func_sincosl_use=no
12106 fi
12107 rm -f conftest*
12108       ac_ext=c
12109 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12110 ac_cpp='$CPP $CPPFLAGS'
12111 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12112 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12113 cross_compiling=$ac_cv_prog_cc_cross
12114
12115
12116 fi
12117
12118   fi
12119   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
12120   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
12121     for ac_func in sincosl
12122 do
12123 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12124 echo "configure:12125: checking for $ac_func" >&5
12125 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12126   echo $ac_n "(cached) $ac_c" 1>&6
12127 else
12128   cat > conftest.$ac_ext <<EOF
12129 #line 12130 "configure"
12130 #include "confdefs.h"
12131 /* System header to define __stub macros and hopefully few prototypes,
12132     which can conflict with char $ac_func(); below.  */
12133 #include <assert.h>
12134 /* Override any gcc2 internal prototype to avoid an error.  */
12135 /* We use char because int might match the return type of a gcc2
12136     builtin and then its argument prototype would still apply.  */
12137 char $ac_func();
12138
12139 int main() {
12140
12141 /* The GNU C library defines this for functions which it implements
12142     to always fail with ENOSYS.  Some functions are actually named
12143     something starting with __ and the normal name is an alias.  */
12144 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12145 choke me
12146 #else
12147 $ac_func();
12148 #endif
12149
12150 ; return 0; }
12151 EOF
12152 if { (eval echo configure:12153: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12153   rm -rf conftest*
12154   eval "ac_cv_func_$ac_func=yes"
12155 else
12156   echo "configure: failed program was:" >&5
12157   cat conftest.$ac_ext >&5
12158   rm -rf conftest*
12159   eval "ac_cv_func_$ac_func=no"
12160 fi
12161 rm -f conftest*
12162 fi
12163
12164 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12165   echo "$ac_t""yes" 1>&6
12166     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12167   cat >> confdefs.h <<EOF
12168 #define $ac_tr_func 1
12169 EOF
12170
12171 else
12172   echo "$ac_t""no" 1>&6
12173 fi
12174 done
12175
12176   fi
12177
12178
12179   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
12180 echo "configure:12181: checking for finitel declaration" >&5
12181   if test x${glibcpp_cv_func_finitel_use+set} != xset; then
12182     if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
12183   echo $ac_n "(cached) $ac_c" 1>&6
12184 else
12185
12186
12187       ac_ext=C
12188 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12189 ac_cpp='$CXXCPP $CPPFLAGS'
12190 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12191 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12192 cross_compiling=$ac_cv_prog_cxx_cross
12193
12194       cat > conftest.$ac_ext <<EOF
12195 #line 12196 "configure"
12196 #include "confdefs.h"
12197 #include <math.h>
12198 int main() {
12199  finitel(0);
12200 ; return 0; }
12201 EOF
12202 if { (eval echo configure:12203: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12203   rm -rf conftest*
12204   glibcpp_cv_func_finitel_use=yes
12205 else
12206   echo "configure: failed program was:" >&5
12207   cat conftest.$ac_ext >&5
12208   rm -rf conftest*
12209   glibcpp_cv_func_finitel_use=no
12210 fi
12211 rm -f conftest*
12212       ac_ext=c
12213 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12214 ac_cpp='$CPP $CPPFLAGS'
12215 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12216 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12217 cross_compiling=$ac_cv_prog_cc_cross
12218
12219
12220 fi
12221
12222   fi
12223   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
12224   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
12225     for ac_func in finitel
12226 do
12227 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12228 echo "configure:12229: checking for $ac_func" >&5
12229 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12230   echo $ac_n "(cached) $ac_c" 1>&6
12231 else
12232   cat > conftest.$ac_ext <<EOF
12233 #line 12234 "configure"
12234 #include "confdefs.h"
12235 /* System header to define __stub macros and hopefully few prototypes,
12236     which can conflict with char $ac_func(); below.  */
12237 #include <assert.h>
12238 /* Override any gcc2 internal prototype to avoid an error.  */
12239 /* We use char because int might match the return type of a gcc2
12240     builtin and then its argument prototype would still apply.  */
12241 char $ac_func();
12242
12243 int main() {
12244
12245 /* The GNU C library defines this for functions which it implements
12246     to always fail with ENOSYS.  Some functions are actually named
12247     something starting with __ and the normal name is an alias.  */
12248 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12249 choke me
12250 #else
12251 $ac_func();
12252 #endif
12253
12254 ; return 0; }
12255 EOF
12256 if { (eval echo configure:12257: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12257   rm -rf conftest*
12258   eval "ac_cv_func_$ac_func=yes"
12259 else
12260   echo "configure: failed program was:" >&5
12261   cat conftest.$ac_ext >&5
12262   rm -rf conftest*
12263   eval "ac_cv_func_$ac_func=no"
12264 fi
12265 rm -f conftest*
12266 fi
12267
12268 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12269   echo "$ac_t""yes" 1>&6
12270     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12271   cat >> confdefs.h <<EOF
12272 #define $ac_tr_func 1
12273 EOF
12274
12275 else
12276   echo "$ac_t""no" 1>&6
12277 fi
12278 done
12279
12280   fi
12281
12282
12283
12284   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
12285 echo "configure:12286: checking for _isinf declaration" >&5
12286   if test x${glibcpp_cv_func__isinf_use+set} != xset; then
12287     if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
12288   echo $ac_n "(cached) $ac_c" 1>&6
12289 else
12290
12291
12292       ac_ext=C
12293 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12294 ac_cpp='$CXXCPP $CPPFLAGS'
12295 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12296 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12297 cross_compiling=$ac_cv_prog_cxx_cross
12298
12299       cat > conftest.$ac_ext <<EOF
12300 #line 12301 "configure"
12301 #include "confdefs.h"
12302 #include <math.h>
12303 int main() {
12304  _isinf(0);
12305 ; return 0; }
12306 EOF
12307 if { (eval echo configure:12308: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12308   rm -rf conftest*
12309   glibcpp_cv_func__isinf_use=yes
12310 else
12311   echo "configure: failed program was:" >&5
12312   cat conftest.$ac_ext >&5
12313   rm -rf conftest*
12314   glibcpp_cv_func__isinf_use=no
12315 fi
12316 rm -f conftest*
12317       ac_ext=c
12318 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12319 ac_cpp='$CPP $CPPFLAGS'
12320 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12321 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12322 cross_compiling=$ac_cv_prog_cc_cross
12323
12324
12325 fi
12326
12327   fi
12328   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
12329   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
12330     for ac_func in _isinf
12331 do
12332 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12333 echo "configure:12334: checking for $ac_func" >&5
12334 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12335   echo $ac_n "(cached) $ac_c" 1>&6
12336 else
12337   cat > conftest.$ac_ext <<EOF
12338 #line 12339 "configure"
12339 #include "confdefs.h"
12340 /* System header to define __stub macros and hopefully few prototypes,
12341     which can conflict with char $ac_func(); below.  */
12342 #include <assert.h>
12343 /* Override any gcc2 internal prototype to avoid an error.  */
12344 /* We use char because int might match the return type of a gcc2
12345     builtin and then its argument prototype would still apply.  */
12346 char $ac_func();
12347
12348 int main() {
12349
12350 /* The GNU C library defines this for functions which it implements
12351     to always fail with ENOSYS.  Some functions are actually named
12352     something starting with __ and the normal name is an alias.  */
12353 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12354 choke me
12355 #else
12356 $ac_func();
12357 #endif
12358
12359 ; return 0; }
12360 EOF
12361 if { (eval echo configure:12362: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12362   rm -rf conftest*
12363   eval "ac_cv_func_$ac_func=yes"
12364 else
12365   echo "configure: failed program was:" >&5
12366   cat conftest.$ac_ext >&5
12367   rm -rf conftest*
12368   eval "ac_cv_func_$ac_func=no"
12369 fi
12370 rm -f conftest*
12371 fi
12372
12373 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12374   echo "$ac_t""yes" 1>&6
12375     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12376   cat >> confdefs.h <<EOF
12377 #define $ac_tr_func 1
12378 EOF
12379
12380 else
12381   echo "$ac_t""no" 1>&6
12382 fi
12383 done
12384
12385   fi
12386
12387
12388   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
12389 echo "configure:12390: checking for _isnan declaration" >&5
12390   if test x${glibcpp_cv_func__isnan_use+set} != xset; then
12391     if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
12392   echo $ac_n "(cached) $ac_c" 1>&6
12393 else
12394
12395
12396       ac_ext=C
12397 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12398 ac_cpp='$CXXCPP $CPPFLAGS'
12399 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12400 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12401 cross_compiling=$ac_cv_prog_cxx_cross
12402
12403       cat > conftest.$ac_ext <<EOF
12404 #line 12405 "configure"
12405 #include "confdefs.h"
12406 #include <math.h>
12407 int main() {
12408  _isnan(0);
12409 ; return 0; }
12410 EOF
12411 if { (eval echo configure:12412: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12412   rm -rf conftest*
12413   glibcpp_cv_func__isnan_use=yes
12414 else
12415   echo "configure: failed program was:" >&5
12416   cat conftest.$ac_ext >&5
12417   rm -rf conftest*
12418   glibcpp_cv_func__isnan_use=no
12419 fi
12420 rm -f conftest*
12421       ac_ext=c
12422 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12423 ac_cpp='$CPP $CPPFLAGS'
12424 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12425 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12426 cross_compiling=$ac_cv_prog_cc_cross
12427
12428
12429 fi
12430
12431   fi
12432   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
12433   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
12434     for ac_func in _isnan
12435 do
12436 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12437 echo "configure:12438: checking for $ac_func" >&5
12438 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12439   echo $ac_n "(cached) $ac_c" 1>&6
12440 else
12441   cat > conftest.$ac_ext <<EOF
12442 #line 12443 "configure"
12443 #include "confdefs.h"
12444 /* System header to define __stub macros and hopefully few prototypes,
12445     which can conflict with char $ac_func(); below.  */
12446 #include <assert.h>
12447 /* Override any gcc2 internal prototype to avoid an error.  */
12448 /* We use char because int might match the return type of a gcc2
12449     builtin and then its argument prototype would still apply.  */
12450 char $ac_func();
12451
12452 int main() {
12453
12454 /* The GNU C library defines this for functions which it implements
12455     to always fail with ENOSYS.  Some functions are actually named
12456     something starting with __ and the normal name is an alias.  */
12457 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12458 choke me
12459 #else
12460 $ac_func();
12461 #endif
12462
12463 ; return 0; }
12464 EOF
12465 if { (eval echo configure:12466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12466   rm -rf conftest*
12467   eval "ac_cv_func_$ac_func=yes"
12468 else
12469   echo "configure: failed program was:" >&5
12470   cat conftest.$ac_ext >&5
12471   rm -rf conftest*
12472   eval "ac_cv_func_$ac_func=no"
12473 fi
12474 rm -f conftest*
12475 fi
12476
12477 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12478   echo "$ac_t""yes" 1>&6
12479     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12480   cat >> confdefs.h <<EOF
12481 #define $ac_tr_func 1
12482 EOF
12483
12484 else
12485   echo "$ac_t""no" 1>&6
12486 fi
12487 done
12488
12489   fi
12490
12491
12492   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
12493 echo "configure:12494: checking for _finite declaration" >&5
12494   if test x${glibcpp_cv_func__finite_use+set} != xset; then
12495     if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
12496   echo $ac_n "(cached) $ac_c" 1>&6
12497 else
12498
12499
12500       ac_ext=C
12501 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12502 ac_cpp='$CXXCPP $CPPFLAGS'
12503 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12504 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12505 cross_compiling=$ac_cv_prog_cxx_cross
12506
12507       cat > conftest.$ac_ext <<EOF
12508 #line 12509 "configure"
12509 #include "confdefs.h"
12510 #include <math.h>
12511 int main() {
12512  _finite(0);
12513 ; return 0; }
12514 EOF
12515 if { (eval echo configure:12516: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12516   rm -rf conftest*
12517   glibcpp_cv_func__finite_use=yes
12518 else
12519   echo "configure: failed program was:" >&5
12520   cat conftest.$ac_ext >&5
12521   rm -rf conftest*
12522   glibcpp_cv_func__finite_use=no
12523 fi
12524 rm -f conftest*
12525       ac_ext=c
12526 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12527 ac_cpp='$CPP $CPPFLAGS'
12528 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12529 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12530 cross_compiling=$ac_cv_prog_cc_cross
12531
12532
12533 fi
12534
12535   fi
12536   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
12537   if test x$glibcpp_cv_func__finite_use = x"yes"; then
12538     for ac_func in _finite
12539 do
12540 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12541 echo "configure:12542: checking for $ac_func" >&5
12542 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12543   echo $ac_n "(cached) $ac_c" 1>&6
12544 else
12545   cat > conftest.$ac_ext <<EOF
12546 #line 12547 "configure"
12547 #include "confdefs.h"
12548 /* System header to define __stub macros and hopefully few prototypes,
12549     which can conflict with char $ac_func(); below.  */
12550 #include <assert.h>
12551 /* Override any gcc2 internal prototype to avoid an error.  */
12552 /* We use char because int might match the return type of a gcc2
12553     builtin and then its argument prototype would still apply.  */
12554 char $ac_func();
12555
12556 int main() {
12557
12558 /* The GNU C library defines this for functions which it implements
12559     to always fail with ENOSYS.  Some functions are actually named
12560     something starting with __ and the normal name is an alias.  */
12561 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12562 choke me
12563 #else
12564 $ac_func();
12565 #endif
12566
12567 ; return 0; }
12568 EOF
12569 if { (eval echo configure:12570: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12570   rm -rf conftest*
12571   eval "ac_cv_func_$ac_func=yes"
12572 else
12573   echo "configure: failed program was:" >&5
12574   cat conftest.$ac_ext >&5
12575   rm -rf conftest*
12576   eval "ac_cv_func_$ac_func=no"
12577 fi
12578 rm -f conftest*
12579 fi
12580
12581 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12582   echo "$ac_t""yes" 1>&6
12583     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12584   cat >> confdefs.h <<EOF
12585 #define $ac_tr_func 1
12586 EOF
12587
12588 else
12589   echo "$ac_t""no" 1>&6
12590 fi
12591 done
12592
12593   fi
12594
12595
12596   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
12597 echo "configure:12598: checking for _copysign declaration" >&5
12598   if test x${glibcpp_cv_func__copysign_use+set} != xset; then
12599     if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
12600   echo $ac_n "(cached) $ac_c" 1>&6
12601 else
12602
12603
12604       ac_ext=C
12605 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12606 ac_cpp='$CXXCPP $CPPFLAGS'
12607 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12608 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12609 cross_compiling=$ac_cv_prog_cxx_cross
12610
12611       cat > conftest.$ac_ext <<EOF
12612 #line 12613 "configure"
12613 #include "confdefs.h"
12614 #include <math.h>
12615 int main() {
12616  _copysign(0, 0);
12617 ; return 0; }
12618 EOF
12619 if { (eval echo configure:12620: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12620   rm -rf conftest*
12621   glibcpp_cv_func__copysign_use=yes
12622 else
12623   echo "configure: failed program was:" >&5
12624   cat conftest.$ac_ext >&5
12625   rm -rf conftest*
12626   glibcpp_cv_func__copysign_use=no
12627 fi
12628 rm -f conftest*
12629       ac_ext=c
12630 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12631 ac_cpp='$CPP $CPPFLAGS'
12632 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12633 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12634 cross_compiling=$ac_cv_prog_cc_cross
12635
12636
12637 fi
12638
12639   fi
12640   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
12641   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
12642     for ac_func in _copysign
12643 do
12644 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12645 echo "configure:12646: checking for $ac_func" >&5
12646 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12647   echo $ac_n "(cached) $ac_c" 1>&6
12648 else
12649   cat > conftest.$ac_ext <<EOF
12650 #line 12651 "configure"
12651 #include "confdefs.h"
12652 /* System header to define __stub macros and hopefully few prototypes,
12653     which can conflict with char $ac_func(); below.  */
12654 #include <assert.h>
12655 /* Override any gcc2 internal prototype to avoid an error.  */
12656 /* We use char because int might match the return type of a gcc2
12657     builtin and then its argument prototype would still apply.  */
12658 char $ac_func();
12659
12660 int main() {
12661
12662 /* The GNU C library defines this for functions which it implements
12663     to always fail with ENOSYS.  Some functions are actually named
12664     something starting with __ and the normal name is an alias.  */
12665 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12666 choke me
12667 #else
12668 $ac_func();
12669 #endif
12670
12671 ; return 0; }
12672 EOF
12673 if { (eval echo configure:12674: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12674   rm -rf conftest*
12675   eval "ac_cv_func_$ac_func=yes"
12676 else
12677   echo "configure: failed program was:" >&5
12678   cat conftest.$ac_ext >&5
12679   rm -rf conftest*
12680   eval "ac_cv_func_$ac_func=no"
12681 fi
12682 rm -f conftest*
12683 fi
12684
12685 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12686   echo "$ac_t""yes" 1>&6
12687     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12688   cat >> confdefs.h <<EOF
12689 #define $ac_tr_func 1
12690 EOF
12691
12692 else
12693   echo "$ac_t""no" 1>&6
12694 fi
12695 done
12696
12697   fi
12698
12699
12700   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
12701 echo "configure:12702: checking for _sincos declaration" >&5
12702   if test x${glibcpp_cv_func__sincos_use+set} != xset; then
12703     if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
12704   echo $ac_n "(cached) $ac_c" 1>&6
12705 else
12706
12707
12708       ac_ext=C
12709 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12710 ac_cpp='$CXXCPP $CPPFLAGS'
12711 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12712 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12713 cross_compiling=$ac_cv_prog_cxx_cross
12714
12715       cat > conftest.$ac_ext <<EOF
12716 #line 12717 "configure"
12717 #include "confdefs.h"
12718 #include <math.h>
12719 int main() {
12720  _sincos(0, 0, 0);
12721 ; return 0; }
12722 EOF
12723 if { (eval echo configure:12724: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12724   rm -rf conftest*
12725   glibcpp_cv_func__sincos_use=yes
12726 else
12727   echo "configure: failed program was:" >&5
12728   cat conftest.$ac_ext >&5
12729   rm -rf conftest*
12730   glibcpp_cv_func__sincos_use=no
12731 fi
12732 rm -f conftest*
12733       ac_ext=c
12734 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12735 ac_cpp='$CPP $CPPFLAGS'
12736 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12737 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12738 cross_compiling=$ac_cv_prog_cc_cross
12739
12740
12741 fi
12742
12743   fi
12744   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
12745   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
12746     for ac_func in _sincos
12747 do
12748 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12749 echo "configure:12750: checking for $ac_func" >&5
12750 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12751   echo $ac_n "(cached) $ac_c" 1>&6
12752 else
12753   cat > conftest.$ac_ext <<EOF
12754 #line 12755 "configure"
12755 #include "confdefs.h"
12756 /* System header to define __stub macros and hopefully few prototypes,
12757     which can conflict with char $ac_func(); below.  */
12758 #include <assert.h>
12759 /* Override any gcc2 internal prototype to avoid an error.  */
12760 /* We use char because int might match the return type of a gcc2
12761     builtin and then its argument prototype would still apply.  */
12762 char $ac_func();
12763
12764 int main() {
12765
12766 /* The GNU C library defines this for functions which it implements
12767     to always fail with ENOSYS.  Some functions are actually named
12768     something starting with __ and the normal name is an alias.  */
12769 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12770 choke me
12771 #else
12772 $ac_func();
12773 #endif
12774
12775 ; return 0; }
12776 EOF
12777 if { (eval echo configure:12778: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12778   rm -rf conftest*
12779   eval "ac_cv_func_$ac_func=yes"
12780 else
12781   echo "configure: failed program was:" >&5
12782   cat conftest.$ac_ext >&5
12783   rm -rf conftest*
12784   eval "ac_cv_func_$ac_func=no"
12785 fi
12786 rm -f conftest*
12787 fi
12788
12789 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12790   echo "$ac_t""yes" 1>&6
12791     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12792   cat >> confdefs.h <<EOF
12793 #define $ac_tr_func 1
12794 EOF
12795
12796 else
12797   echo "$ac_t""no" 1>&6
12798 fi
12799 done
12800
12801   fi
12802
12803
12804   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
12805 echo "configure:12806: checking for _fpclass declaration" >&5
12806   if test x${glibcpp_cv_func__fpclass_use+set} != xset; then
12807     if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
12808   echo $ac_n "(cached) $ac_c" 1>&6
12809 else
12810
12811
12812       ac_ext=C
12813 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12814 ac_cpp='$CXXCPP $CPPFLAGS'
12815 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12816 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12817 cross_compiling=$ac_cv_prog_cxx_cross
12818
12819       cat > conftest.$ac_ext <<EOF
12820 #line 12821 "configure"
12821 #include "confdefs.h"
12822 #include <math.h>
12823 int main() {
12824  _fpclass(0);
12825 ; return 0; }
12826 EOF
12827 if { (eval echo configure:12828: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12828   rm -rf conftest*
12829   glibcpp_cv_func__fpclass_use=yes
12830 else
12831   echo "configure: failed program was:" >&5
12832   cat conftest.$ac_ext >&5
12833   rm -rf conftest*
12834   glibcpp_cv_func__fpclass_use=no
12835 fi
12836 rm -f conftest*
12837       ac_ext=c
12838 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12839 ac_cpp='$CPP $CPPFLAGS'
12840 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12841 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12842 cross_compiling=$ac_cv_prog_cc_cross
12843
12844
12845 fi
12846
12847   fi
12848   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
12849   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
12850     for ac_func in _fpclass
12851 do
12852 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12853 echo "configure:12854: checking for $ac_func" >&5
12854 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12855   echo $ac_n "(cached) $ac_c" 1>&6
12856 else
12857   cat > conftest.$ac_ext <<EOF
12858 #line 12859 "configure"
12859 #include "confdefs.h"
12860 /* System header to define __stub macros and hopefully few prototypes,
12861     which can conflict with char $ac_func(); below.  */
12862 #include <assert.h>
12863 /* Override any gcc2 internal prototype to avoid an error.  */
12864 /* We use char because int might match the return type of a gcc2
12865     builtin and then its argument prototype would still apply.  */
12866 char $ac_func();
12867
12868 int main() {
12869
12870 /* The GNU C library defines this for functions which it implements
12871     to always fail with ENOSYS.  Some functions are actually named
12872     something starting with __ and the normal name is an alias.  */
12873 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12874 choke me
12875 #else
12876 $ac_func();
12877 #endif
12878
12879 ; return 0; }
12880 EOF
12881 if { (eval echo configure:12882: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12882   rm -rf conftest*
12883   eval "ac_cv_func_$ac_func=yes"
12884 else
12885   echo "configure: failed program was:" >&5
12886   cat conftest.$ac_ext >&5
12887   rm -rf conftest*
12888   eval "ac_cv_func_$ac_func=no"
12889 fi
12890 rm -f conftest*
12891 fi
12892
12893 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12894   echo "$ac_t""yes" 1>&6
12895     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12896   cat >> confdefs.h <<EOF
12897 #define $ac_tr_func 1
12898 EOF
12899
12900 else
12901   echo "$ac_t""no" 1>&6
12902 fi
12903 done
12904
12905   fi
12906
12907
12908   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
12909 echo "configure:12910: checking for _qfpclass declaration" >&5
12910   if test x${glibcpp_cv_func__qfpclass_use+set} != xset; then
12911     if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
12912   echo $ac_n "(cached) $ac_c" 1>&6
12913 else
12914
12915
12916       ac_ext=C
12917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12918 ac_cpp='$CXXCPP $CPPFLAGS'
12919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12921 cross_compiling=$ac_cv_prog_cxx_cross
12922
12923       cat > conftest.$ac_ext <<EOF
12924 #line 12925 "configure"
12925 #include "confdefs.h"
12926 #include <math.h>
12927 int main() {
12928  _qfpclass(0);
12929 ; return 0; }
12930 EOF
12931 if { (eval echo configure:12932: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12932   rm -rf conftest*
12933   glibcpp_cv_func__qfpclass_use=yes
12934 else
12935   echo "configure: failed program was:" >&5
12936   cat conftest.$ac_ext >&5
12937   rm -rf conftest*
12938   glibcpp_cv_func__qfpclass_use=no
12939 fi
12940 rm -f conftest*
12941       ac_ext=c
12942 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12943 ac_cpp='$CPP $CPPFLAGS'
12944 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12945 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12946 cross_compiling=$ac_cv_prog_cc_cross
12947
12948
12949 fi
12950
12951   fi
12952   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
12953   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
12954     for ac_func in _qfpclass
12955 do
12956 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12957 echo "configure:12958: checking for $ac_func" >&5
12958 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12959   echo $ac_n "(cached) $ac_c" 1>&6
12960 else
12961   cat > conftest.$ac_ext <<EOF
12962 #line 12963 "configure"
12963 #include "confdefs.h"
12964 /* System header to define __stub macros and hopefully few prototypes,
12965     which can conflict with char $ac_func(); below.  */
12966 #include <assert.h>
12967 /* Override any gcc2 internal prototype to avoid an error.  */
12968 /* We use char because int might match the return type of a gcc2
12969     builtin and then its argument prototype would still apply.  */
12970 char $ac_func();
12971
12972 int main() {
12973
12974 /* The GNU C library defines this for functions which it implements
12975     to always fail with ENOSYS.  Some functions are actually named
12976     something starting with __ and the normal name is an alias.  */
12977 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12978 choke me
12979 #else
12980 $ac_func();
12981 #endif
12982
12983 ; return 0; }
12984 EOF
12985 if { (eval echo configure:12986: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12986   rm -rf conftest*
12987   eval "ac_cv_func_$ac_func=yes"
12988 else
12989   echo "configure: failed program was:" >&5
12990   cat conftest.$ac_ext >&5
12991   rm -rf conftest*
12992   eval "ac_cv_func_$ac_func=no"
12993 fi
12994 rm -f conftest*
12995 fi
12996
12997 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12998   echo "$ac_t""yes" 1>&6
12999     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13000   cat >> confdefs.h <<EOF
13001 #define $ac_tr_func 1
13002 EOF
13003
13004 else
13005   echo "$ac_t""no" 1>&6
13006 fi
13007 done
13008
13009   fi
13010
13011
13012
13013   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
13014 echo "configure:13015: checking for _isnanf declaration" >&5
13015   if test x${glibcpp_cv_func__isnanf_use+set} != xset; then
13016     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
13017   echo $ac_n "(cached) $ac_c" 1>&6
13018 else
13019
13020
13021       ac_ext=C
13022 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13023 ac_cpp='$CXXCPP $CPPFLAGS'
13024 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13025 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13026 cross_compiling=$ac_cv_prog_cxx_cross
13027
13028       cat > conftest.$ac_ext <<EOF
13029 #line 13030 "configure"
13030 #include "confdefs.h"
13031 #include <math.h>
13032 int main() {
13033  _isnanf(0);
13034 ; return 0; }
13035 EOF
13036 if { (eval echo configure:13037: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13037   rm -rf conftest*
13038   glibcpp_cv_func__isnanf_use=yes
13039 else
13040   echo "configure: failed program was:" >&5
13041   cat conftest.$ac_ext >&5
13042   rm -rf conftest*
13043   glibcpp_cv_func__isnanf_use=no
13044 fi
13045 rm -f conftest*
13046       ac_ext=c
13047 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13048 ac_cpp='$CPP $CPPFLAGS'
13049 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13050 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13051 cross_compiling=$ac_cv_prog_cc_cross
13052
13053
13054 fi
13055
13056   fi
13057   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
13058   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
13059     for ac_func in _isnanf
13060 do
13061 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13062 echo "configure:13063: checking for $ac_func" >&5
13063 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13064   echo $ac_n "(cached) $ac_c" 1>&6
13065 else
13066   cat > conftest.$ac_ext <<EOF
13067 #line 13068 "configure"
13068 #include "confdefs.h"
13069 /* System header to define __stub macros and hopefully few prototypes,
13070     which can conflict with char $ac_func(); below.  */
13071 #include <assert.h>
13072 /* Override any gcc2 internal prototype to avoid an error.  */
13073 /* We use char because int might match the return type of a gcc2
13074     builtin and then its argument prototype would still apply.  */
13075 char $ac_func();
13076
13077 int main() {
13078
13079 /* The GNU C library defines this for functions which it implements
13080     to always fail with ENOSYS.  Some functions are actually named
13081     something starting with __ and the normal name is an alias.  */
13082 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13083 choke me
13084 #else
13085 $ac_func();
13086 #endif
13087
13088 ; return 0; }
13089 EOF
13090 if { (eval echo configure:13091: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13091   rm -rf conftest*
13092   eval "ac_cv_func_$ac_func=yes"
13093 else
13094   echo "configure: failed program was:" >&5
13095   cat conftest.$ac_ext >&5
13096   rm -rf conftest*
13097   eval "ac_cv_func_$ac_func=no"
13098 fi
13099 rm -f conftest*
13100 fi
13101
13102 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13103   echo "$ac_t""yes" 1>&6
13104     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13105   cat >> confdefs.h <<EOF
13106 #define $ac_tr_func 1
13107 EOF
13108
13109 else
13110   echo "$ac_t""no" 1>&6
13111 fi
13112 done
13113
13114   fi
13115
13116
13117   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
13118 echo "configure:13119: checking for _isinff declaration" >&5
13119   if test x${glibcpp_cv_func__isinff_use+set} != xset; then
13120     if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
13121   echo $ac_n "(cached) $ac_c" 1>&6
13122 else
13123
13124
13125       ac_ext=C
13126 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13127 ac_cpp='$CXXCPP $CPPFLAGS'
13128 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13129 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13130 cross_compiling=$ac_cv_prog_cxx_cross
13131
13132       cat > conftest.$ac_ext <<EOF
13133 #line 13134 "configure"
13134 #include "confdefs.h"
13135 #include <math.h>
13136 int main() {
13137  _isinff(0);
13138 ; return 0; }
13139 EOF
13140 if { (eval echo configure:13141: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13141   rm -rf conftest*
13142   glibcpp_cv_func__isinff_use=yes
13143 else
13144   echo "configure: failed program was:" >&5
13145   cat conftest.$ac_ext >&5
13146   rm -rf conftest*
13147   glibcpp_cv_func__isinff_use=no
13148 fi
13149 rm -f conftest*
13150       ac_ext=c
13151 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13152 ac_cpp='$CPP $CPPFLAGS'
13153 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13154 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13155 cross_compiling=$ac_cv_prog_cc_cross
13156
13157
13158 fi
13159
13160   fi
13161   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
13162   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
13163     for ac_func in _isinff
13164 do
13165 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13166 echo "configure:13167: checking for $ac_func" >&5
13167 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13168   echo $ac_n "(cached) $ac_c" 1>&6
13169 else
13170   cat > conftest.$ac_ext <<EOF
13171 #line 13172 "configure"
13172 #include "confdefs.h"
13173 /* System header to define __stub macros and hopefully few prototypes,
13174     which can conflict with char $ac_func(); below.  */
13175 #include <assert.h>
13176 /* Override any gcc2 internal prototype to avoid an error.  */
13177 /* We use char because int might match the return type of a gcc2
13178     builtin and then its argument prototype would still apply.  */
13179 char $ac_func();
13180
13181 int main() {
13182
13183 /* The GNU C library defines this for functions which it implements
13184     to always fail with ENOSYS.  Some functions are actually named
13185     something starting with __ and the normal name is an alias.  */
13186 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13187 choke me
13188 #else
13189 $ac_func();
13190 #endif
13191
13192 ; return 0; }
13193 EOF
13194 if { (eval echo configure:13195: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13195   rm -rf conftest*
13196   eval "ac_cv_func_$ac_func=yes"
13197 else
13198   echo "configure: failed program was:" >&5
13199   cat conftest.$ac_ext >&5
13200   rm -rf conftest*
13201   eval "ac_cv_func_$ac_func=no"
13202 fi
13203 rm -f conftest*
13204 fi
13205
13206 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13207   echo "$ac_t""yes" 1>&6
13208     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13209   cat >> confdefs.h <<EOF
13210 #define $ac_tr_func 1
13211 EOF
13212
13213 else
13214   echo "$ac_t""no" 1>&6
13215 fi
13216 done
13217
13218   fi
13219
13220
13221   echo $ac_n "checking for _copysignf declaration""... $ac_c" 1>&6
13222 echo "configure:13223: checking for _copysignf declaration" >&5
13223   if test x${glibcpp_cv_func__copysignf_use+set} != xset; then
13224     if eval "test \"`echo '$''{'glibcpp_cv_func__copysignf_use'+set}'`\" = set"; then
13225   echo $ac_n "(cached) $ac_c" 1>&6
13226 else
13227
13228
13229       ac_ext=C
13230 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13231 ac_cpp='$CXXCPP $CPPFLAGS'
13232 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13233 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13234 cross_compiling=$ac_cv_prog_cxx_cross
13235
13236       cat > conftest.$ac_ext <<EOF
13237 #line 13238 "configure"
13238 #include "confdefs.h"
13239 #include <math.h>
13240 int main() {
13241  _copysignf(0, 0);
13242 ; return 0; }
13243 EOF
13244 if { (eval echo configure:13245: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13245   rm -rf conftest*
13246   glibcpp_cv_func__copysignf_use=yes
13247 else
13248   echo "configure: failed program was:" >&5
13249   cat conftest.$ac_ext >&5
13250   rm -rf conftest*
13251   glibcpp_cv_func__copysignf_use=no
13252 fi
13253 rm -f conftest*
13254       ac_ext=c
13255 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13256 ac_cpp='$CPP $CPPFLAGS'
13257 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13258 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13259 cross_compiling=$ac_cv_prog_cc_cross
13260
13261
13262 fi
13263
13264   fi
13265   echo "$ac_t""$glibcpp_cv_func__copysignf_use" 1>&6
13266   if test x$glibcpp_cv_func__copysignf_use = x"yes"; then
13267     for ac_func in _copysignf
13268 do
13269 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13270 echo "configure:13271: checking for $ac_func" >&5
13271 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13272   echo $ac_n "(cached) $ac_c" 1>&6
13273 else
13274   cat > conftest.$ac_ext <<EOF
13275 #line 13276 "configure"
13276 #include "confdefs.h"
13277 /* System header to define __stub macros and hopefully few prototypes,
13278     which can conflict with char $ac_func(); below.  */
13279 #include <assert.h>
13280 /* Override any gcc2 internal prototype to avoid an error.  */
13281 /* We use char because int might match the return type of a gcc2
13282     builtin and then its argument prototype would still apply.  */
13283 char $ac_func();
13284
13285 int main() {
13286
13287 /* The GNU C library defines this for functions which it implements
13288     to always fail with ENOSYS.  Some functions are actually named
13289     something starting with __ and the normal name is an alias.  */
13290 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13291 choke me
13292 #else
13293 $ac_func();
13294 #endif
13295
13296 ; return 0; }
13297 EOF
13298 if { (eval echo configure:13299: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13299   rm -rf conftest*
13300   eval "ac_cv_func_$ac_func=yes"
13301 else
13302   echo "configure: failed program was:" >&5
13303   cat conftest.$ac_ext >&5
13304   rm -rf conftest*
13305   eval "ac_cv_func_$ac_func=no"
13306 fi
13307 rm -f conftest*
13308 fi
13309
13310 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13311   echo "$ac_t""yes" 1>&6
13312     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13313   cat >> confdefs.h <<EOF
13314 #define $ac_tr_func 1
13315 EOF
13316
13317 else
13318   echo "$ac_t""no" 1>&6
13319 fi
13320 done
13321
13322   fi
13323
13324
13325   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
13326 echo "configure:13327: checking for _acosf declaration" >&5
13327   if test x${glibcpp_cv_func__acosf_use+set} != xset; then
13328     if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
13329   echo $ac_n "(cached) $ac_c" 1>&6
13330 else
13331
13332
13333       ac_ext=C
13334 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13335 ac_cpp='$CXXCPP $CPPFLAGS'
13336 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13337 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13338 cross_compiling=$ac_cv_prog_cxx_cross
13339
13340       cat > conftest.$ac_ext <<EOF
13341 #line 13342 "configure"
13342 #include "confdefs.h"
13343 #include <math.h>
13344 int main() {
13345  _acosf(0);
13346 ; return 0; }
13347 EOF
13348 if { (eval echo configure:13349: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13349   rm -rf conftest*
13350   glibcpp_cv_func__acosf_use=yes
13351 else
13352   echo "configure: failed program was:" >&5
13353   cat conftest.$ac_ext >&5
13354   rm -rf conftest*
13355   glibcpp_cv_func__acosf_use=no
13356 fi
13357 rm -f conftest*
13358       ac_ext=c
13359 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13360 ac_cpp='$CPP $CPPFLAGS'
13361 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13362 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13363 cross_compiling=$ac_cv_prog_cc_cross
13364
13365
13366 fi
13367
13368   fi
13369   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
13370   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
13371     for ac_func in _acosf
13372 do
13373 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13374 echo "configure:13375: checking for $ac_func" >&5
13375 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13376   echo $ac_n "(cached) $ac_c" 1>&6
13377 else
13378   cat > conftest.$ac_ext <<EOF
13379 #line 13380 "configure"
13380 #include "confdefs.h"
13381 /* System header to define __stub macros and hopefully few prototypes,
13382     which can conflict with char $ac_func(); below.  */
13383 #include <assert.h>
13384 /* Override any gcc2 internal prototype to avoid an error.  */
13385 /* We use char because int might match the return type of a gcc2
13386     builtin and then its argument prototype would still apply.  */
13387 char $ac_func();
13388
13389 int main() {
13390
13391 /* The GNU C library defines this for functions which it implements
13392     to always fail with ENOSYS.  Some functions are actually named
13393     something starting with __ and the normal name is an alias.  */
13394 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13395 choke me
13396 #else
13397 $ac_func();
13398 #endif
13399
13400 ; return 0; }
13401 EOF
13402 if { (eval echo configure:13403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13403   rm -rf conftest*
13404   eval "ac_cv_func_$ac_func=yes"
13405 else
13406   echo "configure: failed program was:" >&5
13407   cat conftest.$ac_ext >&5
13408   rm -rf conftest*
13409   eval "ac_cv_func_$ac_func=no"
13410 fi
13411 rm -f conftest*
13412 fi
13413
13414 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13415   echo "$ac_t""yes" 1>&6
13416     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13417   cat >> confdefs.h <<EOF
13418 #define $ac_tr_func 1
13419 EOF
13420
13421 else
13422   echo "$ac_t""no" 1>&6
13423 fi
13424 done
13425
13426   fi
13427
13428
13429   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
13430 echo "configure:13431: checking for _asinf declaration" >&5
13431   if test x${glibcpp_cv_func__asinf_use+set} != xset; then
13432     if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
13433   echo $ac_n "(cached) $ac_c" 1>&6
13434 else
13435
13436
13437       ac_ext=C
13438 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13439 ac_cpp='$CXXCPP $CPPFLAGS'
13440 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13441 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13442 cross_compiling=$ac_cv_prog_cxx_cross
13443
13444       cat > conftest.$ac_ext <<EOF
13445 #line 13446 "configure"
13446 #include "confdefs.h"
13447 #include <math.h>
13448 int main() {
13449  _asinf(0);
13450 ; return 0; }
13451 EOF
13452 if { (eval echo configure:13453: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13453   rm -rf conftest*
13454   glibcpp_cv_func__asinf_use=yes
13455 else
13456   echo "configure: failed program was:" >&5
13457   cat conftest.$ac_ext >&5
13458   rm -rf conftest*
13459   glibcpp_cv_func__asinf_use=no
13460 fi
13461 rm -f conftest*
13462       ac_ext=c
13463 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13464 ac_cpp='$CPP $CPPFLAGS'
13465 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13466 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13467 cross_compiling=$ac_cv_prog_cc_cross
13468
13469
13470 fi
13471
13472   fi
13473   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
13474   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
13475     for ac_func in _asinf
13476 do
13477 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13478 echo "configure:13479: checking for $ac_func" >&5
13479 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13480   echo $ac_n "(cached) $ac_c" 1>&6
13481 else
13482   cat > conftest.$ac_ext <<EOF
13483 #line 13484 "configure"
13484 #include "confdefs.h"
13485 /* System header to define __stub macros and hopefully few prototypes,
13486     which can conflict with char $ac_func(); below.  */
13487 #include <assert.h>
13488 /* Override any gcc2 internal prototype to avoid an error.  */
13489 /* We use char because int might match the return type of a gcc2
13490     builtin and then its argument prototype would still apply.  */
13491 char $ac_func();
13492
13493 int main() {
13494
13495 /* The GNU C library defines this for functions which it implements
13496     to always fail with ENOSYS.  Some functions are actually named
13497     something starting with __ and the normal name is an alias.  */
13498 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13499 choke me
13500 #else
13501 $ac_func();
13502 #endif
13503
13504 ; return 0; }
13505 EOF
13506 if { (eval echo configure:13507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13507   rm -rf conftest*
13508   eval "ac_cv_func_$ac_func=yes"
13509 else
13510   echo "configure: failed program was:" >&5
13511   cat conftest.$ac_ext >&5
13512   rm -rf conftest*
13513   eval "ac_cv_func_$ac_func=no"
13514 fi
13515 rm -f conftest*
13516 fi
13517
13518 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13519   echo "$ac_t""yes" 1>&6
13520     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13521   cat >> confdefs.h <<EOF
13522 #define $ac_tr_func 1
13523 EOF
13524
13525 else
13526   echo "$ac_t""no" 1>&6
13527 fi
13528 done
13529
13530   fi
13531
13532
13533   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
13534 echo "configure:13535: checking for _atanf declaration" >&5
13535   if test x${glibcpp_cv_func__atanf_use+set} != xset; then
13536     if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
13537   echo $ac_n "(cached) $ac_c" 1>&6
13538 else
13539
13540
13541       ac_ext=C
13542 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13543 ac_cpp='$CXXCPP $CPPFLAGS'
13544 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13545 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13546 cross_compiling=$ac_cv_prog_cxx_cross
13547
13548       cat > conftest.$ac_ext <<EOF
13549 #line 13550 "configure"
13550 #include "confdefs.h"
13551 #include <math.h>
13552 int main() {
13553  _atanf(0);
13554 ; return 0; }
13555 EOF
13556 if { (eval echo configure:13557: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13557   rm -rf conftest*
13558   glibcpp_cv_func__atanf_use=yes
13559 else
13560   echo "configure: failed program was:" >&5
13561   cat conftest.$ac_ext >&5
13562   rm -rf conftest*
13563   glibcpp_cv_func__atanf_use=no
13564 fi
13565 rm -f conftest*
13566       ac_ext=c
13567 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13568 ac_cpp='$CPP $CPPFLAGS'
13569 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13570 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13571 cross_compiling=$ac_cv_prog_cc_cross
13572
13573
13574 fi
13575
13576   fi
13577   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
13578   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
13579     for ac_func in _atanf
13580 do
13581 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13582 echo "configure:13583: checking for $ac_func" >&5
13583 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13584   echo $ac_n "(cached) $ac_c" 1>&6
13585 else
13586   cat > conftest.$ac_ext <<EOF
13587 #line 13588 "configure"
13588 #include "confdefs.h"
13589 /* System header to define __stub macros and hopefully few prototypes,
13590     which can conflict with char $ac_func(); below.  */
13591 #include <assert.h>
13592 /* Override any gcc2 internal prototype to avoid an error.  */
13593 /* We use char because int might match the return type of a gcc2
13594     builtin and then its argument prototype would still apply.  */
13595 char $ac_func();
13596
13597 int main() {
13598
13599 /* The GNU C library defines this for functions which it implements
13600     to always fail with ENOSYS.  Some functions are actually named
13601     something starting with __ and the normal name is an alias.  */
13602 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13603 choke me
13604 #else
13605 $ac_func();
13606 #endif
13607
13608 ; return 0; }
13609 EOF
13610 if { (eval echo configure:13611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13611   rm -rf conftest*
13612   eval "ac_cv_func_$ac_func=yes"
13613 else
13614   echo "configure: failed program was:" >&5
13615   cat conftest.$ac_ext >&5
13616   rm -rf conftest*
13617   eval "ac_cv_func_$ac_func=no"
13618 fi
13619 rm -f conftest*
13620 fi
13621
13622 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13623   echo "$ac_t""yes" 1>&6
13624     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13625   cat >> confdefs.h <<EOF
13626 #define $ac_tr_func 1
13627 EOF
13628
13629 else
13630   echo "$ac_t""no" 1>&6
13631 fi
13632 done
13633
13634   fi
13635
13636
13637   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
13638 echo "configure:13639: checking for _atan2f declaration" >&5
13639   if test x${glibcpp_cv_func__atan2f_use+set} != xset; then
13640     if eval "test \"`echo '$''{'glibcpp_cv_func__atan2f_use'+set}'`\" = set"; then
13641   echo $ac_n "(cached) $ac_c" 1>&6
13642 else
13643
13644
13645       ac_ext=C
13646 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13647 ac_cpp='$CXXCPP $CPPFLAGS'
13648 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13649 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13650 cross_compiling=$ac_cv_prog_cxx_cross
13651
13652       cat > conftest.$ac_ext <<EOF
13653 #line 13654 "configure"
13654 #include "confdefs.h"
13655 #include <math.h>
13656 int main() {
13657  _atan2f(0, 0);
13658 ; return 0; }
13659 EOF
13660 if { (eval echo configure:13661: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13661   rm -rf conftest*
13662   glibcpp_cv_func__atan2f_use=yes
13663 else
13664   echo "configure: failed program was:" >&5
13665   cat conftest.$ac_ext >&5
13666   rm -rf conftest*
13667   glibcpp_cv_func__atan2f_use=no
13668 fi
13669 rm -f conftest*
13670       ac_ext=c
13671 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13672 ac_cpp='$CPP $CPPFLAGS'
13673 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13674 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13675 cross_compiling=$ac_cv_prog_cc_cross
13676
13677
13678 fi
13679
13680   fi
13681   echo "$ac_t""$glibcpp_cv_func__atan2f_use" 1>&6
13682   if test x$glibcpp_cv_func__atan2f_use = x"yes"; then
13683     for ac_func in _atan2f
13684 do
13685 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13686 echo "configure:13687: checking for $ac_func" >&5
13687 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13688   echo $ac_n "(cached) $ac_c" 1>&6
13689 else
13690   cat > conftest.$ac_ext <<EOF
13691 #line 13692 "configure"
13692 #include "confdefs.h"
13693 /* System header to define __stub macros and hopefully few prototypes,
13694     which can conflict with char $ac_func(); below.  */
13695 #include <assert.h>
13696 /* Override any gcc2 internal prototype to avoid an error.  */
13697 /* We use char because int might match the return type of a gcc2
13698     builtin and then its argument prototype would still apply.  */
13699 char $ac_func();
13700
13701 int main() {
13702
13703 /* The GNU C library defines this for functions which it implements
13704     to always fail with ENOSYS.  Some functions are actually named
13705     something starting with __ and the normal name is an alias.  */
13706 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13707 choke me
13708 #else
13709 $ac_func();
13710 #endif
13711
13712 ; return 0; }
13713 EOF
13714 if { (eval echo configure:13715: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13715   rm -rf conftest*
13716   eval "ac_cv_func_$ac_func=yes"
13717 else
13718   echo "configure: failed program was:" >&5
13719   cat conftest.$ac_ext >&5
13720   rm -rf conftest*
13721   eval "ac_cv_func_$ac_func=no"
13722 fi
13723 rm -f conftest*
13724 fi
13725
13726 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13727   echo "$ac_t""yes" 1>&6
13728     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13729   cat >> confdefs.h <<EOF
13730 #define $ac_tr_func 1
13731 EOF
13732
13733 else
13734   echo "$ac_t""no" 1>&6
13735 fi
13736 done
13737
13738   fi
13739
13740
13741   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
13742 echo "configure:13743: checking for _ceilf declaration" >&5
13743   if test x${glibcpp_cv_func__ceilf_use+set} != xset; then
13744     if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
13745   echo $ac_n "(cached) $ac_c" 1>&6
13746 else
13747
13748
13749       ac_ext=C
13750 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13751 ac_cpp='$CXXCPP $CPPFLAGS'
13752 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13753 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13754 cross_compiling=$ac_cv_prog_cxx_cross
13755
13756       cat > conftest.$ac_ext <<EOF
13757 #line 13758 "configure"
13758 #include "confdefs.h"
13759 #include <math.h>
13760 int main() {
13761  _ceilf(0);
13762 ; return 0; }
13763 EOF
13764 if { (eval echo configure:13765: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13765   rm -rf conftest*
13766   glibcpp_cv_func__ceilf_use=yes
13767 else
13768   echo "configure: failed program was:" >&5
13769   cat conftest.$ac_ext >&5
13770   rm -rf conftest*
13771   glibcpp_cv_func__ceilf_use=no
13772 fi
13773 rm -f conftest*
13774       ac_ext=c
13775 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13776 ac_cpp='$CPP $CPPFLAGS'
13777 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13778 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13779 cross_compiling=$ac_cv_prog_cc_cross
13780
13781
13782 fi
13783
13784   fi
13785   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
13786   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
13787     for ac_func in _ceilf
13788 do
13789 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13790 echo "configure:13791: checking for $ac_func" >&5
13791 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13792   echo $ac_n "(cached) $ac_c" 1>&6
13793 else
13794   cat > conftest.$ac_ext <<EOF
13795 #line 13796 "configure"
13796 #include "confdefs.h"
13797 /* System header to define __stub macros and hopefully few prototypes,
13798     which can conflict with char $ac_func(); below.  */
13799 #include <assert.h>
13800 /* Override any gcc2 internal prototype to avoid an error.  */
13801 /* We use char because int might match the return type of a gcc2
13802     builtin and then its argument prototype would still apply.  */
13803 char $ac_func();
13804
13805 int main() {
13806
13807 /* The GNU C library defines this for functions which it implements
13808     to always fail with ENOSYS.  Some functions are actually named
13809     something starting with __ and the normal name is an alias.  */
13810 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13811 choke me
13812 #else
13813 $ac_func();
13814 #endif
13815
13816 ; return 0; }
13817 EOF
13818 if { (eval echo configure:13819: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13819   rm -rf conftest*
13820   eval "ac_cv_func_$ac_func=yes"
13821 else
13822   echo "configure: failed program was:" >&5
13823   cat conftest.$ac_ext >&5
13824   rm -rf conftest*
13825   eval "ac_cv_func_$ac_func=no"
13826 fi
13827 rm -f conftest*
13828 fi
13829
13830 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13831   echo "$ac_t""yes" 1>&6
13832     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13833   cat >> confdefs.h <<EOF
13834 #define $ac_tr_func 1
13835 EOF
13836
13837 else
13838   echo "$ac_t""no" 1>&6
13839 fi
13840 done
13841
13842   fi
13843
13844
13845   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
13846 echo "configure:13847: checking for _cosf declaration" >&5
13847   if test x${glibcpp_cv_func__cosf_use+set} != xset; then
13848     if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
13849   echo $ac_n "(cached) $ac_c" 1>&6
13850 else
13851
13852
13853       ac_ext=C
13854 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13855 ac_cpp='$CXXCPP $CPPFLAGS'
13856 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13857 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13858 cross_compiling=$ac_cv_prog_cxx_cross
13859
13860       cat > conftest.$ac_ext <<EOF
13861 #line 13862 "configure"
13862 #include "confdefs.h"
13863 #include <math.h>
13864 int main() {
13865  _cosf(0);
13866 ; return 0; }
13867 EOF
13868 if { (eval echo configure:13869: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13869   rm -rf conftest*
13870   glibcpp_cv_func__cosf_use=yes
13871 else
13872   echo "configure: failed program was:" >&5
13873   cat conftest.$ac_ext >&5
13874   rm -rf conftest*
13875   glibcpp_cv_func__cosf_use=no
13876 fi
13877 rm -f conftest*
13878       ac_ext=c
13879 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13880 ac_cpp='$CPP $CPPFLAGS'
13881 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13882 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13883 cross_compiling=$ac_cv_prog_cc_cross
13884
13885
13886 fi
13887
13888   fi
13889   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
13890   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
13891     for ac_func in _cosf
13892 do
13893 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13894 echo "configure:13895: checking for $ac_func" >&5
13895 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13896   echo $ac_n "(cached) $ac_c" 1>&6
13897 else
13898   cat > conftest.$ac_ext <<EOF
13899 #line 13900 "configure"
13900 #include "confdefs.h"
13901 /* System header to define __stub macros and hopefully few prototypes,
13902     which can conflict with char $ac_func(); below.  */
13903 #include <assert.h>
13904 /* Override any gcc2 internal prototype to avoid an error.  */
13905 /* We use char because int might match the return type of a gcc2
13906     builtin and then its argument prototype would still apply.  */
13907 char $ac_func();
13908
13909 int main() {
13910
13911 /* The GNU C library defines this for functions which it implements
13912     to always fail with ENOSYS.  Some functions are actually named
13913     something starting with __ and the normal name is an alias.  */
13914 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13915 choke me
13916 #else
13917 $ac_func();
13918 #endif
13919
13920 ; return 0; }
13921 EOF
13922 if { (eval echo configure:13923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13923   rm -rf conftest*
13924   eval "ac_cv_func_$ac_func=yes"
13925 else
13926   echo "configure: failed program was:" >&5
13927   cat conftest.$ac_ext >&5
13928   rm -rf conftest*
13929   eval "ac_cv_func_$ac_func=no"
13930 fi
13931 rm -f conftest*
13932 fi
13933
13934 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13935   echo "$ac_t""yes" 1>&6
13936     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13937   cat >> confdefs.h <<EOF
13938 #define $ac_tr_func 1
13939 EOF
13940
13941 else
13942   echo "$ac_t""no" 1>&6
13943 fi
13944 done
13945
13946   fi
13947
13948
13949   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
13950 echo "configure:13951: checking for _coshf declaration" >&5
13951   if test x${glibcpp_cv_func__coshf_use+set} != xset; then
13952     if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
13953   echo $ac_n "(cached) $ac_c" 1>&6
13954 else
13955
13956
13957       ac_ext=C
13958 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13959 ac_cpp='$CXXCPP $CPPFLAGS'
13960 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13961 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13962 cross_compiling=$ac_cv_prog_cxx_cross
13963
13964       cat > conftest.$ac_ext <<EOF
13965 #line 13966 "configure"
13966 #include "confdefs.h"
13967 #include <math.h>
13968 int main() {
13969  _coshf(0);
13970 ; return 0; }
13971 EOF
13972 if { (eval echo configure:13973: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13973   rm -rf conftest*
13974   glibcpp_cv_func__coshf_use=yes
13975 else
13976   echo "configure: failed program was:" >&5
13977   cat conftest.$ac_ext >&5
13978   rm -rf conftest*
13979   glibcpp_cv_func__coshf_use=no
13980 fi
13981 rm -f conftest*
13982       ac_ext=c
13983 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13984 ac_cpp='$CPP $CPPFLAGS'
13985 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13986 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13987 cross_compiling=$ac_cv_prog_cc_cross
13988
13989
13990 fi
13991
13992   fi
13993   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
13994   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
13995     for ac_func in _coshf
13996 do
13997 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13998 echo "configure:13999: checking for $ac_func" >&5
13999 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14000   echo $ac_n "(cached) $ac_c" 1>&6
14001 else
14002   cat > conftest.$ac_ext <<EOF
14003 #line 14004 "configure"
14004 #include "confdefs.h"
14005 /* System header to define __stub macros and hopefully few prototypes,
14006     which can conflict with char $ac_func(); below.  */
14007 #include <assert.h>
14008 /* Override any gcc2 internal prototype to avoid an error.  */
14009 /* We use char because int might match the return type of a gcc2
14010     builtin and then its argument prototype would still apply.  */
14011 char $ac_func();
14012
14013 int main() {
14014
14015 /* The GNU C library defines this for functions which it implements
14016     to always fail with ENOSYS.  Some functions are actually named
14017     something starting with __ and the normal name is an alias.  */
14018 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14019 choke me
14020 #else
14021 $ac_func();
14022 #endif
14023
14024 ; return 0; }
14025 EOF
14026 if { (eval echo configure:14027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14027   rm -rf conftest*
14028   eval "ac_cv_func_$ac_func=yes"
14029 else
14030   echo "configure: failed program was:" >&5
14031   cat conftest.$ac_ext >&5
14032   rm -rf conftest*
14033   eval "ac_cv_func_$ac_func=no"
14034 fi
14035 rm -f conftest*
14036 fi
14037
14038 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14039   echo "$ac_t""yes" 1>&6
14040     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14041   cat >> confdefs.h <<EOF
14042 #define $ac_tr_func 1
14043 EOF
14044
14045 else
14046   echo "$ac_t""no" 1>&6
14047 fi
14048 done
14049
14050   fi
14051
14052
14053   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
14054 echo "configure:14055: checking for _expf declaration" >&5
14055   if test x${glibcpp_cv_func__expf_use+set} != xset; then
14056     if eval "test \"`echo '$''{'glibcpp_cv_func__expf_use'+set}'`\" = set"; then
14057   echo $ac_n "(cached) $ac_c" 1>&6
14058 else
14059
14060
14061       ac_ext=C
14062 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14063 ac_cpp='$CXXCPP $CPPFLAGS'
14064 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14065 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14066 cross_compiling=$ac_cv_prog_cxx_cross
14067
14068       cat > conftest.$ac_ext <<EOF
14069 #line 14070 "configure"
14070 #include "confdefs.h"
14071 #include <math.h>
14072 int main() {
14073  _expf(0);
14074 ; return 0; }
14075 EOF
14076 if { (eval echo configure:14077: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14077   rm -rf conftest*
14078   glibcpp_cv_func__expf_use=yes
14079 else
14080   echo "configure: failed program was:" >&5
14081   cat conftest.$ac_ext >&5
14082   rm -rf conftest*
14083   glibcpp_cv_func__expf_use=no
14084 fi
14085 rm -f conftest*
14086       ac_ext=c
14087 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14088 ac_cpp='$CPP $CPPFLAGS'
14089 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14090 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14091 cross_compiling=$ac_cv_prog_cc_cross
14092
14093
14094 fi
14095
14096   fi
14097   echo "$ac_t""$glibcpp_cv_func__expf_use" 1>&6
14098   if test x$glibcpp_cv_func__expf_use = x"yes"; then
14099     for ac_func in _expf
14100 do
14101 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14102 echo "configure:14103: checking for $ac_func" >&5
14103 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14104   echo $ac_n "(cached) $ac_c" 1>&6
14105 else
14106   cat > conftest.$ac_ext <<EOF
14107 #line 14108 "configure"
14108 #include "confdefs.h"
14109 /* System header to define __stub macros and hopefully few prototypes,
14110     which can conflict with char $ac_func(); below.  */
14111 #include <assert.h>
14112 /* Override any gcc2 internal prototype to avoid an error.  */
14113 /* We use char because int might match the return type of a gcc2
14114     builtin and then its argument prototype would still apply.  */
14115 char $ac_func();
14116
14117 int main() {
14118
14119 /* The GNU C library defines this for functions which it implements
14120     to always fail with ENOSYS.  Some functions are actually named
14121     something starting with __ and the normal name is an alias.  */
14122 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14123 choke me
14124 #else
14125 $ac_func();
14126 #endif
14127
14128 ; return 0; }
14129 EOF
14130 if { (eval echo configure:14131: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14131   rm -rf conftest*
14132   eval "ac_cv_func_$ac_func=yes"
14133 else
14134   echo "configure: failed program was:" >&5
14135   cat conftest.$ac_ext >&5
14136   rm -rf conftest*
14137   eval "ac_cv_func_$ac_func=no"
14138 fi
14139 rm -f conftest*
14140 fi
14141
14142 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14143   echo "$ac_t""yes" 1>&6
14144     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14145   cat >> confdefs.h <<EOF
14146 #define $ac_tr_func 1
14147 EOF
14148
14149 else
14150   echo "$ac_t""no" 1>&6
14151 fi
14152 done
14153
14154   fi
14155
14156
14157   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
14158 echo "configure:14159: checking for _fabsf declaration" >&5
14159   if test x${glibcpp_cv_func__fabsf_use+set} != xset; then
14160     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
14161   echo $ac_n "(cached) $ac_c" 1>&6
14162 else
14163
14164
14165       ac_ext=C
14166 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14167 ac_cpp='$CXXCPP $CPPFLAGS'
14168 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14169 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14170 cross_compiling=$ac_cv_prog_cxx_cross
14171
14172       cat > conftest.$ac_ext <<EOF
14173 #line 14174 "configure"
14174 #include "confdefs.h"
14175 #include <math.h>
14176 int main() {
14177  _fabsf(0);
14178 ; return 0; }
14179 EOF
14180 if { (eval echo configure:14181: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14181   rm -rf conftest*
14182   glibcpp_cv_func__fabsf_use=yes
14183 else
14184   echo "configure: failed program was:" >&5
14185   cat conftest.$ac_ext >&5
14186   rm -rf conftest*
14187   glibcpp_cv_func__fabsf_use=no
14188 fi
14189 rm -f conftest*
14190       ac_ext=c
14191 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14192 ac_cpp='$CPP $CPPFLAGS'
14193 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14194 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14195 cross_compiling=$ac_cv_prog_cc_cross
14196
14197
14198 fi
14199
14200   fi
14201   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
14202   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
14203     for ac_func in _fabsf
14204 do
14205 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14206 echo "configure:14207: checking for $ac_func" >&5
14207 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14208   echo $ac_n "(cached) $ac_c" 1>&6
14209 else
14210   cat > conftest.$ac_ext <<EOF
14211 #line 14212 "configure"
14212 #include "confdefs.h"
14213 /* System header to define __stub macros and hopefully few prototypes,
14214     which can conflict with char $ac_func(); below.  */
14215 #include <assert.h>
14216 /* Override any gcc2 internal prototype to avoid an error.  */
14217 /* We use char because int might match the return type of a gcc2
14218     builtin and then its argument prototype would still apply.  */
14219 char $ac_func();
14220
14221 int main() {
14222
14223 /* The GNU C library defines this for functions which it implements
14224     to always fail with ENOSYS.  Some functions are actually named
14225     something starting with __ and the normal name is an alias.  */
14226 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14227 choke me
14228 #else
14229 $ac_func();
14230 #endif
14231
14232 ; return 0; }
14233 EOF
14234 if { (eval echo configure:14235: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14235   rm -rf conftest*
14236   eval "ac_cv_func_$ac_func=yes"
14237 else
14238   echo "configure: failed program was:" >&5
14239   cat conftest.$ac_ext >&5
14240   rm -rf conftest*
14241   eval "ac_cv_func_$ac_func=no"
14242 fi
14243 rm -f conftest*
14244 fi
14245
14246 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14247   echo "$ac_t""yes" 1>&6
14248     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14249   cat >> confdefs.h <<EOF
14250 #define $ac_tr_func 1
14251 EOF
14252
14253 else
14254   echo "$ac_t""no" 1>&6
14255 fi
14256 done
14257
14258   fi
14259
14260
14261   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
14262 echo "configure:14263: checking for _floorf declaration" >&5
14263   if test x${glibcpp_cv_func__floorf_use+set} != xset; then
14264     if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
14265   echo $ac_n "(cached) $ac_c" 1>&6
14266 else
14267
14268
14269       ac_ext=C
14270 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14271 ac_cpp='$CXXCPP $CPPFLAGS'
14272 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14273 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14274 cross_compiling=$ac_cv_prog_cxx_cross
14275
14276       cat > conftest.$ac_ext <<EOF
14277 #line 14278 "configure"
14278 #include "confdefs.h"
14279 #include <math.h>
14280 int main() {
14281  _floorf(0);
14282 ; return 0; }
14283 EOF
14284 if { (eval echo configure:14285: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14285   rm -rf conftest*
14286   glibcpp_cv_func__floorf_use=yes
14287 else
14288   echo "configure: failed program was:" >&5
14289   cat conftest.$ac_ext >&5
14290   rm -rf conftest*
14291   glibcpp_cv_func__floorf_use=no
14292 fi
14293 rm -f conftest*
14294       ac_ext=c
14295 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14296 ac_cpp='$CPP $CPPFLAGS'
14297 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14298 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14299 cross_compiling=$ac_cv_prog_cc_cross
14300
14301
14302 fi
14303
14304   fi
14305   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
14306   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
14307     for ac_func in _floorf
14308 do
14309 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14310 echo "configure:14311: checking for $ac_func" >&5
14311 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14312   echo $ac_n "(cached) $ac_c" 1>&6
14313 else
14314   cat > conftest.$ac_ext <<EOF
14315 #line 14316 "configure"
14316 #include "confdefs.h"
14317 /* System header to define __stub macros and hopefully few prototypes,
14318     which can conflict with char $ac_func(); below.  */
14319 #include <assert.h>
14320 /* Override any gcc2 internal prototype to avoid an error.  */
14321 /* We use char because int might match the return type of a gcc2
14322     builtin and then its argument prototype would still apply.  */
14323 char $ac_func();
14324
14325 int main() {
14326
14327 /* The GNU C library defines this for functions which it implements
14328     to always fail with ENOSYS.  Some functions are actually named
14329     something starting with __ and the normal name is an alias.  */
14330 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14331 choke me
14332 #else
14333 $ac_func();
14334 #endif
14335
14336 ; return 0; }
14337 EOF
14338 if { (eval echo configure:14339: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14339   rm -rf conftest*
14340   eval "ac_cv_func_$ac_func=yes"
14341 else
14342   echo "configure: failed program was:" >&5
14343   cat conftest.$ac_ext >&5
14344   rm -rf conftest*
14345   eval "ac_cv_func_$ac_func=no"
14346 fi
14347 rm -f conftest*
14348 fi
14349
14350 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14351   echo "$ac_t""yes" 1>&6
14352     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14353   cat >> confdefs.h <<EOF
14354 #define $ac_tr_func 1
14355 EOF
14356
14357 else
14358   echo "$ac_t""no" 1>&6
14359 fi
14360 done
14361
14362   fi
14363
14364
14365   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
14366 echo "configure:14367: checking for _fmodf declaration" >&5
14367   if test x${glibcpp_cv_func__fmodf_use+set} != xset; then
14368     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
14369   echo $ac_n "(cached) $ac_c" 1>&6
14370 else
14371
14372
14373       ac_ext=C
14374 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14375 ac_cpp='$CXXCPP $CPPFLAGS'
14376 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14377 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14378 cross_compiling=$ac_cv_prog_cxx_cross
14379
14380       cat > conftest.$ac_ext <<EOF
14381 #line 14382 "configure"
14382 #include "confdefs.h"
14383 #include <math.h>
14384 int main() {
14385  _fmodf(0, 0);
14386 ; return 0; }
14387 EOF
14388 if { (eval echo configure:14389: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14389   rm -rf conftest*
14390   glibcpp_cv_func__fmodf_use=yes
14391 else
14392   echo "configure: failed program was:" >&5
14393   cat conftest.$ac_ext >&5
14394   rm -rf conftest*
14395   glibcpp_cv_func__fmodf_use=no
14396 fi
14397 rm -f conftest*
14398       ac_ext=c
14399 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14400 ac_cpp='$CPP $CPPFLAGS'
14401 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14402 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14403 cross_compiling=$ac_cv_prog_cc_cross
14404
14405
14406 fi
14407
14408   fi
14409   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
14410   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
14411     for ac_func in _fmodf
14412 do
14413 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14414 echo "configure:14415: checking for $ac_func" >&5
14415 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14416   echo $ac_n "(cached) $ac_c" 1>&6
14417 else
14418   cat > conftest.$ac_ext <<EOF
14419 #line 14420 "configure"
14420 #include "confdefs.h"
14421 /* System header to define __stub macros and hopefully few prototypes,
14422     which can conflict with char $ac_func(); below.  */
14423 #include <assert.h>
14424 /* Override any gcc2 internal prototype to avoid an error.  */
14425 /* We use char because int might match the return type of a gcc2
14426     builtin and then its argument prototype would still apply.  */
14427 char $ac_func();
14428
14429 int main() {
14430
14431 /* The GNU C library defines this for functions which it implements
14432     to always fail with ENOSYS.  Some functions are actually named
14433     something starting with __ and the normal name is an alias.  */
14434 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14435 choke me
14436 #else
14437 $ac_func();
14438 #endif
14439
14440 ; return 0; }
14441 EOF
14442 if { (eval echo configure:14443: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14443   rm -rf conftest*
14444   eval "ac_cv_func_$ac_func=yes"
14445 else
14446   echo "configure: failed program was:" >&5
14447   cat conftest.$ac_ext >&5
14448   rm -rf conftest*
14449   eval "ac_cv_func_$ac_func=no"
14450 fi
14451 rm -f conftest*
14452 fi
14453
14454 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14455   echo "$ac_t""yes" 1>&6
14456     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14457   cat >> confdefs.h <<EOF
14458 #define $ac_tr_func 1
14459 EOF
14460
14461 else
14462   echo "$ac_t""no" 1>&6
14463 fi
14464 done
14465
14466   fi
14467
14468
14469   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
14470 echo "configure:14471: checking for _frexpf declaration" >&5
14471   if test x${glibcpp_cv_func__frexpf_use+set} != xset; then
14472     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
14473   echo $ac_n "(cached) $ac_c" 1>&6
14474 else
14475
14476
14477       ac_ext=C
14478 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14479 ac_cpp='$CXXCPP $CPPFLAGS'
14480 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14481 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14482 cross_compiling=$ac_cv_prog_cxx_cross
14483
14484       cat > conftest.$ac_ext <<EOF
14485 #line 14486 "configure"
14486 #include "confdefs.h"
14487 #include <math.h>
14488 int main() {
14489  _frexpf(0, 0);
14490 ; return 0; }
14491 EOF
14492 if { (eval echo configure:14493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14493   rm -rf conftest*
14494   glibcpp_cv_func__frexpf_use=yes
14495 else
14496   echo "configure: failed program was:" >&5
14497   cat conftest.$ac_ext >&5
14498   rm -rf conftest*
14499   glibcpp_cv_func__frexpf_use=no
14500 fi
14501 rm -f conftest*
14502       ac_ext=c
14503 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14504 ac_cpp='$CPP $CPPFLAGS'
14505 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14506 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14507 cross_compiling=$ac_cv_prog_cc_cross
14508
14509
14510 fi
14511
14512   fi
14513   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
14514   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
14515     for ac_func in _frexpf
14516 do
14517 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14518 echo "configure:14519: checking for $ac_func" >&5
14519 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14520   echo $ac_n "(cached) $ac_c" 1>&6
14521 else
14522   cat > conftest.$ac_ext <<EOF
14523 #line 14524 "configure"
14524 #include "confdefs.h"
14525 /* System header to define __stub macros and hopefully few prototypes,
14526     which can conflict with char $ac_func(); below.  */
14527 #include <assert.h>
14528 /* Override any gcc2 internal prototype to avoid an error.  */
14529 /* We use char because int might match the return type of a gcc2
14530     builtin and then its argument prototype would still apply.  */
14531 char $ac_func();
14532
14533 int main() {
14534
14535 /* The GNU C library defines this for functions which it implements
14536     to always fail with ENOSYS.  Some functions are actually named
14537     something starting with __ and the normal name is an alias.  */
14538 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14539 choke me
14540 #else
14541 $ac_func();
14542 #endif
14543
14544 ; return 0; }
14545 EOF
14546 if { (eval echo configure:14547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14547   rm -rf conftest*
14548   eval "ac_cv_func_$ac_func=yes"
14549 else
14550   echo "configure: failed program was:" >&5
14551   cat conftest.$ac_ext >&5
14552   rm -rf conftest*
14553   eval "ac_cv_func_$ac_func=no"
14554 fi
14555 rm -f conftest*
14556 fi
14557
14558 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14559   echo "$ac_t""yes" 1>&6
14560     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14561   cat >> confdefs.h <<EOF
14562 #define $ac_tr_func 1
14563 EOF
14564
14565 else
14566   echo "$ac_t""no" 1>&6
14567 fi
14568 done
14569
14570   fi
14571
14572
14573   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
14574 echo "configure:14575: checking for _ldexpf declaration" >&5
14575   if test x${glibcpp_cv_func__ldexpf_use+set} != xset; then
14576     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
14577   echo $ac_n "(cached) $ac_c" 1>&6
14578 else
14579
14580
14581       ac_ext=C
14582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14583 ac_cpp='$CXXCPP $CPPFLAGS'
14584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14586 cross_compiling=$ac_cv_prog_cxx_cross
14587
14588       cat > conftest.$ac_ext <<EOF
14589 #line 14590 "configure"
14590 #include "confdefs.h"
14591 #include <math.h>
14592 int main() {
14593  _ldexpf(0, 0);
14594 ; return 0; }
14595 EOF
14596 if { (eval echo configure:14597: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14597   rm -rf conftest*
14598   glibcpp_cv_func__ldexpf_use=yes
14599 else
14600   echo "configure: failed program was:" >&5
14601   cat conftest.$ac_ext >&5
14602   rm -rf conftest*
14603   glibcpp_cv_func__ldexpf_use=no
14604 fi
14605 rm -f conftest*
14606       ac_ext=c
14607 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14608 ac_cpp='$CPP $CPPFLAGS'
14609 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14610 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14611 cross_compiling=$ac_cv_prog_cc_cross
14612
14613
14614 fi
14615
14616   fi
14617   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
14618   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
14619     for ac_func in _ldexpf
14620 do
14621 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14622 echo "configure:14623: checking for $ac_func" >&5
14623 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14624   echo $ac_n "(cached) $ac_c" 1>&6
14625 else
14626   cat > conftest.$ac_ext <<EOF
14627 #line 14628 "configure"
14628 #include "confdefs.h"
14629 /* System header to define __stub macros and hopefully few prototypes,
14630     which can conflict with char $ac_func(); below.  */
14631 #include <assert.h>
14632 /* Override any gcc2 internal prototype to avoid an error.  */
14633 /* We use char because int might match the return type of a gcc2
14634     builtin and then its argument prototype would still apply.  */
14635 char $ac_func();
14636
14637 int main() {
14638
14639 /* The GNU C library defines this for functions which it implements
14640     to always fail with ENOSYS.  Some functions are actually named
14641     something starting with __ and the normal name is an alias.  */
14642 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14643 choke me
14644 #else
14645 $ac_func();
14646 #endif
14647
14648 ; return 0; }
14649 EOF
14650 if { (eval echo configure:14651: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14651   rm -rf conftest*
14652   eval "ac_cv_func_$ac_func=yes"
14653 else
14654   echo "configure: failed program was:" >&5
14655   cat conftest.$ac_ext >&5
14656   rm -rf conftest*
14657   eval "ac_cv_func_$ac_func=no"
14658 fi
14659 rm -f conftest*
14660 fi
14661
14662 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14663   echo "$ac_t""yes" 1>&6
14664     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14665   cat >> confdefs.h <<EOF
14666 #define $ac_tr_func 1
14667 EOF
14668
14669 else
14670   echo "$ac_t""no" 1>&6
14671 fi
14672 done
14673
14674   fi
14675
14676
14677   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
14678 echo "configure:14679: checking for _logf declaration" >&5
14679   if test x${glibcpp_cv_func__logf_use+set} != xset; then
14680     if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
14681   echo $ac_n "(cached) $ac_c" 1>&6
14682 else
14683
14684
14685       ac_ext=C
14686 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14687 ac_cpp='$CXXCPP $CPPFLAGS'
14688 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14689 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14690 cross_compiling=$ac_cv_prog_cxx_cross
14691
14692       cat > conftest.$ac_ext <<EOF
14693 #line 14694 "configure"
14694 #include "confdefs.h"
14695 #include <math.h>
14696 int main() {
14697  _logf(0);
14698 ; return 0; }
14699 EOF
14700 if { (eval echo configure:14701: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14701   rm -rf conftest*
14702   glibcpp_cv_func__logf_use=yes
14703 else
14704   echo "configure: failed program was:" >&5
14705   cat conftest.$ac_ext >&5
14706   rm -rf conftest*
14707   glibcpp_cv_func__logf_use=no
14708 fi
14709 rm -f conftest*
14710       ac_ext=c
14711 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14712 ac_cpp='$CPP $CPPFLAGS'
14713 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14714 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14715 cross_compiling=$ac_cv_prog_cc_cross
14716
14717
14718 fi
14719
14720   fi
14721   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
14722   if test x$glibcpp_cv_func__logf_use = x"yes"; then
14723     for ac_func in _logf
14724 do
14725 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14726 echo "configure:14727: checking for $ac_func" >&5
14727 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14728   echo $ac_n "(cached) $ac_c" 1>&6
14729 else
14730   cat > conftest.$ac_ext <<EOF
14731 #line 14732 "configure"
14732 #include "confdefs.h"
14733 /* System header to define __stub macros and hopefully few prototypes,
14734     which can conflict with char $ac_func(); below.  */
14735 #include <assert.h>
14736 /* Override any gcc2 internal prototype to avoid an error.  */
14737 /* We use char because int might match the return type of a gcc2
14738     builtin and then its argument prototype would still apply.  */
14739 char $ac_func();
14740
14741 int main() {
14742
14743 /* The GNU C library defines this for functions which it implements
14744     to always fail with ENOSYS.  Some functions are actually named
14745     something starting with __ and the normal name is an alias.  */
14746 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14747 choke me
14748 #else
14749 $ac_func();
14750 #endif
14751
14752 ; return 0; }
14753 EOF
14754 if { (eval echo configure:14755: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14755   rm -rf conftest*
14756   eval "ac_cv_func_$ac_func=yes"
14757 else
14758   echo "configure: failed program was:" >&5
14759   cat conftest.$ac_ext >&5
14760   rm -rf conftest*
14761   eval "ac_cv_func_$ac_func=no"
14762 fi
14763 rm -f conftest*
14764 fi
14765
14766 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14767   echo "$ac_t""yes" 1>&6
14768     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14769   cat >> confdefs.h <<EOF
14770 #define $ac_tr_func 1
14771 EOF
14772
14773 else
14774   echo "$ac_t""no" 1>&6
14775 fi
14776 done
14777
14778   fi
14779
14780
14781   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
14782 echo "configure:14783: checking for _log10f declaration" >&5
14783   if test x${glibcpp_cv_func__log10f_use+set} != xset; then
14784     if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
14785   echo $ac_n "(cached) $ac_c" 1>&6
14786 else
14787
14788
14789       ac_ext=C
14790 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14791 ac_cpp='$CXXCPP $CPPFLAGS'
14792 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14793 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14794 cross_compiling=$ac_cv_prog_cxx_cross
14795
14796       cat > conftest.$ac_ext <<EOF
14797 #line 14798 "configure"
14798 #include "confdefs.h"
14799 #include <math.h>
14800 int main() {
14801  _log10f(0);
14802 ; return 0; }
14803 EOF
14804 if { (eval echo configure:14805: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14805   rm -rf conftest*
14806   glibcpp_cv_func__log10f_use=yes
14807 else
14808   echo "configure: failed program was:" >&5
14809   cat conftest.$ac_ext >&5
14810   rm -rf conftest*
14811   glibcpp_cv_func__log10f_use=no
14812 fi
14813 rm -f conftest*
14814       ac_ext=c
14815 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14816 ac_cpp='$CPP $CPPFLAGS'
14817 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14818 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14819 cross_compiling=$ac_cv_prog_cc_cross
14820
14821
14822 fi
14823
14824   fi
14825   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
14826   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
14827     for ac_func in _log10f
14828 do
14829 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14830 echo "configure:14831: checking for $ac_func" >&5
14831 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14832   echo $ac_n "(cached) $ac_c" 1>&6
14833 else
14834   cat > conftest.$ac_ext <<EOF
14835 #line 14836 "configure"
14836 #include "confdefs.h"
14837 /* System header to define __stub macros and hopefully few prototypes,
14838     which can conflict with char $ac_func(); below.  */
14839 #include <assert.h>
14840 /* Override any gcc2 internal prototype to avoid an error.  */
14841 /* We use char because int might match the return type of a gcc2
14842     builtin and then its argument prototype would still apply.  */
14843 char $ac_func();
14844
14845 int main() {
14846
14847 /* The GNU C library defines this for functions which it implements
14848     to always fail with ENOSYS.  Some functions are actually named
14849     something starting with __ and the normal name is an alias.  */
14850 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14851 choke me
14852 #else
14853 $ac_func();
14854 #endif
14855
14856 ; return 0; }
14857 EOF
14858 if { (eval echo configure:14859: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14859   rm -rf conftest*
14860   eval "ac_cv_func_$ac_func=yes"
14861 else
14862   echo "configure: failed program was:" >&5
14863   cat conftest.$ac_ext >&5
14864   rm -rf conftest*
14865   eval "ac_cv_func_$ac_func=no"
14866 fi
14867 rm -f conftest*
14868 fi
14869
14870 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14871   echo "$ac_t""yes" 1>&6
14872     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14873   cat >> confdefs.h <<EOF
14874 #define $ac_tr_func 1
14875 EOF
14876
14877 else
14878   echo "$ac_t""no" 1>&6
14879 fi
14880 done
14881
14882   fi
14883
14884
14885   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
14886 echo "configure:14887: checking for _modff declaration" >&5
14887   if test x${glibcpp_cv_func__modff_use+set} != xset; then
14888     if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
14889   echo $ac_n "(cached) $ac_c" 1>&6
14890 else
14891
14892
14893       ac_ext=C
14894 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14895 ac_cpp='$CXXCPP $CPPFLAGS'
14896 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14897 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14898 cross_compiling=$ac_cv_prog_cxx_cross
14899
14900       cat > conftest.$ac_ext <<EOF
14901 #line 14902 "configure"
14902 #include "confdefs.h"
14903 #include <math.h>
14904 int main() {
14905  _modff(0, 0);
14906 ; return 0; }
14907 EOF
14908 if { (eval echo configure:14909: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14909   rm -rf conftest*
14910   glibcpp_cv_func__modff_use=yes
14911 else
14912   echo "configure: failed program was:" >&5
14913   cat conftest.$ac_ext >&5
14914   rm -rf conftest*
14915   glibcpp_cv_func__modff_use=no
14916 fi
14917 rm -f conftest*
14918       ac_ext=c
14919 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14920 ac_cpp='$CPP $CPPFLAGS'
14921 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14922 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14923 cross_compiling=$ac_cv_prog_cc_cross
14924
14925
14926 fi
14927
14928   fi
14929   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
14930   if test x$glibcpp_cv_func__modff_use = x"yes"; then
14931     for ac_func in _modff
14932 do
14933 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14934 echo "configure:14935: checking for $ac_func" >&5
14935 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14936   echo $ac_n "(cached) $ac_c" 1>&6
14937 else
14938   cat > conftest.$ac_ext <<EOF
14939 #line 14940 "configure"
14940 #include "confdefs.h"
14941 /* System header to define __stub macros and hopefully few prototypes,
14942     which can conflict with char $ac_func(); below.  */
14943 #include <assert.h>
14944 /* Override any gcc2 internal prototype to avoid an error.  */
14945 /* We use char because int might match the return type of a gcc2
14946     builtin and then its argument prototype would still apply.  */
14947 char $ac_func();
14948
14949 int main() {
14950
14951 /* The GNU C library defines this for functions which it implements
14952     to always fail with ENOSYS.  Some functions are actually named
14953     something starting with __ and the normal name is an alias.  */
14954 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14955 choke me
14956 #else
14957 $ac_func();
14958 #endif
14959
14960 ; return 0; }
14961 EOF
14962 if { (eval echo configure:14963: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14963   rm -rf conftest*
14964   eval "ac_cv_func_$ac_func=yes"
14965 else
14966   echo "configure: failed program was:" >&5
14967   cat conftest.$ac_ext >&5
14968   rm -rf conftest*
14969   eval "ac_cv_func_$ac_func=no"
14970 fi
14971 rm -f conftest*
14972 fi
14973
14974 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14975   echo "$ac_t""yes" 1>&6
14976     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14977   cat >> confdefs.h <<EOF
14978 #define $ac_tr_func 1
14979 EOF
14980
14981 else
14982   echo "$ac_t""no" 1>&6
14983 fi
14984 done
14985
14986   fi
14987
14988
14989   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
14990 echo "configure:14991: checking for _powf declaration" >&5
14991   if test x${glibcpp_cv_func__powf_use+set} != xset; then
14992     if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
14993   echo $ac_n "(cached) $ac_c" 1>&6
14994 else
14995
14996
14997       ac_ext=C
14998 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14999 ac_cpp='$CXXCPP $CPPFLAGS'
15000 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15001 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15002 cross_compiling=$ac_cv_prog_cxx_cross
15003
15004       cat > conftest.$ac_ext <<EOF
15005 #line 15006 "configure"
15006 #include "confdefs.h"
15007 #include <math.h>
15008 int main() {
15009  _powf(0, 0);
15010 ; return 0; }
15011 EOF
15012 if { (eval echo configure:15013: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15013   rm -rf conftest*
15014   glibcpp_cv_func__powf_use=yes
15015 else
15016   echo "configure: failed program was:" >&5
15017   cat conftest.$ac_ext >&5
15018   rm -rf conftest*
15019   glibcpp_cv_func__powf_use=no
15020 fi
15021 rm -f conftest*
15022       ac_ext=c
15023 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15024 ac_cpp='$CPP $CPPFLAGS'
15025 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15026 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15027 cross_compiling=$ac_cv_prog_cc_cross
15028
15029
15030 fi
15031
15032   fi
15033   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
15034   if test x$glibcpp_cv_func__powf_use = x"yes"; then
15035     for ac_func in _powf
15036 do
15037 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15038 echo "configure:15039: checking for $ac_func" >&5
15039 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15040   echo $ac_n "(cached) $ac_c" 1>&6
15041 else
15042   cat > conftest.$ac_ext <<EOF
15043 #line 15044 "configure"
15044 #include "confdefs.h"
15045 /* System header to define __stub macros and hopefully few prototypes,
15046     which can conflict with char $ac_func(); below.  */
15047 #include <assert.h>
15048 /* Override any gcc2 internal prototype to avoid an error.  */
15049 /* We use char because int might match the return type of a gcc2
15050     builtin and then its argument prototype would still apply.  */
15051 char $ac_func();
15052
15053 int main() {
15054
15055 /* The GNU C library defines this for functions which it implements
15056     to always fail with ENOSYS.  Some functions are actually named
15057     something starting with __ and the normal name is an alias.  */
15058 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15059 choke me
15060 #else
15061 $ac_func();
15062 #endif
15063
15064 ; return 0; }
15065 EOF
15066 if { (eval echo configure:15067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15067   rm -rf conftest*
15068   eval "ac_cv_func_$ac_func=yes"
15069 else
15070   echo "configure: failed program was:" >&5
15071   cat conftest.$ac_ext >&5
15072   rm -rf conftest*
15073   eval "ac_cv_func_$ac_func=no"
15074 fi
15075 rm -f conftest*
15076 fi
15077
15078 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15079   echo "$ac_t""yes" 1>&6
15080     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15081   cat >> confdefs.h <<EOF
15082 #define $ac_tr_func 1
15083 EOF
15084
15085 else
15086   echo "$ac_t""no" 1>&6
15087 fi
15088 done
15089
15090   fi
15091
15092
15093   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
15094 echo "configure:15095: checking for _sinf declaration" >&5
15095   if test x${glibcpp_cv_func__sinf_use+set} != xset; then
15096     if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
15097   echo $ac_n "(cached) $ac_c" 1>&6
15098 else
15099
15100
15101       ac_ext=C
15102 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15103 ac_cpp='$CXXCPP $CPPFLAGS'
15104 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15105 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15106 cross_compiling=$ac_cv_prog_cxx_cross
15107
15108       cat > conftest.$ac_ext <<EOF
15109 #line 15110 "configure"
15110 #include "confdefs.h"
15111 #include <math.h>
15112 int main() {
15113  _sinf(0);
15114 ; return 0; }
15115 EOF
15116 if { (eval echo configure:15117: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15117   rm -rf conftest*
15118   glibcpp_cv_func__sinf_use=yes
15119 else
15120   echo "configure: failed program was:" >&5
15121   cat conftest.$ac_ext >&5
15122   rm -rf conftest*
15123   glibcpp_cv_func__sinf_use=no
15124 fi
15125 rm -f conftest*
15126       ac_ext=c
15127 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15128 ac_cpp='$CPP $CPPFLAGS'
15129 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15130 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15131 cross_compiling=$ac_cv_prog_cc_cross
15132
15133
15134 fi
15135
15136   fi
15137   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
15138   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
15139     for ac_func in _sinf
15140 do
15141 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15142 echo "configure:15143: checking for $ac_func" >&5
15143 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15144   echo $ac_n "(cached) $ac_c" 1>&6
15145 else
15146   cat > conftest.$ac_ext <<EOF
15147 #line 15148 "configure"
15148 #include "confdefs.h"
15149 /* System header to define __stub macros and hopefully few prototypes,
15150     which can conflict with char $ac_func(); below.  */
15151 #include <assert.h>
15152 /* Override any gcc2 internal prototype to avoid an error.  */
15153 /* We use char because int might match the return type of a gcc2
15154     builtin and then its argument prototype would still apply.  */
15155 char $ac_func();
15156
15157 int main() {
15158
15159 /* The GNU C library defines this for functions which it implements
15160     to always fail with ENOSYS.  Some functions are actually named
15161     something starting with __ and the normal name is an alias.  */
15162 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15163 choke me
15164 #else
15165 $ac_func();
15166 #endif
15167
15168 ; return 0; }
15169 EOF
15170 if { (eval echo configure:15171: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15171   rm -rf conftest*
15172   eval "ac_cv_func_$ac_func=yes"
15173 else
15174   echo "configure: failed program was:" >&5
15175   cat conftest.$ac_ext >&5
15176   rm -rf conftest*
15177   eval "ac_cv_func_$ac_func=no"
15178 fi
15179 rm -f conftest*
15180 fi
15181
15182 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15183   echo "$ac_t""yes" 1>&6
15184     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15185   cat >> confdefs.h <<EOF
15186 #define $ac_tr_func 1
15187 EOF
15188
15189 else
15190   echo "$ac_t""no" 1>&6
15191 fi
15192 done
15193
15194   fi
15195
15196
15197   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
15198 echo "configure:15199: checking for _sinhf declaration" >&5
15199   if test x${glibcpp_cv_func__sinhf_use+set} != xset; then
15200     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
15201   echo $ac_n "(cached) $ac_c" 1>&6
15202 else
15203
15204
15205       ac_ext=C
15206 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15207 ac_cpp='$CXXCPP $CPPFLAGS'
15208 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15209 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15210 cross_compiling=$ac_cv_prog_cxx_cross
15211
15212       cat > conftest.$ac_ext <<EOF
15213 #line 15214 "configure"
15214 #include "confdefs.h"
15215 #include <math.h>
15216 int main() {
15217  _sinhf(0);
15218 ; return 0; }
15219 EOF
15220 if { (eval echo configure:15221: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15221   rm -rf conftest*
15222   glibcpp_cv_func__sinhf_use=yes
15223 else
15224   echo "configure: failed program was:" >&5
15225   cat conftest.$ac_ext >&5
15226   rm -rf conftest*
15227   glibcpp_cv_func__sinhf_use=no
15228 fi
15229 rm -f conftest*
15230       ac_ext=c
15231 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15232 ac_cpp='$CPP $CPPFLAGS'
15233 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15234 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15235 cross_compiling=$ac_cv_prog_cc_cross
15236
15237
15238 fi
15239
15240   fi
15241   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
15242   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
15243     for ac_func in _sinhf
15244 do
15245 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15246 echo "configure:15247: checking for $ac_func" >&5
15247 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15248   echo $ac_n "(cached) $ac_c" 1>&6
15249 else
15250   cat > conftest.$ac_ext <<EOF
15251 #line 15252 "configure"
15252 #include "confdefs.h"
15253 /* System header to define __stub macros and hopefully few prototypes,
15254     which can conflict with char $ac_func(); below.  */
15255 #include <assert.h>
15256 /* Override any gcc2 internal prototype to avoid an error.  */
15257 /* We use char because int might match the return type of a gcc2
15258     builtin and then its argument prototype would still apply.  */
15259 char $ac_func();
15260
15261 int main() {
15262
15263 /* The GNU C library defines this for functions which it implements
15264     to always fail with ENOSYS.  Some functions are actually named
15265     something starting with __ and the normal name is an alias.  */
15266 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15267 choke me
15268 #else
15269 $ac_func();
15270 #endif
15271
15272 ; return 0; }
15273 EOF
15274 if { (eval echo configure:15275: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15275   rm -rf conftest*
15276   eval "ac_cv_func_$ac_func=yes"
15277 else
15278   echo "configure: failed program was:" >&5
15279   cat conftest.$ac_ext >&5
15280   rm -rf conftest*
15281   eval "ac_cv_func_$ac_func=no"
15282 fi
15283 rm -f conftest*
15284 fi
15285
15286 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15287   echo "$ac_t""yes" 1>&6
15288     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15289   cat >> confdefs.h <<EOF
15290 #define $ac_tr_func 1
15291 EOF
15292
15293 else
15294   echo "$ac_t""no" 1>&6
15295 fi
15296 done
15297
15298   fi
15299
15300
15301   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
15302 echo "configure:15303: checking for _sqrtf declaration" >&5
15303   if test x${glibcpp_cv_func__sqrtf_use+set} != xset; then
15304     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
15305   echo $ac_n "(cached) $ac_c" 1>&6
15306 else
15307
15308
15309       ac_ext=C
15310 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15311 ac_cpp='$CXXCPP $CPPFLAGS'
15312 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15313 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15314 cross_compiling=$ac_cv_prog_cxx_cross
15315
15316       cat > conftest.$ac_ext <<EOF
15317 #line 15318 "configure"
15318 #include "confdefs.h"
15319 #include <math.h>
15320 int main() {
15321  _sqrtf(0);
15322 ; return 0; }
15323 EOF
15324 if { (eval echo configure:15325: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15325   rm -rf conftest*
15326   glibcpp_cv_func__sqrtf_use=yes
15327 else
15328   echo "configure: failed program was:" >&5
15329   cat conftest.$ac_ext >&5
15330   rm -rf conftest*
15331   glibcpp_cv_func__sqrtf_use=no
15332 fi
15333 rm -f conftest*
15334       ac_ext=c
15335 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15336 ac_cpp='$CPP $CPPFLAGS'
15337 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15338 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15339 cross_compiling=$ac_cv_prog_cc_cross
15340
15341
15342 fi
15343
15344   fi
15345   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
15346   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
15347     for ac_func in _sqrtf
15348 do
15349 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15350 echo "configure:15351: checking for $ac_func" >&5
15351 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15352   echo $ac_n "(cached) $ac_c" 1>&6
15353 else
15354   cat > conftest.$ac_ext <<EOF
15355 #line 15356 "configure"
15356 #include "confdefs.h"
15357 /* System header to define __stub macros and hopefully few prototypes,
15358     which can conflict with char $ac_func(); below.  */
15359 #include <assert.h>
15360 /* Override any gcc2 internal prototype to avoid an error.  */
15361 /* We use char because int might match the return type of a gcc2
15362     builtin and then its argument prototype would still apply.  */
15363 char $ac_func();
15364
15365 int main() {
15366
15367 /* The GNU C library defines this for functions which it implements
15368     to always fail with ENOSYS.  Some functions are actually named
15369     something starting with __ and the normal name is an alias.  */
15370 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15371 choke me
15372 #else
15373 $ac_func();
15374 #endif
15375
15376 ; return 0; }
15377 EOF
15378 if { (eval echo configure:15379: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15379   rm -rf conftest*
15380   eval "ac_cv_func_$ac_func=yes"
15381 else
15382   echo "configure: failed program was:" >&5
15383   cat conftest.$ac_ext >&5
15384   rm -rf conftest*
15385   eval "ac_cv_func_$ac_func=no"
15386 fi
15387 rm -f conftest*
15388 fi
15389
15390 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15391   echo "$ac_t""yes" 1>&6
15392     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15393   cat >> confdefs.h <<EOF
15394 #define $ac_tr_func 1
15395 EOF
15396
15397 else
15398   echo "$ac_t""no" 1>&6
15399 fi
15400 done
15401
15402   fi
15403
15404
15405   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
15406 echo "configure:15407: checking for _tanf declaration" >&5
15407   if test x${glibcpp_cv_func__tanf_use+set} != xset; then
15408     if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
15409   echo $ac_n "(cached) $ac_c" 1>&6
15410 else
15411
15412
15413       ac_ext=C
15414 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15415 ac_cpp='$CXXCPP $CPPFLAGS'
15416 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15417 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15418 cross_compiling=$ac_cv_prog_cxx_cross
15419
15420       cat > conftest.$ac_ext <<EOF
15421 #line 15422 "configure"
15422 #include "confdefs.h"
15423 #include <math.h>
15424 int main() {
15425  _tanf(0);
15426 ; return 0; }
15427 EOF
15428 if { (eval echo configure:15429: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15429   rm -rf conftest*
15430   glibcpp_cv_func__tanf_use=yes
15431 else
15432   echo "configure: failed program was:" >&5
15433   cat conftest.$ac_ext >&5
15434   rm -rf conftest*
15435   glibcpp_cv_func__tanf_use=no
15436 fi
15437 rm -f conftest*
15438       ac_ext=c
15439 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15440 ac_cpp='$CPP $CPPFLAGS'
15441 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15442 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15443 cross_compiling=$ac_cv_prog_cc_cross
15444
15445
15446 fi
15447
15448   fi
15449   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
15450   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
15451     for ac_func in _tanf
15452 do
15453 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15454 echo "configure:15455: checking for $ac_func" >&5
15455 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15456   echo $ac_n "(cached) $ac_c" 1>&6
15457 else
15458   cat > conftest.$ac_ext <<EOF
15459 #line 15460 "configure"
15460 #include "confdefs.h"
15461 /* System header to define __stub macros and hopefully few prototypes,
15462     which can conflict with char $ac_func(); below.  */
15463 #include <assert.h>
15464 /* Override any gcc2 internal prototype to avoid an error.  */
15465 /* We use char because int might match the return type of a gcc2
15466     builtin and then its argument prototype would still apply.  */
15467 char $ac_func();
15468
15469 int main() {
15470
15471 /* The GNU C library defines this for functions which it implements
15472     to always fail with ENOSYS.  Some functions are actually named
15473     something starting with __ and the normal name is an alias.  */
15474 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15475 choke me
15476 #else
15477 $ac_func();
15478 #endif
15479
15480 ; return 0; }
15481 EOF
15482 if { (eval echo configure:15483: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15483   rm -rf conftest*
15484   eval "ac_cv_func_$ac_func=yes"
15485 else
15486   echo "configure: failed program was:" >&5
15487   cat conftest.$ac_ext >&5
15488   rm -rf conftest*
15489   eval "ac_cv_func_$ac_func=no"
15490 fi
15491 rm -f conftest*
15492 fi
15493
15494 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15495   echo "$ac_t""yes" 1>&6
15496     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15497   cat >> confdefs.h <<EOF
15498 #define $ac_tr_func 1
15499 EOF
15500
15501 else
15502   echo "$ac_t""no" 1>&6
15503 fi
15504 done
15505
15506   fi
15507
15508
15509   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
15510 echo "configure:15511: checking for _tanhf declaration" >&5
15511   if test x${glibcpp_cv_func__tanhf_use+set} != xset; then
15512     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
15513   echo $ac_n "(cached) $ac_c" 1>&6
15514 else
15515
15516
15517       ac_ext=C
15518 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15519 ac_cpp='$CXXCPP $CPPFLAGS'
15520 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15521 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15522 cross_compiling=$ac_cv_prog_cxx_cross
15523
15524       cat > conftest.$ac_ext <<EOF
15525 #line 15526 "configure"
15526 #include "confdefs.h"
15527 #include <math.h>
15528 int main() {
15529  _tanhf(0);
15530 ; return 0; }
15531 EOF
15532 if { (eval echo configure:15533: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15533   rm -rf conftest*
15534   glibcpp_cv_func__tanhf_use=yes
15535 else
15536   echo "configure: failed program was:" >&5
15537   cat conftest.$ac_ext >&5
15538   rm -rf conftest*
15539   glibcpp_cv_func__tanhf_use=no
15540 fi
15541 rm -f conftest*
15542       ac_ext=c
15543 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15544 ac_cpp='$CPP $CPPFLAGS'
15545 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15546 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15547 cross_compiling=$ac_cv_prog_cc_cross
15548
15549
15550 fi
15551
15552   fi
15553   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
15554   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
15555     for ac_func in _tanhf
15556 do
15557 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15558 echo "configure:15559: checking for $ac_func" >&5
15559 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15560   echo $ac_n "(cached) $ac_c" 1>&6
15561 else
15562   cat > conftest.$ac_ext <<EOF
15563 #line 15564 "configure"
15564 #include "confdefs.h"
15565 /* System header to define __stub macros and hopefully few prototypes,
15566     which can conflict with char $ac_func(); below.  */
15567 #include <assert.h>
15568 /* Override any gcc2 internal prototype to avoid an error.  */
15569 /* We use char because int might match the return type of a gcc2
15570     builtin and then its argument prototype would still apply.  */
15571 char $ac_func();
15572
15573 int main() {
15574
15575 /* The GNU C library defines this for functions which it implements
15576     to always fail with ENOSYS.  Some functions are actually named
15577     something starting with __ and the normal name is an alias.  */
15578 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15579 choke me
15580 #else
15581 $ac_func();
15582 #endif
15583
15584 ; return 0; }
15585 EOF
15586 if { (eval echo configure:15587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15587   rm -rf conftest*
15588   eval "ac_cv_func_$ac_func=yes"
15589 else
15590   echo "configure: failed program was:" >&5
15591   cat conftest.$ac_ext >&5
15592   rm -rf conftest*
15593   eval "ac_cv_func_$ac_func=no"
15594 fi
15595 rm -f conftest*
15596 fi
15597
15598 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15599   echo "$ac_t""yes" 1>&6
15600     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15601   cat >> confdefs.h <<EOF
15602 #define $ac_tr_func 1
15603 EOF
15604
15605 else
15606   echo "$ac_t""no" 1>&6
15607 fi
15608 done
15609
15610   fi
15611
15612
15613   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
15614 echo "configure:15615: checking for _sincosf declaration" >&5
15615   if test x${glibcpp_cv_func__sincosf_use+set} != xset; then
15616     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
15617   echo $ac_n "(cached) $ac_c" 1>&6
15618 else
15619
15620
15621       ac_ext=C
15622 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15623 ac_cpp='$CXXCPP $CPPFLAGS'
15624 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15625 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15626 cross_compiling=$ac_cv_prog_cxx_cross
15627
15628       cat > conftest.$ac_ext <<EOF
15629 #line 15630 "configure"
15630 #include "confdefs.h"
15631 #include <math.h>
15632 int main() {
15633  _sincosf(0, 0, 0);
15634 ; return 0; }
15635 EOF
15636 if { (eval echo configure:15637: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15637   rm -rf conftest*
15638   glibcpp_cv_func__sincosf_use=yes
15639 else
15640   echo "configure: failed program was:" >&5
15641   cat conftest.$ac_ext >&5
15642   rm -rf conftest*
15643   glibcpp_cv_func__sincosf_use=no
15644 fi
15645 rm -f conftest*
15646       ac_ext=c
15647 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15648 ac_cpp='$CPP $CPPFLAGS'
15649 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15650 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15651 cross_compiling=$ac_cv_prog_cc_cross
15652
15653
15654 fi
15655
15656   fi
15657   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
15658   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
15659     for ac_func in _sincosf
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 _finitef declaration""... $ac_c" 1>&6
15718 echo "configure:15719: checking for _finitef declaration" >&5
15719   if test x${glibcpp_cv_func__finitef_use+set} != xset; then
15720     if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
15721   echo $ac_n "(cached) $ac_c" 1>&6
15722 else
15723
15724
15725       ac_ext=C
15726 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15727 ac_cpp='$CXXCPP $CPPFLAGS'
15728 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15729 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15730 cross_compiling=$ac_cv_prog_cxx_cross
15731
15732       cat > conftest.$ac_ext <<EOF
15733 #line 15734 "configure"
15734 #include "confdefs.h"
15735 #include <math.h>
15736 int main() {
15737  _finitef(0);
15738 ; return 0; }
15739 EOF
15740 if { (eval echo configure:15741: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15741   rm -rf conftest*
15742   glibcpp_cv_func__finitef_use=yes
15743 else
15744   echo "configure: failed program was:" >&5
15745   cat conftest.$ac_ext >&5
15746   rm -rf conftest*
15747   glibcpp_cv_func__finitef_use=no
15748 fi
15749 rm -f conftest*
15750       ac_ext=c
15751 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15752 ac_cpp='$CPP $CPPFLAGS'
15753 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15754 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15755 cross_compiling=$ac_cv_prog_cc_cross
15756
15757
15758 fi
15759
15760   fi
15761   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
15762   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
15763     for ac_func in _finitef
15764 do
15765 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15766 echo "configure:15767: checking for $ac_func" >&5
15767 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15768   echo $ac_n "(cached) $ac_c" 1>&6
15769 else
15770   cat > conftest.$ac_ext <<EOF
15771 #line 15772 "configure"
15772 #include "confdefs.h"
15773 /* System header to define __stub macros and hopefully few prototypes,
15774     which can conflict with char $ac_func(); below.  */
15775 #include <assert.h>
15776 /* Override any gcc2 internal prototype to avoid an error.  */
15777 /* We use char because int might match the return type of a gcc2
15778     builtin and then its argument prototype would still apply.  */
15779 char $ac_func();
15780
15781 int main() {
15782
15783 /* The GNU C library defines this for functions which it implements
15784     to always fail with ENOSYS.  Some functions are actually named
15785     something starting with __ and the normal name is an alias.  */
15786 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15787 choke me
15788 #else
15789 $ac_func();
15790 #endif
15791
15792 ; return 0; }
15793 EOF
15794 if { (eval echo configure:15795: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15795   rm -rf conftest*
15796   eval "ac_cv_func_$ac_func=yes"
15797 else
15798   echo "configure: failed program was:" >&5
15799   cat conftest.$ac_ext >&5
15800   rm -rf conftest*
15801   eval "ac_cv_func_$ac_func=no"
15802 fi
15803 rm -f conftest*
15804 fi
15805
15806 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15807   echo "$ac_t""yes" 1>&6
15808     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15809   cat >> confdefs.h <<EOF
15810 #define $ac_tr_func 1
15811 EOF
15812
15813 else
15814   echo "$ac_t""no" 1>&6
15815 fi
15816 done
15817
15818   fi
15819
15820
15821
15822   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
15823 echo "configure:15824: checking for _isnanl declaration" >&5
15824   if test x${glibcpp_cv_func__isnanl_use+set} != xset; then
15825     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
15826   echo $ac_n "(cached) $ac_c" 1>&6
15827 else
15828
15829
15830       ac_ext=C
15831 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15832 ac_cpp='$CXXCPP $CPPFLAGS'
15833 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15834 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15835 cross_compiling=$ac_cv_prog_cxx_cross
15836
15837       cat > conftest.$ac_ext <<EOF
15838 #line 15839 "configure"
15839 #include "confdefs.h"
15840 #include <math.h>
15841 int main() {
15842  _isnanl(0);
15843 ; return 0; }
15844 EOF
15845 if { (eval echo configure:15846: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15846   rm -rf conftest*
15847   glibcpp_cv_func__isnanl_use=yes
15848 else
15849   echo "configure: failed program was:" >&5
15850   cat conftest.$ac_ext >&5
15851   rm -rf conftest*
15852   glibcpp_cv_func__isnanl_use=no
15853 fi
15854 rm -f conftest*
15855       ac_ext=c
15856 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15857 ac_cpp='$CPP $CPPFLAGS'
15858 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15859 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15860 cross_compiling=$ac_cv_prog_cc_cross
15861
15862
15863 fi
15864
15865   fi
15866   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
15867   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
15868     for ac_func in _isnanl
15869 do
15870 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15871 echo "configure:15872: checking for $ac_func" >&5
15872 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15873   echo $ac_n "(cached) $ac_c" 1>&6
15874 else
15875   cat > conftest.$ac_ext <<EOF
15876 #line 15877 "configure"
15877 #include "confdefs.h"
15878 /* System header to define __stub macros and hopefully few prototypes,
15879     which can conflict with char $ac_func(); below.  */
15880 #include <assert.h>
15881 /* Override any gcc2 internal prototype to avoid an error.  */
15882 /* We use char because int might match the return type of a gcc2
15883     builtin and then its argument prototype would still apply.  */
15884 char $ac_func();
15885
15886 int main() {
15887
15888 /* The GNU C library defines this for functions which it implements
15889     to always fail with ENOSYS.  Some functions are actually named
15890     something starting with __ and the normal name is an alias.  */
15891 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15892 choke me
15893 #else
15894 $ac_func();
15895 #endif
15896
15897 ; return 0; }
15898 EOF
15899 if { (eval echo configure:15900: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15900   rm -rf conftest*
15901   eval "ac_cv_func_$ac_func=yes"
15902 else
15903   echo "configure: failed program was:" >&5
15904   cat conftest.$ac_ext >&5
15905   rm -rf conftest*
15906   eval "ac_cv_func_$ac_func=no"
15907 fi
15908 rm -f conftest*
15909 fi
15910
15911 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15912   echo "$ac_t""yes" 1>&6
15913     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15914   cat >> confdefs.h <<EOF
15915 #define $ac_tr_func 1
15916 EOF
15917
15918 else
15919   echo "$ac_t""no" 1>&6
15920 fi
15921 done
15922
15923   fi
15924
15925
15926   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
15927 echo "configure:15928: checking for _isinfl declaration" >&5
15928   if test x${glibcpp_cv_func__isinfl_use+set} != xset; then
15929     if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
15930   echo $ac_n "(cached) $ac_c" 1>&6
15931 else
15932
15933
15934       ac_ext=C
15935 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15936 ac_cpp='$CXXCPP $CPPFLAGS'
15937 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15938 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15939 cross_compiling=$ac_cv_prog_cxx_cross
15940
15941       cat > conftest.$ac_ext <<EOF
15942 #line 15943 "configure"
15943 #include "confdefs.h"
15944 #include <math.h>
15945 int main() {
15946  _isinfl(0);
15947 ; return 0; }
15948 EOF
15949 if { (eval echo configure:15950: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15950   rm -rf conftest*
15951   glibcpp_cv_func__isinfl_use=yes
15952 else
15953   echo "configure: failed program was:" >&5
15954   cat conftest.$ac_ext >&5
15955   rm -rf conftest*
15956   glibcpp_cv_func__isinfl_use=no
15957 fi
15958 rm -f conftest*
15959       ac_ext=c
15960 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15961 ac_cpp='$CPP $CPPFLAGS'
15962 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15963 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15964 cross_compiling=$ac_cv_prog_cc_cross
15965
15966
15967 fi
15968
15969   fi
15970   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
15971   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
15972     for ac_func in _isinfl
15973 do
15974 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15975 echo "configure:15976: checking for $ac_func" >&5
15976 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15977   echo $ac_n "(cached) $ac_c" 1>&6
15978 else
15979   cat > conftest.$ac_ext <<EOF
15980 #line 15981 "configure"
15981 #include "confdefs.h"
15982 /* System header to define __stub macros and hopefully few prototypes,
15983     which can conflict with char $ac_func(); below.  */
15984 #include <assert.h>
15985 /* Override any gcc2 internal prototype to avoid an error.  */
15986 /* We use char because int might match the return type of a gcc2
15987     builtin and then its argument prototype would still apply.  */
15988 char $ac_func();
15989
15990 int main() {
15991
15992 /* The GNU C library defines this for functions which it implements
15993     to always fail with ENOSYS.  Some functions are actually named
15994     something starting with __ and the normal name is an alias.  */
15995 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15996 choke me
15997 #else
15998 $ac_func();
15999 #endif
16000
16001 ; return 0; }
16002 EOF
16003 if { (eval echo configure:16004: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16004   rm -rf conftest*
16005   eval "ac_cv_func_$ac_func=yes"
16006 else
16007   echo "configure: failed program was:" >&5
16008   cat conftest.$ac_ext >&5
16009   rm -rf conftest*
16010   eval "ac_cv_func_$ac_func=no"
16011 fi
16012 rm -f conftest*
16013 fi
16014
16015 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16016   echo "$ac_t""yes" 1>&6
16017     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16018   cat >> confdefs.h <<EOF
16019 #define $ac_tr_func 1
16020 EOF
16021
16022 else
16023   echo "$ac_t""no" 1>&6
16024 fi
16025 done
16026
16027   fi
16028
16029
16030   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
16031 echo "configure:16032: checking for _copysignl declaration" >&5
16032   if test x${glibcpp_cv_func__copysignl_use+set} != xset; then
16033     if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
16034   echo $ac_n "(cached) $ac_c" 1>&6
16035 else
16036
16037
16038       ac_ext=C
16039 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16040 ac_cpp='$CXXCPP $CPPFLAGS'
16041 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16042 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16043 cross_compiling=$ac_cv_prog_cxx_cross
16044
16045       cat > conftest.$ac_ext <<EOF
16046 #line 16047 "configure"
16047 #include "confdefs.h"
16048 #include <math.h>
16049 int main() {
16050  _copysignl(0, 0);
16051 ; return 0; }
16052 EOF
16053 if { (eval echo configure:16054: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16054   rm -rf conftest*
16055   glibcpp_cv_func__copysignl_use=yes
16056 else
16057   echo "configure: failed program was:" >&5
16058   cat conftest.$ac_ext >&5
16059   rm -rf conftest*
16060   glibcpp_cv_func__copysignl_use=no
16061 fi
16062 rm -f conftest*
16063       ac_ext=c
16064 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16065 ac_cpp='$CPP $CPPFLAGS'
16066 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16067 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16068 cross_compiling=$ac_cv_prog_cc_cross
16069
16070
16071 fi
16072
16073   fi
16074   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
16075   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
16076     for ac_func in _copysignl
16077 do
16078 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16079 echo "configure:16080: checking for $ac_func" >&5
16080 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16081   echo $ac_n "(cached) $ac_c" 1>&6
16082 else
16083   cat > conftest.$ac_ext <<EOF
16084 #line 16085 "configure"
16085 #include "confdefs.h"
16086 /* System header to define __stub macros and hopefully few prototypes,
16087     which can conflict with char $ac_func(); below.  */
16088 #include <assert.h>
16089 /* Override any gcc2 internal prototype to avoid an error.  */
16090 /* We use char because int might match the return type of a gcc2
16091     builtin and then its argument prototype would still apply.  */
16092 char $ac_func();
16093
16094 int main() {
16095
16096 /* The GNU C library defines this for functions which it implements
16097     to always fail with ENOSYS.  Some functions are actually named
16098     something starting with __ and the normal name is an alias.  */
16099 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16100 choke me
16101 #else
16102 $ac_func();
16103 #endif
16104
16105 ; return 0; }
16106 EOF
16107 if { (eval echo configure:16108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16108   rm -rf conftest*
16109   eval "ac_cv_func_$ac_func=yes"
16110 else
16111   echo "configure: failed program was:" >&5
16112   cat conftest.$ac_ext >&5
16113   rm -rf conftest*
16114   eval "ac_cv_func_$ac_func=no"
16115 fi
16116 rm -f conftest*
16117 fi
16118
16119 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16120   echo "$ac_t""yes" 1>&6
16121     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16122   cat >> confdefs.h <<EOF
16123 #define $ac_tr_func 1
16124 EOF
16125
16126 else
16127   echo "$ac_t""no" 1>&6
16128 fi
16129 done
16130
16131   fi
16132
16133
16134   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
16135 echo "configure:16136: checking for _acosl declaration" >&5
16136   if test x${glibcpp_cv_func__acosl_use+set} != xset; then
16137     if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
16138   echo $ac_n "(cached) $ac_c" 1>&6
16139 else
16140
16141
16142       ac_ext=C
16143 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16144 ac_cpp='$CXXCPP $CPPFLAGS'
16145 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16146 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16147 cross_compiling=$ac_cv_prog_cxx_cross
16148
16149       cat > conftest.$ac_ext <<EOF
16150 #line 16151 "configure"
16151 #include "confdefs.h"
16152 #include <math.h>
16153 int main() {
16154  _acosl(0);
16155 ; return 0; }
16156 EOF
16157 if { (eval echo configure:16158: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16158   rm -rf conftest*
16159   glibcpp_cv_func__acosl_use=yes
16160 else
16161   echo "configure: failed program was:" >&5
16162   cat conftest.$ac_ext >&5
16163   rm -rf conftest*
16164   glibcpp_cv_func__acosl_use=no
16165 fi
16166 rm -f conftest*
16167       ac_ext=c
16168 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16169 ac_cpp='$CPP $CPPFLAGS'
16170 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16171 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16172 cross_compiling=$ac_cv_prog_cc_cross
16173
16174
16175 fi
16176
16177   fi
16178   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
16179   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
16180     for ac_func in _acosl
16181 do
16182 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16183 echo "configure:16184: checking for $ac_func" >&5
16184 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16185   echo $ac_n "(cached) $ac_c" 1>&6
16186 else
16187   cat > conftest.$ac_ext <<EOF
16188 #line 16189 "configure"
16189 #include "confdefs.h"
16190 /* System header to define __stub macros and hopefully few prototypes,
16191     which can conflict with char $ac_func(); below.  */
16192 #include <assert.h>
16193 /* Override any gcc2 internal prototype to avoid an error.  */
16194 /* We use char because int might match the return type of a gcc2
16195     builtin and then its argument prototype would still apply.  */
16196 char $ac_func();
16197
16198 int main() {
16199
16200 /* The GNU C library defines this for functions which it implements
16201     to always fail with ENOSYS.  Some functions are actually named
16202     something starting with __ and the normal name is an alias.  */
16203 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16204 choke me
16205 #else
16206 $ac_func();
16207 #endif
16208
16209 ; return 0; }
16210 EOF
16211 if { (eval echo configure:16212: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16212   rm -rf conftest*
16213   eval "ac_cv_func_$ac_func=yes"
16214 else
16215   echo "configure: failed program was:" >&5
16216   cat conftest.$ac_ext >&5
16217   rm -rf conftest*
16218   eval "ac_cv_func_$ac_func=no"
16219 fi
16220 rm -f conftest*
16221 fi
16222
16223 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16224   echo "$ac_t""yes" 1>&6
16225     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16226   cat >> confdefs.h <<EOF
16227 #define $ac_tr_func 1
16228 EOF
16229
16230 else
16231   echo "$ac_t""no" 1>&6
16232 fi
16233 done
16234
16235   fi
16236
16237
16238   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
16239 echo "configure:16240: checking for _asinl declaration" >&5
16240   if test x${glibcpp_cv_func__asinl_use+set} != xset; then
16241     if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
16242   echo $ac_n "(cached) $ac_c" 1>&6
16243 else
16244
16245
16246       ac_ext=C
16247 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16248 ac_cpp='$CXXCPP $CPPFLAGS'
16249 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16250 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16251 cross_compiling=$ac_cv_prog_cxx_cross
16252
16253       cat > conftest.$ac_ext <<EOF
16254 #line 16255 "configure"
16255 #include "confdefs.h"
16256 #include <math.h>
16257 int main() {
16258  _asinl(0);
16259 ; return 0; }
16260 EOF
16261 if { (eval echo configure:16262: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16262   rm -rf conftest*
16263   glibcpp_cv_func__asinl_use=yes
16264 else
16265   echo "configure: failed program was:" >&5
16266   cat conftest.$ac_ext >&5
16267   rm -rf conftest*
16268   glibcpp_cv_func__asinl_use=no
16269 fi
16270 rm -f conftest*
16271       ac_ext=c
16272 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16273 ac_cpp='$CPP $CPPFLAGS'
16274 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16275 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16276 cross_compiling=$ac_cv_prog_cc_cross
16277
16278
16279 fi
16280
16281   fi
16282   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
16283   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
16284     for ac_func in _asinl
16285 do
16286 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16287 echo "configure:16288: checking for $ac_func" >&5
16288 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16289   echo $ac_n "(cached) $ac_c" 1>&6
16290 else
16291   cat > conftest.$ac_ext <<EOF
16292 #line 16293 "configure"
16293 #include "confdefs.h"
16294 /* System header to define __stub macros and hopefully few prototypes,
16295     which can conflict with char $ac_func(); below.  */
16296 #include <assert.h>
16297 /* Override any gcc2 internal prototype to avoid an error.  */
16298 /* We use char because int might match the return type of a gcc2
16299     builtin and then its argument prototype would still apply.  */
16300 char $ac_func();
16301
16302 int main() {
16303
16304 /* The GNU C library defines this for functions which it implements
16305     to always fail with ENOSYS.  Some functions are actually named
16306     something starting with __ and the normal name is an alias.  */
16307 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16308 choke me
16309 #else
16310 $ac_func();
16311 #endif
16312
16313 ; return 0; }
16314 EOF
16315 if { (eval echo configure:16316: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16316   rm -rf conftest*
16317   eval "ac_cv_func_$ac_func=yes"
16318 else
16319   echo "configure: failed program was:" >&5
16320   cat conftest.$ac_ext >&5
16321   rm -rf conftest*
16322   eval "ac_cv_func_$ac_func=no"
16323 fi
16324 rm -f conftest*
16325 fi
16326
16327 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16328   echo "$ac_t""yes" 1>&6
16329     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16330   cat >> confdefs.h <<EOF
16331 #define $ac_tr_func 1
16332 EOF
16333
16334 else
16335   echo "$ac_t""no" 1>&6
16336 fi
16337 done
16338
16339   fi
16340
16341
16342   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
16343 echo "configure:16344: checking for _atanl declaration" >&5
16344   if test x${glibcpp_cv_func__atanl_use+set} != xset; then
16345     if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
16346   echo $ac_n "(cached) $ac_c" 1>&6
16347 else
16348
16349
16350       ac_ext=C
16351 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16352 ac_cpp='$CXXCPP $CPPFLAGS'
16353 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16354 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16355 cross_compiling=$ac_cv_prog_cxx_cross
16356
16357       cat > conftest.$ac_ext <<EOF
16358 #line 16359 "configure"
16359 #include "confdefs.h"
16360 #include <math.h>
16361 int main() {
16362  _atanl(0);
16363 ; return 0; }
16364 EOF
16365 if { (eval echo configure:16366: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16366   rm -rf conftest*
16367   glibcpp_cv_func__atanl_use=yes
16368 else
16369   echo "configure: failed program was:" >&5
16370   cat conftest.$ac_ext >&5
16371   rm -rf conftest*
16372   glibcpp_cv_func__atanl_use=no
16373 fi
16374 rm -f conftest*
16375       ac_ext=c
16376 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16377 ac_cpp='$CPP $CPPFLAGS'
16378 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16379 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16380 cross_compiling=$ac_cv_prog_cc_cross
16381
16382
16383 fi
16384
16385   fi
16386   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
16387   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
16388     for ac_func in _atanl
16389 do
16390 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16391 echo "configure:16392: checking for $ac_func" >&5
16392 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16393   echo $ac_n "(cached) $ac_c" 1>&6
16394 else
16395   cat > conftest.$ac_ext <<EOF
16396 #line 16397 "configure"
16397 #include "confdefs.h"
16398 /* System header to define __stub macros and hopefully few prototypes,
16399     which can conflict with char $ac_func(); below.  */
16400 #include <assert.h>
16401 /* Override any gcc2 internal prototype to avoid an error.  */
16402 /* We use char because int might match the return type of a gcc2
16403     builtin and then its argument prototype would still apply.  */
16404 char $ac_func();
16405
16406 int main() {
16407
16408 /* The GNU C library defines this for functions which it implements
16409     to always fail with ENOSYS.  Some functions are actually named
16410     something starting with __ and the normal name is an alias.  */
16411 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16412 choke me
16413 #else
16414 $ac_func();
16415 #endif
16416
16417 ; return 0; }
16418 EOF
16419 if { (eval echo configure:16420: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16420   rm -rf conftest*
16421   eval "ac_cv_func_$ac_func=yes"
16422 else
16423   echo "configure: failed program was:" >&5
16424   cat conftest.$ac_ext >&5
16425   rm -rf conftest*
16426   eval "ac_cv_func_$ac_func=no"
16427 fi
16428 rm -f conftest*
16429 fi
16430
16431 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16432   echo "$ac_t""yes" 1>&6
16433     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16434   cat >> confdefs.h <<EOF
16435 #define $ac_tr_func 1
16436 EOF
16437
16438 else
16439   echo "$ac_t""no" 1>&6
16440 fi
16441 done
16442
16443   fi
16444
16445
16446   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
16447 echo "configure:16448: checking for _atan2l declaration" >&5
16448   if test x${glibcpp_cv_func__atan2l_use+set} != xset; then
16449     if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
16450   echo $ac_n "(cached) $ac_c" 1>&6
16451 else
16452
16453
16454       ac_ext=C
16455 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16456 ac_cpp='$CXXCPP $CPPFLAGS'
16457 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16458 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16459 cross_compiling=$ac_cv_prog_cxx_cross
16460
16461       cat > conftest.$ac_ext <<EOF
16462 #line 16463 "configure"
16463 #include "confdefs.h"
16464 #include <math.h>
16465 int main() {
16466  _atan2l(0, 0);
16467 ; return 0; }
16468 EOF
16469 if { (eval echo configure:16470: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16470   rm -rf conftest*
16471   glibcpp_cv_func__atan2l_use=yes
16472 else
16473   echo "configure: failed program was:" >&5
16474   cat conftest.$ac_ext >&5
16475   rm -rf conftest*
16476   glibcpp_cv_func__atan2l_use=no
16477 fi
16478 rm -f conftest*
16479       ac_ext=c
16480 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16481 ac_cpp='$CPP $CPPFLAGS'
16482 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16483 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16484 cross_compiling=$ac_cv_prog_cc_cross
16485
16486
16487 fi
16488
16489   fi
16490   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
16491   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
16492     for ac_func in _atan2l
16493 do
16494 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16495 echo "configure:16496: checking for $ac_func" >&5
16496 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16497   echo $ac_n "(cached) $ac_c" 1>&6
16498 else
16499   cat > conftest.$ac_ext <<EOF
16500 #line 16501 "configure"
16501 #include "confdefs.h"
16502 /* System header to define __stub macros and hopefully few prototypes,
16503     which can conflict with char $ac_func(); below.  */
16504 #include <assert.h>
16505 /* Override any gcc2 internal prototype to avoid an error.  */
16506 /* We use char because int might match the return type of a gcc2
16507     builtin and then its argument prototype would still apply.  */
16508 char $ac_func();
16509
16510 int main() {
16511
16512 /* The GNU C library defines this for functions which it implements
16513     to always fail with ENOSYS.  Some functions are actually named
16514     something starting with __ and the normal name is an alias.  */
16515 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16516 choke me
16517 #else
16518 $ac_func();
16519 #endif
16520
16521 ; return 0; }
16522 EOF
16523 if { (eval echo configure:16524: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16524   rm -rf conftest*
16525   eval "ac_cv_func_$ac_func=yes"
16526 else
16527   echo "configure: failed program was:" >&5
16528   cat conftest.$ac_ext >&5
16529   rm -rf conftest*
16530   eval "ac_cv_func_$ac_func=no"
16531 fi
16532 rm -f conftest*
16533 fi
16534
16535 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16536   echo "$ac_t""yes" 1>&6
16537     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16538   cat >> confdefs.h <<EOF
16539 #define $ac_tr_func 1
16540 EOF
16541
16542 else
16543   echo "$ac_t""no" 1>&6
16544 fi
16545 done
16546
16547   fi
16548
16549
16550   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
16551 echo "configure:16552: checking for _ceill declaration" >&5
16552   if test x${glibcpp_cv_func__ceill_use+set} != xset; then
16553     if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
16554   echo $ac_n "(cached) $ac_c" 1>&6
16555 else
16556
16557
16558       ac_ext=C
16559 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16560 ac_cpp='$CXXCPP $CPPFLAGS'
16561 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16562 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16563 cross_compiling=$ac_cv_prog_cxx_cross
16564
16565       cat > conftest.$ac_ext <<EOF
16566 #line 16567 "configure"
16567 #include "confdefs.h"
16568 #include <math.h>
16569 int main() {
16570  _ceill(0);
16571 ; return 0; }
16572 EOF
16573 if { (eval echo configure:16574: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16574   rm -rf conftest*
16575   glibcpp_cv_func__ceill_use=yes
16576 else
16577   echo "configure: failed program was:" >&5
16578   cat conftest.$ac_ext >&5
16579   rm -rf conftest*
16580   glibcpp_cv_func__ceill_use=no
16581 fi
16582 rm -f conftest*
16583       ac_ext=c
16584 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16585 ac_cpp='$CPP $CPPFLAGS'
16586 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16587 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16588 cross_compiling=$ac_cv_prog_cc_cross
16589
16590
16591 fi
16592
16593   fi
16594   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
16595   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
16596     for ac_func in _ceill
16597 do
16598 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16599 echo "configure:16600: checking for $ac_func" >&5
16600 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16601   echo $ac_n "(cached) $ac_c" 1>&6
16602 else
16603   cat > conftest.$ac_ext <<EOF
16604 #line 16605 "configure"
16605 #include "confdefs.h"
16606 /* System header to define __stub macros and hopefully few prototypes,
16607     which can conflict with char $ac_func(); below.  */
16608 #include <assert.h>
16609 /* Override any gcc2 internal prototype to avoid an error.  */
16610 /* We use char because int might match the return type of a gcc2
16611     builtin and then its argument prototype would still apply.  */
16612 char $ac_func();
16613
16614 int main() {
16615
16616 /* The GNU C library defines this for functions which it implements
16617     to always fail with ENOSYS.  Some functions are actually named
16618     something starting with __ and the normal name is an alias.  */
16619 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16620 choke me
16621 #else
16622 $ac_func();
16623 #endif
16624
16625 ; return 0; }
16626 EOF
16627 if { (eval echo configure:16628: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16628   rm -rf conftest*
16629   eval "ac_cv_func_$ac_func=yes"
16630 else
16631   echo "configure: failed program was:" >&5
16632   cat conftest.$ac_ext >&5
16633   rm -rf conftest*
16634   eval "ac_cv_func_$ac_func=no"
16635 fi
16636 rm -f conftest*
16637 fi
16638
16639 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16640   echo "$ac_t""yes" 1>&6
16641     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16642   cat >> confdefs.h <<EOF
16643 #define $ac_tr_func 1
16644 EOF
16645
16646 else
16647   echo "$ac_t""no" 1>&6
16648 fi
16649 done
16650
16651   fi
16652
16653
16654   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
16655 echo "configure:16656: checking for _cosl declaration" >&5
16656   if test x${glibcpp_cv_func__cosl_use+set} != xset; then
16657     if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
16658   echo $ac_n "(cached) $ac_c" 1>&6
16659 else
16660
16661
16662       ac_ext=C
16663 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16664 ac_cpp='$CXXCPP $CPPFLAGS'
16665 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16666 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16667 cross_compiling=$ac_cv_prog_cxx_cross
16668
16669       cat > conftest.$ac_ext <<EOF
16670 #line 16671 "configure"
16671 #include "confdefs.h"
16672 #include <math.h>
16673 int main() {
16674  _cosl(0);
16675 ; return 0; }
16676 EOF
16677 if { (eval echo configure:16678: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16678   rm -rf conftest*
16679   glibcpp_cv_func__cosl_use=yes
16680 else
16681   echo "configure: failed program was:" >&5
16682   cat conftest.$ac_ext >&5
16683   rm -rf conftest*
16684   glibcpp_cv_func__cosl_use=no
16685 fi
16686 rm -f conftest*
16687       ac_ext=c
16688 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16689 ac_cpp='$CPP $CPPFLAGS'
16690 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16691 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16692 cross_compiling=$ac_cv_prog_cc_cross
16693
16694
16695 fi
16696
16697   fi
16698   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
16699   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
16700     for ac_func in _cosl
16701 do
16702 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16703 echo "configure:16704: checking for $ac_func" >&5
16704 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16705   echo $ac_n "(cached) $ac_c" 1>&6
16706 else
16707   cat > conftest.$ac_ext <<EOF
16708 #line 16709 "configure"
16709 #include "confdefs.h"
16710 /* System header to define __stub macros and hopefully few prototypes,
16711     which can conflict with char $ac_func(); below.  */
16712 #include <assert.h>
16713 /* Override any gcc2 internal prototype to avoid an error.  */
16714 /* We use char because int might match the return type of a gcc2
16715     builtin and then its argument prototype would still apply.  */
16716 char $ac_func();
16717
16718 int main() {
16719
16720 /* The GNU C library defines this for functions which it implements
16721     to always fail with ENOSYS.  Some functions are actually named
16722     something starting with __ and the normal name is an alias.  */
16723 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16724 choke me
16725 #else
16726 $ac_func();
16727 #endif
16728
16729 ; return 0; }
16730 EOF
16731 if { (eval echo configure:16732: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16732   rm -rf conftest*
16733   eval "ac_cv_func_$ac_func=yes"
16734 else
16735   echo "configure: failed program was:" >&5
16736   cat conftest.$ac_ext >&5
16737   rm -rf conftest*
16738   eval "ac_cv_func_$ac_func=no"
16739 fi
16740 rm -f conftest*
16741 fi
16742
16743 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16744   echo "$ac_t""yes" 1>&6
16745     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16746   cat >> confdefs.h <<EOF
16747 #define $ac_tr_func 1
16748 EOF
16749
16750 else
16751   echo "$ac_t""no" 1>&6
16752 fi
16753 done
16754
16755   fi
16756
16757
16758   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
16759 echo "configure:16760: checking for _coshl declaration" >&5
16760   if test x${glibcpp_cv_func__coshl_use+set} != xset; then
16761     if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
16762   echo $ac_n "(cached) $ac_c" 1>&6
16763 else
16764
16765
16766       ac_ext=C
16767 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16768 ac_cpp='$CXXCPP $CPPFLAGS'
16769 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16770 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16771 cross_compiling=$ac_cv_prog_cxx_cross
16772
16773       cat > conftest.$ac_ext <<EOF
16774 #line 16775 "configure"
16775 #include "confdefs.h"
16776 #include <math.h>
16777 int main() {
16778  _coshl(0);
16779 ; return 0; }
16780 EOF
16781 if { (eval echo configure:16782: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16782   rm -rf conftest*
16783   glibcpp_cv_func__coshl_use=yes
16784 else
16785   echo "configure: failed program was:" >&5
16786   cat conftest.$ac_ext >&5
16787   rm -rf conftest*
16788   glibcpp_cv_func__coshl_use=no
16789 fi
16790 rm -f conftest*
16791       ac_ext=c
16792 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16793 ac_cpp='$CPP $CPPFLAGS'
16794 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16795 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16796 cross_compiling=$ac_cv_prog_cc_cross
16797
16798
16799 fi
16800
16801   fi
16802   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
16803   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
16804     for ac_func in _coshl
16805 do
16806 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16807 echo "configure:16808: checking for $ac_func" >&5
16808 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16809   echo $ac_n "(cached) $ac_c" 1>&6
16810 else
16811   cat > conftest.$ac_ext <<EOF
16812 #line 16813 "configure"
16813 #include "confdefs.h"
16814 /* System header to define __stub macros and hopefully few prototypes,
16815     which can conflict with char $ac_func(); below.  */
16816 #include <assert.h>
16817 /* Override any gcc2 internal prototype to avoid an error.  */
16818 /* We use char because int might match the return type of a gcc2
16819     builtin and then its argument prototype would still apply.  */
16820 char $ac_func();
16821
16822 int main() {
16823
16824 /* The GNU C library defines this for functions which it implements
16825     to always fail with ENOSYS.  Some functions are actually named
16826     something starting with __ and the normal name is an alias.  */
16827 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16828 choke me
16829 #else
16830 $ac_func();
16831 #endif
16832
16833 ; return 0; }
16834 EOF
16835 if { (eval echo configure:16836: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16836   rm -rf conftest*
16837   eval "ac_cv_func_$ac_func=yes"
16838 else
16839   echo "configure: failed program was:" >&5
16840   cat conftest.$ac_ext >&5
16841   rm -rf conftest*
16842   eval "ac_cv_func_$ac_func=no"
16843 fi
16844 rm -f conftest*
16845 fi
16846
16847 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16848   echo "$ac_t""yes" 1>&6
16849     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16850   cat >> confdefs.h <<EOF
16851 #define $ac_tr_func 1
16852 EOF
16853
16854 else
16855   echo "$ac_t""no" 1>&6
16856 fi
16857 done
16858
16859   fi
16860
16861
16862   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
16863 echo "configure:16864: checking for _expl declaration" >&5
16864   if test x${glibcpp_cv_func__expl_use+set} != xset; then
16865     if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
16866   echo $ac_n "(cached) $ac_c" 1>&6
16867 else
16868
16869
16870       ac_ext=C
16871 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16872 ac_cpp='$CXXCPP $CPPFLAGS'
16873 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16874 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16875 cross_compiling=$ac_cv_prog_cxx_cross
16876
16877       cat > conftest.$ac_ext <<EOF
16878 #line 16879 "configure"
16879 #include "confdefs.h"
16880 #include <math.h>
16881 int main() {
16882  _expl(0);
16883 ; return 0; }
16884 EOF
16885 if { (eval echo configure:16886: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16886   rm -rf conftest*
16887   glibcpp_cv_func__expl_use=yes
16888 else
16889   echo "configure: failed program was:" >&5
16890   cat conftest.$ac_ext >&5
16891   rm -rf conftest*
16892   glibcpp_cv_func__expl_use=no
16893 fi
16894 rm -f conftest*
16895       ac_ext=c
16896 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16897 ac_cpp='$CPP $CPPFLAGS'
16898 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16899 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16900 cross_compiling=$ac_cv_prog_cc_cross
16901
16902
16903 fi
16904
16905   fi
16906   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
16907   if test x$glibcpp_cv_func__expl_use = x"yes"; then
16908     for ac_func in _expl
16909 do
16910 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16911 echo "configure:16912: checking for $ac_func" >&5
16912 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16913   echo $ac_n "(cached) $ac_c" 1>&6
16914 else
16915   cat > conftest.$ac_ext <<EOF
16916 #line 16917 "configure"
16917 #include "confdefs.h"
16918 /* System header to define __stub macros and hopefully few prototypes,
16919     which can conflict with char $ac_func(); below.  */
16920 #include <assert.h>
16921 /* Override any gcc2 internal prototype to avoid an error.  */
16922 /* We use char because int might match the return type of a gcc2
16923     builtin and then its argument prototype would still apply.  */
16924 char $ac_func();
16925
16926 int main() {
16927
16928 /* The GNU C library defines this for functions which it implements
16929     to always fail with ENOSYS.  Some functions are actually named
16930     something starting with __ and the normal name is an alias.  */
16931 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16932 choke me
16933 #else
16934 $ac_func();
16935 #endif
16936
16937 ; return 0; }
16938 EOF
16939 if { (eval echo configure:16940: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16940   rm -rf conftest*
16941   eval "ac_cv_func_$ac_func=yes"
16942 else
16943   echo "configure: failed program was:" >&5
16944   cat conftest.$ac_ext >&5
16945   rm -rf conftest*
16946   eval "ac_cv_func_$ac_func=no"
16947 fi
16948 rm -f conftest*
16949 fi
16950
16951 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16952   echo "$ac_t""yes" 1>&6
16953     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16954   cat >> confdefs.h <<EOF
16955 #define $ac_tr_func 1
16956 EOF
16957
16958 else
16959   echo "$ac_t""no" 1>&6
16960 fi
16961 done
16962
16963   fi
16964
16965
16966   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
16967 echo "configure:16968: checking for _fabsl declaration" >&5
16968   if test x${glibcpp_cv_func__fabsl_use+set} != xset; then
16969     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
16970   echo $ac_n "(cached) $ac_c" 1>&6
16971 else
16972
16973
16974       ac_ext=C
16975 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16976 ac_cpp='$CXXCPP $CPPFLAGS'
16977 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16978 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16979 cross_compiling=$ac_cv_prog_cxx_cross
16980
16981       cat > conftest.$ac_ext <<EOF
16982 #line 16983 "configure"
16983 #include "confdefs.h"
16984 #include <math.h>
16985 int main() {
16986  _fabsl(0);
16987 ; return 0; }
16988 EOF
16989 if { (eval echo configure:16990: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16990   rm -rf conftest*
16991   glibcpp_cv_func__fabsl_use=yes
16992 else
16993   echo "configure: failed program was:" >&5
16994   cat conftest.$ac_ext >&5
16995   rm -rf conftest*
16996   glibcpp_cv_func__fabsl_use=no
16997 fi
16998 rm -f conftest*
16999       ac_ext=c
17000 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17001 ac_cpp='$CPP $CPPFLAGS'
17002 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17003 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17004 cross_compiling=$ac_cv_prog_cc_cross
17005
17006
17007 fi
17008
17009   fi
17010   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
17011   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
17012     for ac_func in _fabsl
17013 do
17014 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17015 echo "configure:17016: checking for $ac_func" >&5
17016 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17017   echo $ac_n "(cached) $ac_c" 1>&6
17018 else
17019   cat > conftest.$ac_ext <<EOF
17020 #line 17021 "configure"
17021 #include "confdefs.h"
17022 /* System header to define __stub macros and hopefully few prototypes,
17023     which can conflict with char $ac_func(); below.  */
17024 #include <assert.h>
17025 /* Override any gcc2 internal prototype to avoid an error.  */
17026 /* We use char because int might match the return type of a gcc2
17027     builtin and then its argument prototype would still apply.  */
17028 char $ac_func();
17029
17030 int main() {
17031
17032 /* The GNU C library defines this for functions which it implements
17033     to always fail with ENOSYS.  Some functions are actually named
17034     something starting with __ and the normal name is an alias.  */
17035 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17036 choke me
17037 #else
17038 $ac_func();
17039 #endif
17040
17041 ; return 0; }
17042 EOF
17043 if { (eval echo configure:17044: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17044   rm -rf conftest*
17045   eval "ac_cv_func_$ac_func=yes"
17046 else
17047   echo "configure: failed program was:" >&5
17048   cat conftest.$ac_ext >&5
17049   rm -rf conftest*
17050   eval "ac_cv_func_$ac_func=no"
17051 fi
17052 rm -f conftest*
17053 fi
17054
17055 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17056   echo "$ac_t""yes" 1>&6
17057     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17058   cat >> confdefs.h <<EOF
17059 #define $ac_tr_func 1
17060 EOF
17061
17062 else
17063   echo "$ac_t""no" 1>&6
17064 fi
17065 done
17066
17067   fi
17068
17069
17070   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
17071 echo "configure:17072: checking for _floorl declaration" >&5
17072   if test x${glibcpp_cv_func__floorl_use+set} != xset; then
17073     if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
17074   echo $ac_n "(cached) $ac_c" 1>&6
17075 else
17076
17077
17078       ac_ext=C
17079 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17080 ac_cpp='$CXXCPP $CPPFLAGS'
17081 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17082 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17083 cross_compiling=$ac_cv_prog_cxx_cross
17084
17085       cat > conftest.$ac_ext <<EOF
17086 #line 17087 "configure"
17087 #include "confdefs.h"
17088 #include <math.h>
17089 int main() {
17090  _floorl(0);
17091 ; return 0; }
17092 EOF
17093 if { (eval echo configure:17094: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17094   rm -rf conftest*
17095   glibcpp_cv_func__floorl_use=yes
17096 else
17097   echo "configure: failed program was:" >&5
17098   cat conftest.$ac_ext >&5
17099   rm -rf conftest*
17100   glibcpp_cv_func__floorl_use=no
17101 fi
17102 rm -f conftest*
17103       ac_ext=c
17104 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17105 ac_cpp='$CPP $CPPFLAGS'
17106 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17107 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17108 cross_compiling=$ac_cv_prog_cc_cross
17109
17110
17111 fi
17112
17113   fi
17114   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
17115   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
17116     for ac_func in _floorl
17117 do
17118 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17119 echo "configure:17120: checking for $ac_func" >&5
17120 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17121   echo $ac_n "(cached) $ac_c" 1>&6
17122 else
17123   cat > conftest.$ac_ext <<EOF
17124 #line 17125 "configure"
17125 #include "confdefs.h"
17126 /* System header to define __stub macros and hopefully few prototypes,
17127     which can conflict with char $ac_func(); below.  */
17128 #include <assert.h>
17129 /* Override any gcc2 internal prototype to avoid an error.  */
17130 /* We use char because int might match the return type of a gcc2
17131     builtin and then its argument prototype would still apply.  */
17132 char $ac_func();
17133
17134 int main() {
17135
17136 /* The GNU C library defines this for functions which it implements
17137     to always fail with ENOSYS.  Some functions are actually named
17138     something starting with __ and the normal name is an alias.  */
17139 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17140 choke me
17141 #else
17142 $ac_func();
17143 #endif
17144
17145 ; return 0; }
17146 EOF
17147 if { (eval echo configure:17148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17148   rm -rf conftest*
17149   eval "ac_cv_func_$ac_func=yes"
17150 else
17151   echo "configure: failed program was:" >&5
17152   cat conftest.$ac_ext >&5
17153   rm -rf conftest*
17154   eval "ac_cv_func_$ac_func=no"
17155 fi
17156 rm -f conftest*
17157 fi
17158
17159 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17160   echo "$ac_t""yes" 1>&6
17161     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17162   cat >> confdefs.h <<EOF
17163 #define $ac_tr_func 1
17164 EOF
17165
17166 else
17167   echo "$ac_t""no" 1>&6
17168 fi
17169 done
17170
17171   fi
17172
17173
17174   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
17175 echo "configure:17176: checking for _fmodl declaration" >&5
17176   if test x${glibcpp_cv_func__fmodl_use+set} != xset; then
17177     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
17178   echo $ac_n "(cached) $ac_c" 1>&6
17179 else
17180
17181
17182       ac_ext=C
17183 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17184 ac_cpp='$CXXCPP $CPPFLAGS'
17185 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17186 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17187 cross_compiling=$ac_cv_prog_cxx_cross
17188
17189       cat > conftest.$ac_ext <<EOF
17190 #line 17191 "configure"
17191 #include "confdefs.h"
17192 #include <math.h>
17193 int main() {
17194  _fmodl(0, 0);
17195 ; return 0; }
17196 EOF
17197 if { (eval echo configure:17198: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17198   rm -rf conftest*
17199   glibcpp_cv_func__fmodl_use=yes
17200 else
17201   echo "configure: failed program was:" >&5
17202   cat conftest.$ac_ext >&5
17203   rm -rf conftest*
17204   glibcpp_cv_func__fmodl_use=no
17205 fi
17206 rm -f conftest*
17207       ac_ext=c
17208 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17209 ac_cpp='$CPP $CPPFLAGS'
17210 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17211 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17212 cross_compiling=$ac_cv_prog_cc_cross
17213
17214
17215 fi
17216
17217   fi
17218   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
17219   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
17220     for ac_func in _fmodl
17221 do
17222 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17223 echo "configure:17224: checking for $ac_func" >&5
17224 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17225   echo $ac_n "(cached) $ac_c" 1>&6
17226 else
17227   cat > conftest.$ac_ext <<EOF
17228 #line 17229 "configure"
17229 #include "confdefs.h"
17230 /* System header to define __stub macros and hopefully few prototypes,
17231     which can conflict with char $ac_func(); below.  */
17232 #include <assert.h>
17233 /* Override any gcc2 internal prototype to avoid an error.  */
17234 /* We use char because int might match the return type of a gcc2
17235     builtin and then its argument prototype would still apply.  */
17236 char $ac_func();
17237
17238 int main() {
17239
17240 /* The GNU C library defines this for functions which it implements
17241     to always fail with ENOSYS.  Some functions are actually named
17242     something starting with __ and the normal name is an alias.  */
17243 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17244 choke me
17245 #else
17246 $ac_func();
17247 #endif
17248
17249 ; return 0; }
17250 EOF
17251 if { (eval echo configure:17252: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17252   rm -rf conftest*
17253   eval "ac_cv_func_$ac_func=yes"
17254 else
17255   echo "configure: failed program was:" >&5
17256   cat conftest.$ac_ext >&5
17257   rm -rf conftest*
17258   eval "ac_cv_func_$ac_func=no"
17259 fi
17260 rm -f conftest*
17261 fi
17262
17263 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17264   echo "$ac_t""yes" 1>&6
17265     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17266   cat >> confdefs.h <<EOF
17267 #define $ac_tr_func 1
17268 EOF
17269
17270 else
17271   echo "$ac_t""no" 1>&6
17272 fi
17273 done
17274
17275   fi
17276
17277
17278   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
17279 echo "configure:17280: checking for _frexpl declaration" >&5
17280   if test x${glibcpp_cv_func__frexpl_use+set} != xset; then
17281     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
17282   echo $ac_n "(cached) $ac_c" 1>&6
17283 else
17284
17285
17286       ac_ext=C
17287 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17288 ac_cpp='$CXXCPP $CPPFLAGS'
17289 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17290 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17291 cross_compiling=$ac_cv_prog_cxx_cross
17292
17293       cat > conftest.$ac_ext <<EOF
17294 #line 17295 "configure"
17295 #include "confdefs.h"
17296 #include <math.h>
17297 int main() {
17298  _frexpl(0, 0);
17299 ; return 0; }
17300 EOF
17301 if { (eval echo configure:17302: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17302   rm -rf conftest*
17303   glibcpp_cv_func__frexpl_use=yes
17304 else
17305   echo "configure: failed program was:" >&5
17306   cat conftest.$ac_ext >&5
17307   rm -rf conftest*
17308   glibcpp_cv_func__frexpl_use=no
17309 fi
17310 rm -f conftest*
17311       ac_ext=c
17312 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17313 ac_cpp='$CPP $CPPFLAGS'
17314 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17315 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17316 cross_compiling=$ac_cv_prog_cc_cross
17317
17318
17319 fi
17320
17321   fi
17322   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
17323   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
17324     for ac_func in _frexpl
17325 do
17326 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17327 echo "configure:17328: checking for $ac_func" >&5
17328 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17329   echo $ac_n "(cached) $ac_c" 1>&6
17330 else
17331   cat > conftest.$ac_ext <<EOF
17332 #line 17333 "configure"
17333 #include "confdefs.h"
17334 /* System header to define __stub macros and hopefully few prototypes,
17335     which can conflict with char $ac_func(); below.  */
17336 #include <assert.h>
17337 /* Override any gcc2 internal prototype to avoid an error.  */
17338 /* We use char because int might match the return type of a gcc2
17339     builtin and then its argument prototype would still apply.  */
17340 char $ac_func();
17341
17342 int main() {
17343
17344 /* The GNU C library defines this for functions which it implements
17345     to always fail with ENOSYS.  Some functions are actually named
17346     something starting with __ and the normal name is an alias.  */
17347 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17348 choke me
17349 #else
17350 $ac_func();
17351 #endif
17352
17353 ; return 0; }
17354 EOF
17355 if { (eval echo configure:17356: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17356   rm -rf conftest*
17357   eval "ac_cv_func_$ac_func=yes"
17358 else
17359   echo "configure: failed program was:" >&5
17360   cat conftest.$ac_ext >&5
17361   rm -rf conftest*
17362   eval "ac_cv_func_$ac_func=no"
17363 fi
17364 rm -f conftest*
17365 fi
17366
17367 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17368   echo "$ac_t""yes" 1>&6
17369     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17370   cat >> confdefs.h <<EOF
17371 #define $ac_tr_func 1
17372 EOF
17373
17374 else
17375   echo "$ac_t""no" 1>&6
17376 fi
17377 done
17378
17379   fi
17380
17381
17382   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
17383 echo "configure:17384: checking for _ldexpl declaration" >&5
17384   if test x${glibcpp_cv_func__ldexpl_use+set} != xset; then
17385     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
17386   echo $ac_n "(cached) $ac_c" 1>&6
17387 else
17388
17389
17390       ac_ext=C
17391 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17392 ac_cpp='$CXXCPP $CPPFLAGS'
17393 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17394 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17395 cross_compiling=$ac_cv_prog_cxx_cross
17396
17397       cat > conftest.$ac_ext <<EOF
17398 #line 17399 "configure"
17399 #include "confdefs.h"
17400 #include <math.h>
17401 int main() {
17402  _ldexpl(0, 0);
17403 ; return 0; }
17404 EOF
17405 if { (eval echo configure:17406: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17406   rm -rf conftest*
17407   glibcpp_cv_func__ldexpl_use=yes
17408 else
17409   echo "configure: failed program was:" >&5
17410   cat conftest.$ac_ext >&5
17411   rm -rf conftest*
17412   glibcpp_cv_func__ldexpl_use=no
17413 fi
17414 rm -f conftest*
17415       ac_ext=c
17416 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17417 ac_cpp='$CPP $CPPFLAGS'
17418 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17419 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17420 cross_compiling=$ac_cv_prog_cc_cross
17421
17422
17423 fi
17424
17425   fi
17426   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
17427   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
17428     for ac_func in _ldexpl
17429 do
17430 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17431 echo "configure:17432: checking for $ac_func" >&5
17432 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17433   echo $ac_n "(cached) $ac_c" 1>&6
17434 else
17435   cat > conftest.$ac_ext <<EOF
17436 #line 17437 "configure"
17437 #include "confdefs.h"
17438 /* System header to define __stub macros and hopefully few prototypes,
17439     which can conflict with char $ac_func(); below.  */
17440 #include <assert.h>
17441 /* Override any gcc2 internal prototype to avoid an error.  */
17442 /* We use char because int might match the return type of a gcc2
17443     builtin and then its argument prototype would still apply.  */
17444 char $ac_func();
17445
17446 int main() {
17447
17448 /* The GNU C library defines this for functions which it implements
17449     to always fail with ENOSYS.  Some functions are actually named
17450     something starting with __ and the normal name is an alias.  */
17451 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17452 choke me
17453 #else
17454 $ac_func();
17455 #endif
17456
17457 ; return 0; }
17458 EOF
17459 if { (eval echo configure:17460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17460   rm -rf conftest*
17461   eval "ac_cv_func_$ac_func=yes"
17462 else
17463   echo "configure: failed program was:" >&5
17464   cat conftest.$ac_ext >&5
17465   rm -rf conftest*
17466   eval "ac_cv_func_$ac_func=no"
17467 fi
17468 rm -f conftest*
17469 fi
17470
17471 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17472   echo "$ac_t""yes" 1>&6
17473     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17474   cat >> confdefs.h <<EOF
17475 #define $ac_tr_func 1
17476 EOF
17477
17478 else
17479   echo "$ac_t""no" 1>&6
17480 fi
17481 done
17482
17483   fi
17484
17485
17486   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
17487 echo "configure:17488: checking for _logl declaration" >&5
17488   if test x${glibcpp_cv_func__logl_use+set} != xset; then
17489     if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
17490   echo $ac_n "(cached) $ac_c" 1>&6
17491 else
17492
17493
17494       ac_ext=C
17495 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17496 ac_cpp='$CXXCPP $CPPFLAGS'
17497 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17498 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17499 cross_compiling=$ac_cv_prog_cxx_cross
17500
17501       cat > conftest.$ac_ext <<EOF
17502 #line 17503 "configure"
17503 #include "confdefs.h"
17504 #include <math.h>
17505 int main() {
17506  _logl(0);
17507 ; return 0; }
17508 EOF
17509 if { (eval echo configure:17510: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17510   rm -rf conftest*
17511   glibcpp_cv_func__logl_use=yes
17512 else
17513   echo "configure: failed program was:" >&5
17514   cat conftest.$ac_ext >&5
17515   rm -rf conftest*
17516   glibcpp_cv_func__logl_use=no
17517 fi
17518 rm -f conftest*
17519       ac_ext=c
17520 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17521 ac_cpp='$CPP $CPPFLAGS'
17522 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17523 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17524 cross_compiling=$ac_cv_prog_cc_cross
17525
17526
17527 fi
17528
17529   fi
17530   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
17531   if test x$glibcpp_cv_func__logl_use = x"yes"; then
17532     for ac_func in _logl
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
17582 else
17583   echo "$ac_t""no" 1>&6
17584 fi
17585 done
17586
17587   fi
17588
17589
17590   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
17591 echo "configure:17592: checking for _log10l declaration" >&5
17592   if test x${glibcpp_cv_func__log10l_use+set} != xset; then
17593     if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
17594   echo $ac_n "(cached) $ac_c" 1>&6
17595 else
17596
17597
17598       ac_ext=C
17599 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17600 ac_cpp='$CXXCPP $CPPFLAGS'
17601 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17602 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17603 cross_compiling=$ac_cv_prog_cxx_cross
17604
17605       cat > conftest.$ac_ext <<EOF
17606 #line 17607 "configure"
17607 #include "confdefs.h"
17608 #include <math.h>
17609 int main() {
17610  _log10l(0);
17611 ; return 0; }
17612 EOF
17613 if { (eval echo configure:17614: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17614   rm -rf conftest*
17615   glibcpp_cv_func__log10l_use=yes
17616 else
17617   echo "configure: failed program was:" >&5
17618   cat conftest.$ac_ext >&5
17619   rm -rf conftest*
17620   glibcpp_cv_func__log10l_use=no
17621 fi
17622 rm -f conftest*
17623       ac_ext=c
17624 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17625 ac_cpp='$CPP $CPPFLAGS'
17626 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17627 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17628 cross_compiling=$ac_cv_prog_cc_cross
17629
17630
17631 fi
17632
17633   fi
17634   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
17635   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
17636     for ac_func in _log10l
17637 do
17638 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17639 echo "configure:17640: checking for $ac_func" >&5
17640 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17641   echo $ac_n "(cached) $ac_c" 1>&6
17642 else
17643   cat > conftest.$ac_ext <<EOF
17644 #line 17645 "configure"
17645 #include "confdefs.h"
17646 /* System header to define __stub macros and hopefully few prototypes,
17647     which can conflict with char $ac_func(); below.  */
17648 #include <assert.h>
17649 /* Override any gcc2 internal prototype to avoid an error.  */
17650 /* We use char because int might match the return type of a gcc2
17651     builtin and then its argument prototype would still apply.  */
17652 char $ac_func();
17653
17654 int main() {
17655
17656 /* The GNU C library defines this for functions which it implements
17657     to always fail with ENOSYS.  Some functions are actually named
17658     something starting with __ and the normal name is an alias.  */
17659 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17660 choke me
17661 #else
17662 $ac_func();
17663 #endif
17664
17665 ; return 0; }
17666 EOF
17667 if { (eval echo configure:17668: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17668   rm -rf conftest*
17669   eval "ac_cv_func_$ac_func=yes"
17670 else
17671   echo "configure: failed program was:" >&5
17672   cat conftest.$ac_ext >&5
17673   rm -rf conftest*
17674   eval "ac_cv_func_$ac_func=no"
17675 fi
17676 rm -f conftest*
17677 fi
17678
17679 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17680   echo "$ac_t""yes" 1>&6
17681     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17682   cat >> confdefs.h <<EOF
17683 #define $ac_tr_func 1
17684 EOF
17685
17686 else
17687   echo "$ac_t""no" 1>&6
17688 fi
17689 done
17690
17691   fi
17692
17693
17694   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
17695 echo "configure:17696: checking for _modfl declaration" >&5
17696   if test x${glibcpp_cv_func__modfl_use+set} != xset; then
17697     if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
17698   echo $ac_n "(cached) $ac_c" 1>&6
17699 else
17700
17701
17702       ac_ext=C
17703 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17704 ac_cpp='$CXXCPP $CPPFLAGS'
17705 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17706 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17707 cross_compiling=$ac_cv_prog_cxx_cross
17708
17709       cat > conftest.$ac_ext <<EOF
17710 #line 17711 "configure"
17711 #include "confdefs.h"
17712 #include <math.h>
17713 int main() {
17714  _modfl(0, 0);
17715 ; return 0; }
17716 EOF
17717 if { (eval echo configure:17718: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17718   rm -rf conftest*
17719   glibcpp_cv_func__modfl_use=yes
17720 else
17721   echo "configure: failed program was:" >&5
17722   cat conftest.$ac_ext >&5
17723   rm -rf conftest*
17724   glibcpp_cv_func__modfl_use=no
17725 fi
17726 rm -f conftest*
17727       ac_ext=c
17728 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17729 ac_cpp='$CPP $CPPFLAGS'
17730 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17731 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17732 cross_compiling=$ac_cv_prog_cc_cross
17733
17734
17735 fi
17736
17737   fi
17738   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
17739   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
17740     for ac_func in _modfl
17741 do
17742 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17743 echo "configure:17744: checking for $ac_func" >&5
17744 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17745   echo $ac_n "(cached) $ac_c" 1>&6
17746 else
17747   cat > conftest.$ac_ext <<EOF
17748 #line 17749 "configure"
17749 #include "confdefs.h"
17750 /* System header to define __stub macros and hopefully few prototypes,
17751     which can conflict with char $ac_func(); below.  */
17752 #include <assert.h>
17753 /* Override any gcc2 internal prototype to avoid an error.  */
17754 /* We use char because int might match the return type of a gcc2
17755     builtin and then its argument prototype would still apply.  */
17756 char $ac_func();
17757
17758 int main() {
17759
17760 /* The GNU C library defines this for functions which it implements
17761     to always fail with ENOSYS.  Some functions are actually named
17762     something starting with __ and the normal name is an alias.  */
17763 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17764 choke me
17765 #else
17766 $ac_func();
17767 #endif
17768
17769 ; return 0; }
17770 EOF
17771 if { (eval echo configure:17772: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17772   rm -rf conftest*
17773   eval "ac_cv_func_$ac_func=yes"
17774 else
17775   echo "configure: failed program was:" >&5
17776   cat conftest.$ac_ext >&5
17777   rm -rf conftest*
17778   eval "ac_cv_func_$ac_func=no"
17779 fi
17780 rm -f conftest*
17781 fi
17782
17783 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17784   echo "$ac_t""yes" 1>&6
17785     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17786   cat >> confdefs.h <<EOF
17787 #define $ac_tr_func 1
17788 EOF
17789
17790 else
17791   echo "$ac_t""no" 1>&6
17792 fi
17793 done
17794
17795   fi
17796
17797
17798   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
17799 echo "configure:17800: checking for _powl declaration" >&5
17800   if test x${glibcpp_cv_func__powl_use+set} != xset; then
17801     if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
17802   echo $ac_n "(cached) $ac_c" 1>&6
17803 else
17804
17805
17806       ac_ext=C
17807 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17808 ac_cpp='$CXXCPP $CPPFLAGS'
17809 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17810 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17811 cross_compiling=$ac_cv_prog_cxx_cross
17812
17813       cat > conftest.$ac_ext <<EOF
17814 #line 17815 "configure"
17815 #include "confdefs.h"
17816 #include <math.h>
17817 int main() {
17818  _powl(0, 0);
17819 ; return 0; }
17820 EOF
17821 if { (eval echo configure:17822: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17822   rm -rf conftest*
17823   glibcpp_cv_func__powl_use=yes
17824 else
17825   echo "configure: failed program was:" >&5
17826   cat conftest.$ac_ext >&5
17827   rm -rf conftest*
17828   glibcpp_cv_func__powl_use=no
17829 fi
17830 rm -f conftest*
17831       ac_ext=c
17832 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17833 ac_cpp='$CPP $CPPFLAGS'
17834 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17835 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17836 cross_compiling=$ac_cv_prog_cc_cross
17837
17838
17839 fi
17840
17841   fi
17842   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
17843   if test x$glibcpp_cv_func__powl_use = x"yes"; then
17844     for ac_func in _powl
17845 do
17846 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17847 echo "configure:17848: checking for $ac_func" >&5
17848 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17849   echo $ac_n "(cached) $ac_c" 1>&6
17850 else
17851   cat > conftest.$ac_ext <<EOF
17852 #line 17853 "configure"
17853 #include "confdefs.h"
17854 /* System header to define __stub macros and hopefully few prototypes,
17855     which can conflict with char $ac_func(); below.  */
17856 #include <assert.h>
17857 /* Override any gcc2 internal prototype to avoid an error.  */
17858 /* We use char because int might match the return type of a gcc2
17859     builtin and then its argument prototype would still apply.  */
17860 char $ac_func();
17861
17862 int main() {
17863
17864 /* The GNU C library defines this for functions which it implements
17865     to always fail with ENOSYS.  Some functions are actually named
17866     something starting with __ and the normal name is an alias.  */
17867 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17868 choke me
17869 #else
17870 $ac_func();
17871 #endif
17872
17873 ; return 0; }
17874 EOF
17875 if { (eval echo configure:17876: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17876   rm -rf conftest*
17877   eval "ac_cv_func_$ac_func=yes"
17878 else
17879   echo "configure: failed program was:" >&5
17880   cat conftest.$ac_ext >&5
17881   rm -rf conftest*
17882   eval "ac_cv_func_$ac_func=no"
17883 fi
17884 rm -f conftest*
17885 fi
17886
17887 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17888   echo "$ac_t""yes" 1>&6
17889     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17890   cat >> confdefs.h <<EOF
17891 #define $ac_tr_func 1
17892 EOF
17893
17894 else
17895   echo "$ac_t""no" 1>&6
17896 fi
17897 done
17898
17899   fi
17900
17901
17902   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
17903 echo "configure:17904: checking for _sinl declaration" >&5
17904   if test x${glibcpp_cv_func__sinl_use+set} != xset; then
17905     if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
17906   echo $ac_n "(cached) $ac_c" 1>&6
17907 else
17908
17909
17910       ac_ext=C
17911 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17912 ac_cpp='$CXXCPP $CPPFLAGS'
17913 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17914 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17915 cross_compiling=$ac_cv_prog_cxx_cross
17916
17917       cat > conftest.$ac_ext <<EOF
17918 #line 17919 "configure"
17919 #include "confdefs.h"
17920 #include <math.h>
17921 int main() {
17922  _sinl(0);
17923 ; return 0; }
17924 EOF
17925 if { (eval echo configure:17926: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17926   rm -rf conftest*
17927   glibcpp_cv_func__sinl_use=yes
17928 else
17929   echo "configure: failed program was:" >&5
17930   cat conftest.$ac_ext >&5
17931   rm -rf conftest*
17932   glibcpp_cv_func__sinl_use=no
17933 fi
17934 rm -f conftest*
17935       ac_ext=c
17936 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17937 ac_cpp='$CPP $CPPFLAGS'
17938 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17939 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17940 cross_compiling=$ac_cv_prog_cc_cross
17941
17942
17943 fi
17944
17945   fi
17946   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
17947   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
17948     for ac_func in _sinl
17949 do
17950 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17951 echo "configure:17952: checking for $ac_func" >&5
17952 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17953   echo $ac_n "(cached) $ac_c" 1>&6
17954 else
17955   cat > conftest.$ac_ext <<EOF
17956 #line 17957 "configure"
17957 #include "confdefs.h"
17958 /* System header to define __stub macros and hopefully few prototypes,
17959     which can conflict with char $ac_func(); below.  */
17960 #include <assert.h>
17961 /* Override any gcc2 internal prototype to avoid an error.  */
17962 /* We use char because int might match the return type of a gcc2
17963     builtin and then its argument prototype would still apply.  */
17964 char $ac_func();
17965
17966 int main() {
17967
17968 /* The GNU C library defines this for functions which it implements
17969     to always fail with ENOSYS.  Some functions are actually named
17970     something starting with __ and the normal name is an alias.  */
17971 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17972 choke me
17973 #else
17974 $ac_func();
17975 #endif
17976
17977 ; return 0; }
17978 EOF
17979 if { (eval echo configure:17980: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17980   rm -rf conftest*
17981   eval "ac_cv_func_$ac_func=yes"
17982 else
17983   echo "configure: failed program was:" >&5
17984   cat conftest.$ac_ext >&5
17985   rm -rf conftest*
17986   eval "ac_cv_func_$ac_func=no"
17987 fi
17988 rm -f conftest*
17989 fi
17990
17991 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17992   echo "$ac_t""yes" 1>&6
17993     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17994   cat >> confdefs.h <<EOF
17995 #define $ac_tr_func 1
17996 EOF
17997
17998 else
17999   echo "$ac_t""no" 1>&6
18000 fi
18001 done
18002
18003   fi
18004
18005
18006   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
18007 echo "configure:18008: checking for _sinhl declaration" >&5
18008   if test x${glibcpp_cv_func__sinhl_use+set} != xset; then
18009     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
18010   echo $ac_n "(cached) $ac_c" 1>&6
18011 else
18012
18013
18014       ac_ext=C
18015 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18016 ac_cpp='$CXXCPP $CPPFLAGS'
18017 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18018 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18019 cross_compiling=$ac_cv_prog_cxx_cross
18020
18021       cat > conftest.$ac_ext <<EOF
18022 #line 18023 "configure"
18023 #include "confdefs.h"
18024 #include <math.h>
18025 int main() {
18026  _sinhl(0);
18027 ; return 0; }
18028 EOF
18029 if { (eval echo configure:18030: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18030   rm -rf conftest*
18031   glibcpp_cv_func__sinhl_use=yes
18032 else
18033   echo "configure: failed program was:" >&5
18034   cat conftest.$ac_ext >&5
18035   rm -rf conftest*
18036   glibcpp_cv_func__sinhl_use=no
18037 fi
18038 rm -f conftest*
18039       ac_ext=c
18040 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18041 ac_cpp='$CPP $CPPFLAGS'
18042 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18043 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18044 cross_compiling=$ac_cv_prog_cc_cross
18045
18046
18047 fi
18048
18049   fi
18050   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
18051   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
18052     for ac_func in _sinhl
18053 do
18054 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18055 echo "configure:18056: checking for $ac_func" >&5
18056 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18057   echo $ac_n "(cached) $ac_c" 1>&6
18058 else
18059   cat > conftest.$ac_ext <<EOF
18060 #line 18061 "configure"
18061 #include "confdefs.h"
18062 /* System header to define __stub macros and hopefully few prototypes,
18063     which can conflict with char $ac_func(); below.  */
18064 #include <assert.h>
18065 /* Override any gcc2 internal prototype to avoid an error.  */
18066 /* We use char because int might match the return type of a gcc2
18067     builtin and then its argument prototype would still apply.  */
18068 char $ac_func();
18069
18070 int main() {
18071
18072 /* The GNU C library defines this for functions which it implements
18073     to always fail with ENOSYS.  Some functions are actually named
18074     something starting with __ and the normal name is an alias.  */
18075 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18076 choke me
18077 #else
18078 $ac_func();
18079 #endif
18080
18081 ; return 0; }
18082 EOF
18083 if { (eval echo configure:18084: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18084   rm -rf conftest*
18085   eval "ac_cv_func_$ac_func=yes"
18086 else
18087   echo "configure: failed program was:" >&5
18088   cat conftest.$ac_ext >&5
18089   rm -rf conftest*
18090   eval "ac_cv_func_$ac_func=no"
18091 fi
18092 rm -f conftest*
18093 fi
18094
18095 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18096   echo "$ac_t""yes" 1>&6
18097     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18098   cat >> confdefs.h <<EOF
18099 #define $ac_tr_func 1
18100 EOF
18101
18102 else
18103   echo "$ac_t""no" 1>&6
18104 fi
18105 done
18106
18107   fi
18108
18109
18110   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
18111 echo "configure:18112: checking for _sqrtl declaration" >&5
18112   if test x${glibcpp_cv_func__sqrtl_use+set} != xset; then
18113     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
18114   echo $ac_n "(cached) $ac_c" 1>&6
18115 else
18116
18117
18118       ac_ext=C
18119 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18120 ac_cpp='$CXXCPP $CPPFLAGS'
18121 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18122 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18123 cross_compiling=$ac_cv_prog_cxx_cross
18124
18125       cat > conftest.$ac_ext <<EOF
18126 #line 18127 "configure"
18127 #include "confdefs.h"
18128 #include <math.h>
18129 int main() {
18130  _sqrtl(0);
18131 ; return 0; }
18132 EOF
18133 if { (eval echo configure:18134: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18134   rm -rf conftest*
18135   glibcpp_cv_func__sqrtl_use=yes
18136 else
18137   echo "configure: failed program was:" >&5
18138   cat conftest.$ac_ext >&5
18139   rm -rf conftest*
18140   glibcpp_cv_func__sqrtl_use=no
18141 fi
18142 rm -f conftest*
18143       ac_ext=c
18144 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18145 ac_cpp='$CPP $CPPFLAGS'
18146 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18147 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18148 cross_compiling=$ac_cv_prog_cc_cross
18149
18150
18151 fi
18152
18153   fi
18154   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
18155   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
18156     for ac_func in _sqrtl
18157 do
18158 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18159 echo "configure:18160: checking for $ac_func" >&5
18160 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18161   echo $ac_n "(cached) $ac_c" 1>&6
18162 else
18163   cat > conftest.$ac_ext <<EOF
18164 #line 18165 "configure"
18165 #include "confdefs.h"
18166 /* System header to define __stub macros and hopefully few prototypes,
18167     which can conflict with char $ac_func(); below.  */
18168 #include <assert.h>
18169 /* Override any gcc2 internal prototype to avoid an error.  */
18170 /* We use char because int might match the return type of a gcc2
18171     builtin and then its argument prototype would still apply.  */
18172 char $ac_func();
18173
18174 int main() {
18175
18176 /* The GNU C library defines this for functions which it implements
18177     to always fail with ENOSYS.  Some functions are actually named
18178     something starting with __ and the normal name is an alias.  */
18179 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18180 choke me
18181 #else
18182 $ac_func();
18183 #endif
18184
18185 ; return 0; }
18186 EOF
18187 if { (eval echo configure:18188: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18188   rm -rf conftest*
18189   eval "ac_cv_func_$ac_func=yes"
18190 else
18191   echo "configure: failed program was:" >&5
18192   cat conftest.$ac_ext >&5
18193   rm -rf conftest*
18194   eval "ac_cv_func_$ac_func=no"
18195 fi
18196 rm -f conftest*
18197 fi
18198
18199 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18200   echo "$ac_t""yes" 1>&6
18201     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18202   cat >> confdefs.h <<EOF
18203 #define $ac_tr_func 1
18204 EOF
18205
18206 else
18207   echo "$ac_t""no" 1>&6
18208 fi
18209 done
18210
18211   fi
18212
18213
18214   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
18215 echo "configure:18216: checking for _tanl declaration" >&5
18216   if test x${glibcpp_cv_func__tanl_use+set} != xset; then
18217     if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
18218   echo $ac_n "(cached) $ac_c" 1>&6
18219 else
18220
18221
18222       ac_ext=C
18223 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18224 ac_cpp='$CXXCPP $CPPFLAGS'
18225 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18226 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18227 cross_compiling=$ac_cv_prog_cxx_cross
18228
18229       cat > conftest.$ac_ext <<EOF
18230 #line 18231 "configure"
18231 #include "confdefs.h"
18232 #include <math.h>
18233 int main() {
18234  _tanl(0);
18235 ; return 0; }
18236 EOF
18237 if { (eval echo configure:18238: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18238   rm -rf conftest*
18239   glibcpp_cv_func__tanl_use=yes
18240 else
18241   echo "configure: failed program was:" >&5
18242   cat conftest.$ac_ext >&5
18243   rm -rf conftest*
18244   glibcpp_cv_func__tanl_use=no
18245 fi
18246 rm -f conftest*
18247       ac_ext=c
18248 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18249 ac_cpp='$CPP $CPPFLAGS'
18250 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18251 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18252 cross_compiling=$ac_cv_prog_cc_cross
18253
18254
18255 fi
18256
18257   fi
18258   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
18259   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
18260     for ac_func in _tanl
18261 do
18262 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18263 echo "configure:18264: checking for $ac_func" >&5
18264 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18265   echo $ac_n "(cached) $ac_c" 1>&6
18266 else
18267   cat > conftest.$ac_ext <<EOF
18268 #line 18269 "configure"
18269 #include "confdefs.h"
18270 /* System header to define __stub macros and hopefully few prototypes,
18271     which can conflict with char $ac_func(); below.  */
18272 #include <assert.h>
18273 /* Override any gcc2 internal prototype to avoid an error.  */
18274 /* We use char because int might match the return type of a gcc2
18275     builtin and then its argument prototype would still apply.  */
18276 char $ac_func();
18277
18278 int main() {
18279
18280 /* The GNU C library defines this for functions which it implements
18281     to always fail with ENOSYS.  Some functions are actually named
18282     something starting with __ and the normal name is an alias.  */
18283 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18284 choke me
18285 #else
18286 $ac_func();
18287 #endif
18288
18289 ; return 0; }
18290 EOF
18291 if { (eval echo configure:18292: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18292   rm -rf conftest*
18293   eval "ac_cv_func_$ac_func=yes"
18294 else
18295   echo "configure: failed program was:" >&5
18296   cat conftest.$ac_ext >&5
18297   rm -rf conftest*
18298   eval "ac_cv_func_$ac_func=no"
18299 fi
18300 rm -f conftest*
18301 fi
18302
18303 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18304   echo "$ac_t""yes" 1>&6
18305     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18306   cat >> confdefs.h <<EOF
18307 #define $ac_tr_func 1
18308 EOF
18309
18310 else
18311   echo "$ac_t""no" 1>&6
18312 fi
18313 done
18314
18315   fi
18316
18317
18318   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
18319 echo "configure:18320: checking for _tanhl declaration" >&5
18320   if test x${glibcpp_cv_func__tanhl_use+set} != xset; then
18321     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
18322   echo $ac_n "(cached) $ac_c" 1>&6
18323 else
18324
18325
18326       ac_ext=C
18327 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18328 ac_cpp='$CXXCPP $CPPFLAGS'
18329 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18330 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18331 cross_compiling=$ac_cv_prog_cxx_cross
18332
18333       cat > conftest.$ac_ext <<EOF
18334 #line 18335 "configure"
18335 #include "confdefs.h"
18336 #include <math.h>
18337 int main() {
18338  _tanhl(0);
18339 ; return 0; }
18340 EOF
18341 if { (eval echo configure:18342: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18342   rm -rf conftest*
18343   glibcpp_cv_func__tanhl_use=yes
18344 else
18345   echo "configure: failed program was:" >&5
18346   cat conftest.$ac_ext >&5
18347   rm -rf conftest*
18348   glibcpp_cv_func__tanhl_use=no
18349 fi
18350 rm -f conftest*
18351       ac_ext=c
18352 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18353 ac_cpp='$CPP $CPPFLAGS'
18354 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18355 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18356 cross_compiling=$ac_cv_prog_cc_cross
18357
18358
18359 fi
18360
18361   fi
18362   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
18363   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
18364     for ac_func in _tanhl
18365 do
18366 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18367 echo "configure:18368: checking for $ac_func" >&5
18368 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18369   echo $ac_n "(cached) $ac_c" 1>&6
18370 else
18371   cat > conftest.$ac_ext <<EOF
18372 #line 18373 "configure"
18373 #include "confdefs.h"
18374 /* System header to define __stub macros and hopefully few prototypes,
18375     which can conflict with char $ac_func(); below.  */
18376 #include <assert.h>
18377 /* Override any gcc2 internal prototype to avoid an error.  */
18378 /* We use char because int might match the return type of a gcc2
18379     builtin and then its argument prototype would still apply.  */
18380 char $ac_func();
18381
18382 int main() {
18383
18384 /* The GNU C library defines this for functions which it implements
18385     to always fail with ENOSYS.  Some functions are actually named
18386     something starting with __ and the normal name is an alias.  */
18387 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18388 choke me
18389 #else
18390 $ac_func();
18391 #endif
18392
18393 ; return 0; }
18394 EOF
18395 if { (eval echo configure:18396: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18396   rm -rf conftest*
18397   eval "ac_cv_func_$ac_func=yes"
18398 else
18399   echo "configure: failed program was:" >&5
18400   cat conftest.$ac_ext >&5
18401   rm -rf conftest*
18402   eval "ac_cv_func_$ac_func=no"
18403 fi
18404 rm -f conftest*
18405 fi
18406
18407 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18408   echo "$ac_t""yes" 1>&6
18409     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18410   cat >> confdefs.h <<EOF
18411 #define $ac_tr_func 1
18412 EOF
18413
18414 else
18415   echo "$ac_t""no" 1>&6
18416 fi
18417 done
18418
18419   fi
18420
18421
18422   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
18423 echo "configure:18424: checking for _sincosl declaration" >&5
18424   if test x${glibcpp_cv_func__sincosl_use+set} != xset; then
18425     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
18426   echo $ac_n "(cached) $ac_c" 1>&6
18427 else
18428
18429
18430       ac_ext=C
18431 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18432 ac_cpp='$CXXCPP $CPPFLAGS'
18433 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18434 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18435 cross_compiling=$ac_cv_prog_cxx_cross
18436
18437       cat > conftest.$ac_ext <<EOF
18438 #line 18439 "configure"
18439 #include "confdefs.h"
18440 #include <math.h>
18441 int main() {
18442  _sincosl(0, 0, 0);
18443 ; return 0; }
18444 EOF
18445 if { (eval echo configure:18446: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18446   rm -rf conftest*
18447   glibcpp_cv_func__sincosl_use=yes
18448 else
18449   echo "configure: failed program was:" >&5
18450   cat conftest.$ac_ext >&5
18451   rm -rf conftest*
18452   glibcpp_cv_func__sincosl_use=no
18453 fi
18454 rm -f conftest*
18455       ac_ext=c
18456 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18457 ac_cpp='$CPP $CPPFLAGS'
18458 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18459 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18460 cross_compiling=$ac_cv_prog_cc_cross
18461
18462
18463 fi
18464
18465   fi
18466   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
18467   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
18468     for ac_func in _sincosl
18469 do
18470 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18471 echo "configure:18472: checking for $ac_func" >&5
18472 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18473   echo $ac_n "(cached) $ac_c" 1>&6
18474 else
18475   cat > conftest.$ac_ext <<EOF
18476 #line 18477 "configure"
18477 #include "confdefs.h"
18478 /* System header to define __stub macros and hopefully few prototypes,
18479     which can conflict with char $ac_func(); below.  */
18480 #include <assert.h>
18481 /* Override any gcc2 internal prototype to avoid an error.  */
18482 /* We use char because int might match the return type of a gcc2
18483     builtin and then its argument prototype would still apply.  */
18484 char $ac_func();
18485
18486 int main() {
18487
18488 /* The GNU C library defines this for functions which it implements
18489     to always fail with ENOSYS.  Some functions are actually named
18490     something starting with __ and the normal name is an alias.  */
18491 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18492 choke me
18493 #else
18494 $ac_func();
18495 #endif
18496
18497 ; return 0; }
18498 EOF
18499 if { (eval echo configure:18500: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18500   rm -rf conftest*
18501   eval "ac_cv_func_$ac_func=yes"
18502 else
18503   echo "configure: failed program was:" >&5
18504   cat conftest.$ac_ext >&5
18505   rm -rf conftest*
18506   eval "ac_cv_func_$ac_func=no"
18507 fi
18508 rm -f conftest*
18509 fi
18510
18511 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18512   echo "$ac_t""yes" 1>&6
18513     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18514   cat >> confdefs.h <<EOF
18515 #define $ac_tr_func 1
18516 EOF
18517
18518 else
18519   echo "$ac_t""no" 1>&6
18520 fi
18521 done
18522
18523   fi
18524
18525
18526   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
18527 echo "configure:18528: checking for _finitel declaration" >&5
18528   if test x${glibcpp_cv_func__finitel_use+set} != xset; then
18529     if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
18530   echo $ac_n "(cached) $ac_c" 1>&6
18531 else
18532
18533
18534       ac_ext=C
18535 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18536 ac_cpp='$CXXCPP $CPPFLAGS'
18537 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18538 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18539 cross_compiling=$ac_cv_prog_cxx_cross
18540
18541       cat > conftest.$ac_ext <<EOF
18542 #line 18543 "configure"
18543 #include "confdefs.h"
18544 #include <math.h>
18545 int main() {
18546  _finitel(0);
18547 ; return 0; }
18548 EOF
18549 if { (eval echo configure:18550: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18550   rm -rf conftest*
18551   glibcpp_cv_func__finitel_use=yes
18552 else
18553   echo "configure: failed program was:" >&5
18554   cat conftest.$ac_ext >&5
18555   rm -rf conftest*
18556   glibcpp_cv_func__finitel_use=no
18557 fi
18558 rm -f conftest*
18559       ac_ext=c
18560 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18561 ac_cpp='$CPP $CPPFLAGS'
18562 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18563 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18564 cross_compiling=$ac_cv_prog_cc_cross
18565
18566
18567 fi
18568
18569   fi
18570   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
18571   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
18572     for ac_func in _finitel
18573 do
18574 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18575 echo "configure:18576: checking for $ac_func" >&5
18576 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18577   echo $ac_n "(cached) $ac_c" 1>&6
18578 else
18579   cat > conftest.$ac_ext <<EOF
18580 #line 18581 "configure"
18581 #include "confdefs.h"
18582 /* System header to define __stub macros and hopefully few prototypes,
18583     which can conflict with char $ac_func(); below.  */
18584 #include <assert.h>
18585 /* Override any gcc2 internal prototype to avoid an error.  */
18586 /* We use char because int might match the return type of a gcc2
18587     builtin and then its argument prototype would still apply.  */
18588 char $ac_func();
18589
18590 int main() {
18591
18592 /* The GNU C library defines this for functions which it implements
18593     to always fail with ENOSYS.  Some functions are actually named
18594     something starting with __ and the normal name is an alias.  */
18595 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18596 choke me
18597 #else
18598 $ac_func();
18599 #endif
18600
18601 ; return 0; }
18602 EOF
18603 if { (eval echo configure:18604: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18604   rm -rf conftest*
18605   eval "ac_cv_func_$ac_func=yes"
18606 else
18607   echo "configure: failed program was:" >&5
18608   cat conftest.$ac_ext >&5
18609   rm -rf conftest*
18610   eval "ac_cv_func_$ac_func=no"
18611 fi
18612 rm -f conftest*
18613 fi
18614
18615 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18616   echo "$ac_t""yes" 1>&6
18617     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18618   cat >> confdefs.h <<EOF
18619 #define $ac_tr_func 1
18620 EOF
18621
18622 else
18623   echo "$ac_t""no" 1>&6
18624 fi
18625 done
18626
18627   fi
18628
18629
18630   LIBS="$ac_save_LIBS"
18631   CXXFLAGS="$ac_save_CXXFLAGS"
18632
18633
18634     for ac_hdr in complex.h
18635 do
18636 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18637 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18638 echo "configure:18639: checking for $ac_hdr" >&5
18639 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18640   echo $ac_n "(cached) $ac_c" 1>&6
18641 else
18642   cat > conftest.$ac_ext <<EOF
18643 #line 18644 "configure"
18644 #include "confdefs.h"
18645 #include <$ac_hdr>
18646 EOF
18647 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18648 { (eval echo configure:18649: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18649 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18650 if test -z "$ac_err"; then
18651   rm -rf conftest*
18652   eval "ac_cv_header_$ac_safe=yes"
18653 else
18654   echo "$ac_err" >&5
18655   echo "configure: failed program was:" >&5
18656   cat conftest.$ac_ext >&5
18657   rm -rf conftest*
18658   eval "ac_cv_header_$ac_safe=no"
18659 fi
18660 rm -f conftest*
18661 fi
18662 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18663   echo "$ac_t""yes" 1>&6
18664     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18665   cat >> confdefs.h <<EOF
18666 #define $ac_tr_hdr 1
18667 EOF
18668
18669 else
18670   echo "$ac_t""no" 1>&6
18671 fi
18672 done
18673
18674   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
18675 echo "configure:18676: checking for main in -lm" >&5
18676 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
18677 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
18678   echo $ac_n "(cached) $ac_c" 1>&6
18679 else
18680   ac_save_LIBS="$LIBS"
18681 LIBS="-lm  $LIBS"
18682 cat > conftest.$ac_ext <<EOF
18683 #line 18684 "configure"
18684 #include "confdefs.h"
18685
18686 int main() {
18687 main()
18688 ; return 0; }
18689 EOF
18690 if { (eval echo configure:18691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18691   rm -rf conftest*
18692   eval "ac_cv_lib_$ac_lib_var=yes"
18693 else
18694   echo "configure: failed program was:" >&5
18695   cat conftest.$ac_ext >&5
18696   rm -rf conftest*
18697   eval "ac_cv_lib_$ac_lib_var=no"
18698 fi
18699 rm -f conftest*
18700 LIBS="$ac_save_LIBS"
18701
18702 fi
18703 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
18704   echo "$ac_t""yes" 1>&6
18705     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
18706     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
18707   cat >> confdefs.h <<EOF
18708 #define $ac_tr_lib 1
18709 EOF
18710
18711   LIBS="-lm $LIBS"
18712
18713 else
18714   echo "$ac_t""no" 1>&6
18715 fi
18716
18717   for ac_func in csqrt csqrtf nan hypot hypotf
18718 do
18719 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18720 echo "configure:18721: checking for $ac_func" >&5
18721 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18722   echo $ac_n "(cached) $ac_c" 1>&6
18723 else
18724   cat > conftest.$ac_ext <<EOF
18725 #line 18726 "configure"
18726 #include "confdefs.h"
18727 /* System header to define __stub macros and hopefully few prototypes,
18728     which can conflict with char $ac_func(); below.  */
18729 #include <assert.h>
18730 /* Override any gcc2 internal prototype to avoid an error.  */
18731 /* We use char because int might match the return type of a gcc2
18732     builtin and then its argument prototype would still apply.  */
18733 char $ac_func();
18734
18735 int main() {
18736
18737 /* The GNU C library defines this for functions which it implements
18738     to always fail with ENOSYS.  Some functions are actually named
18739     something starting with __ and the normal name is an alias.  */
18740 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18741 choke me
18742 #else
18743 $ac_func();
18744 #endif
18745
18746 ; return 0; }
18747 EOF
18748 if { (eval echo configure:18749: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18749   rm -rf conftest*
18750   eval "ac_cv_func_$ac_func=yes"
18751 else
18752   echo "configure: failed program was:" >&5
18753   cat conftest.$ac_ext >&5
18754   rm -rf conftest*
18755   eval "ac_cv_func_$ac_func=no"
18756 fi
18757 rm -f conftest*
18758 fi
18759
18760 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18761   echo "$ac_t""yes" 1>&6
18762     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18763   cat >> confdefs.h <<EOF
18764 #define $ac_tr_func 1
18765 EOF
18766
18767 else
18768   echo "$ac_t""no" 1>&6
18769 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18770 fi
18771 done
18772
18773
18774
18775           USE_COMPLEX_LONG_DOUBLE=no
18776   if test x$ac_cv_func_atan2l = x"yes" \
18777      && test x$ac_cv_func_copysignl = x"yes"; then
18778     USE_COMPLEX_LONG_DOUBLE=yes
18779     for ac_func in csqrtl hypotl signbitl
18780 do
18781 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18782 echo "configure:18783: checking for $ac_func" >&5
18783 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18784   echo $ac_n "(cached) $ac_c" 1>&6
18785 else
18786   cat > conftest.$ac_ext <<EOF
18787 #line 18788 "configure"
18788 #include "confdefs.h"
18789 /* System header to define __stub macros and hopefully few prototypes,
18790     which can conflict with char $ac_func(); below.  */
18791 #include <assert.h>
18792 /* Override any gcc2 internal prototype to avoid an error.  */
18793 /* We use char because int might match the return type of a gcc2
18794     builtin and then its argument prototype would still apply.  */
18795 char $ac_func();
18796
18797 int main() {
18798
18799 /* The GNU C library defines this for functions which it implements
18800     to always fail with ENOSYS.  Some functions are actually named
18801     something starting with __ and the normal name is an alias.  */
18802 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18803 choke me
18804 #else
18805 $ac_func();
18806 #endif
18807
18808 ; return 0; }
18809 EOF
18810 if { (eval echo configure:18811: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18811   rm -rf conftest*
18812   eval "ac_cv_func_$ac_func=yes"
18813 else
18814   echo "configure: failed program was:" >&5
18815   cat conftest.$ac_ext >&5
18816   rm -rf conftest*
18817   eval "ac_cv_func_$ac_func=no"
18818 fi
18819 rm -f conftest*
18820 fi
18821
18822 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18823   echo "$ac_t""yes" 1>&6
18824     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18825   cat >> confdefs.h <<EOF
18826 #define $ac_tr_func 1
18827 EOF
18828
18829 else
18830   echo "$ac_t""no" 1>&6
18831 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18832 fi
18833 done
18834
18835
18836   fi
18837
18838
18839
18840
18841
18842
18843   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
18844 echo "configure:18845: checking for GNU C++ __complex__ support" >&5
18845   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
18846   echo $ac_n "(cached) $ac_c" 1>&6
18847 else
18848
18849
18850     ac_ext=C
18851 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18852 ac_cpp='$CXXCPP $CPPFLAGS'
18853 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18854 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18855 cross_compiling=$ac_cv_prog_cxx_cross
18856
18857     cat > conftest.$ac_ext <<EOF
18858 #line 18859 "configure"
18859 #include "confdefs.h"
18860 struct dcomplex { __complex__ double x; }; \
18861                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
18862 int main() {
18863 \
18864                      dcomplex x; f(x);
18865 ; return 0; }
18866 EOF
18867 if { (eval echo configure:18868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18868   rm -rf conftest*
18869   glibcpp_cv_complex=ok
18870 else
18871   echo "configure: failed program was:" >&5
18872   cat conftest.$ac_ext >&5
18873   rm -rf conftest*
18874   glibcpp_cv_complex=buggy
18875
18876 fi
18877 rm -f conftest*
18878     ac_ext=c
18879 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18880 ac_cpp='$CPP $CPPFLAGS'
18881 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18882 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18883 cross_compiling=$ac_cv_prog_cc_cross
18884
18885
18886 fi
18887
18888   echo "$ac_t""$glibcpp_cv_complex" 1>&6
18889   if test $glibcpp_cv_complex = buggy; then
18890     cat >> confdefs.h <<\EOF
18891 #define _GLIBCPP_BUGGY_COMPLEX 1
18892 EOF
18893
18894   fi
18895
18896   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
18897 echo "configure:18898: checking for GNU C++ __complex__ float support" >&5
18898   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
18899   echo $ac_n "(cached) $ac_c" 1>&6
18900 else
18901
18902
18903     ac_ext=C
18904 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18905 ac_cpp='$CXXCPP $CPPFLAGS'
18906 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18907 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18908 cross_compiling=$ac_cv_prog_cxx_cross
18909
18910     rm -f conftest.h
18911     cat > conftest.h <<EOB
18912       //
18913       // Check for buggy __complex__ that causes ICE in most versions of egcs
18914       // and gcc-2.95.x on certain platforms (eg., x86-win32).
18915       //
18916       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
18917       // more info on the bug itself.
18918       //
18919       struct
18920       float_complex
18921       {
18922        __complex__ float m_value;
18923        float_complex (float = 0.0f, float = 0.0f);
18924        float_complex (__complex__ float val) : m_value (val) {}
18925        float_complex foo (const float_complex &val)
18926          { return float_complex (~val.m_value); }
18927       };
18928 EOB
18929     cat > conftest.$ac_ext <<EOF
18930 #line 18931 "configure"
18931 #include "confdefs.h"
18932 #include "conftest.h"
18933 int main() {
18934
18935 ; return 0; }
18936 EOF
18937 if { (eval echo configure:18938: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18938   rm -rf conftest*
18939   glibcpp_cv_float_complex=ok
18940 else
18941   echo "configure: failed program was:" >&5
18942   cat conftest.$ac_ext >&5
18943   rm -rf conftest*
18944   glibcpp_cv_float_complex=buggy
18945
18946 fi
18947 rm -f conftest*
18948     ac_ext=c
18949 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18950 ac_cpp='$CPP $CPPFLAGS'
18951 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18952 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18953 cross_compiling=$ac_cv_prog_cc_cross
18954
18955
18956 fi
18957
18958   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
18959   if test $glibcpp_cv_float_complex = buggy; then
18960     cat >> confdefs.h <<\EOF
18961 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
18962 EOF
18963
18964   fi
18965
18966
18967   if test x$enable_c_mbchar != xno; then
18968
18969         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
18970 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
18971 echo "configure:18972: checking for wchar.h" >&5
18972 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18973   echo $ac_n "(cached) $ac_c" 1>&6
18974 else
18975   cat > conftest.$ac_ext <<EOF
18976 #line 18977 "configure"
18977 #include "confdefs.h"
18978 #include <wchar.h>
18979 EOF
18980 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18981 { (eval echo configure:18982: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18982 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18983 if test -z "$ac_err"; then
18984   rm -rf conftest*
18985   eval "ac_cv_header_$ac_safe=yes"
18986 else
18987   echo "$ac_err" >&5
18988   echo "configure: failed program was:" >&5
18989   cat conftest.$ac_ext >&5
18990   rm -rf conftest*
18991   eval "ac_cv_header_$ac_safe=no"
18992 fi
18993 rm -f conftest*
18994 fi
18995 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18996   echo "$ac_t""yes" 1>&6
18997   ac_has_wchar_h=yes
18998 else
18999   echo "$ac_t""no" 1>&6
19000 ac_has_wchar_h=no
19001 fi
19002
19003     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
19004 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
19005 echo "configure:19006: checking for wctype.h" >&5
19006 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19007   echo $ac_n "(cached) $ac_c" 1>&6
19008 else
19009   cat > conftest.$ac_ext <<EOF
19010 #line 19011 "configure"
19011 #include "confdefs.h"
19012 #include <wctype.h>
19013 EOF
19014 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19015 { (eval echo configure:19016: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19016 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19017 if test -z "$ac_err"; then
19018   rm -rf conftest*
19019   eval "ac_cv_header_$ac_safe=yes"
19020 else
19021   echo "$ac_err" >&5
19022   echo "configure: failed program was:" >&5
19023   cat conftest.$ac_ext >&5
19024   rm -rf conftest*
19025   eval "ac_cv_header_$ac_safe=no"
19026 fi
19027 rm -f conftest*
19028 fi
19029 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19030   echo "$ac_t""yes" 1>&6
19031   ac_has_wctype_h=yes
19032 else
19033   echo "$ac_t""no" 1>&6
19034 ac_has_wctype_h=no
19035 fi
19036
19037
19038         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
19039
19040                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
19041 echo "configure:19042: checking for mbstate_t" >&5
19042       cat > conftest.$ac_ext <<EOF
19043 #line 19044 "configure"
19044 #include "confdefs.h"
19045 #include <wchar.h>
19046 int main() {
19047 mbstate_t teststate;
19048 ; return 0; }
19049 EOF
19050 if { (eval echo configure:19051: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19051   rm -rf conftest*
19052   use_native_mbstatet=yes
19053 else
19054   echo "configure: failed program was:" >&5
19055   cat conftest.$ac_ext >&5
19056   rm -rf conftest*
19057   use_native_mbstatet=no
19058 fi
19059 rm -f conftest*
19060       echo "$ac_t""$use_native_mbstatet" 1>&6
19061
19062                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
19063 echo "configure:19064: checking for WCHAR_MIN and WCHAR_MAX" >&5
19064       cat > conftest.$ac_ext <<EOF
19065 #line 19066 "configure"
19066 #include "confdefs.h"
19067 #include <wchar.h>
19068 int main() {
19069 int i = WCHAR_MIN; int j = WCHAR_MAX;
19070 ; return 0; }
19071 EOF
19072 if { (eval echo configure:19073: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19073   rm -rf conftest*
19074   has_wchar_minmax=yes
19075 else
19076   echo "configure: failed program was:" >&5
19077   cat conftest.$ac_ext >&5
19078   rm -rf conftest*
19079   has_wchar_minmax=no
19080 fi
19081 rm -f conftest*
19082       echo "$ac_t""$has_wchar_minmax" 1>&6
19083
19084                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
19085 echo "configure:19086: checking for WEOF" >&5
19086       cat > conftest.$ac_ext <<EOF
19087 #line 19088 "configure"
19088 #include "confdefs.h"
19089
19090         #include <wchar.h>
19091         #include <stddef.h>
19092 int main() {
19093 wint_t i = WEOF;
19094 ; return 0; }
19095 EOF
19096 if { (eval echo configure:19097: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19097   rm -rf conftest*
19098   has_weof=yes
19099 else
19100   echo "configure: failed program was:" >&5
19101   cat conftest.$ac_ext >&5
19102   rm -rf conftest*
19103   has_weof=no
19104 fi
19105 rm -f conftest*
19106       echo "$ac_t""$has_weof" 1>&6
19107
19108             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
19109       wcsrtombs mbsrtowcs
19110 do
19111 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19112 echo "configure:19113: checking for $ac_func" >&5
19113 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19114   echo $ac_n "(cached) $ac_c" 1>&6
19115 else
19116   cat > conftest.$ac_ext <<EOF
19117 #line 19118 "configure"
19118 #include "confdefs.h"
19119 /* System header to define __stub macros and hopefully few prototypes,
19120     which can conflict with char $ac_func(); below.  */
19121 #include <assert.h>
19122 /* Override any gcc2 internal prototype to avoid an error.  */
19123 /* We use char because int might match the return type of a gcc2
19124     builtin and then its argument prototype would still apply.  */
19125 char $ac_func();
19126
19127 int main() {
19128
19129 /* The GNU C library defines this for functions which it implements
19130     to always fail with ENOSYS.  Some functions are actually named
19131     something starting with __ and the normal name is an alias.  */
19132 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19133 choke me
19134 #else
19135 $ac_func();
19136 #endif
19137
19138 ; return 0; }
19139 EOF
19140 if { (eval echo configure:19141: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19141   rm -rf conftest*
19142   eval "ac_cv_func_$ac_func=yes"
19143 else
19144   echo "configure: failed program was:" >&5
19145   cat conftest.$ac_ext >&5
19146   rm -rf conftest*
19147   eval "ac_cv_func_$ac_func=no"
19148 fi
19149 rm -f conftest*
19150 fi
19151
19152 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19153   echo "$ac_t""yes" 1>&6
19154     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19155   cat >> confdefs.h <<EOF
19156 #define $ac_tr_func 1
19157 EOF
19158  ac_wfuncs=yes
19159 else
19160   echo "$ac_t""no" 1>&6
19161 ac_wfuncs=no
19162 fi
19163 done
19164
19165
19166       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
19167 echo "configure:19168: checking for ISO C99 wchar_t support" >&5
19168       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
19169          && test x"$ac_wfuncs" = xyes; then
19170         ac_isoC99_wchar_t=yes
19171       else
19172         ac_isoC99_wchar_t=no
19173       fi
19174       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
19175
19176                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
19177 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
19178 echo "configure:19179: checking for iconv.h" >&5
19179 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19180   echo $ac_n "(cached) $ac_c" 1>&6
19181 else
19182   cat > conftest.$ac_ext <<EOF
19183 #line 19184 "configure"
19184 #include "confdefs.h"
19185 #include <iconv.h>
19186 EOF
19187 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19188 { (eval echo configure:19189: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19189 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19190 if test -z "$ac_err"; then
19191   rm -rf conftest*
19192   eval "ac_cv_header_$ac_safe=yes"
19193 else
19194   echo "$ac_err" >&5
19195   echo "configure: failed program was:" >&5
19196   cat conftest.$ac_ext >&5
19197   rm -rf conftest*
19198   eval "ac_cv_header_$ac_safe=no"
19199 fi
19200 rm -f conftest*
19201 fi
19202 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19203   echo "$ac_t""yes" 1>&6
19204   ac_has_iconv_h=yes
19205 else
19206   echo "$ac_t""no" 1>&6
19207 ac_has_iconv_h=no
19208 fi
19209
19210       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
19211 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
19212 echo "configure:19213: checking for langinfo.h" >&5
19213 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19214   echo $ac_n "(cached) $ac_c" 1>&6
19215 else
19216   cat > conftest.$ac_ext <<EOF
19217 #line 19218 "configure"
19218 #include "confdefs.h"
19219 #include <langinfo.h>
19220 EOF
19221 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19222 { (eval echo configure:19223: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19223 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19224 if test -z "$ac_err"; then
19225   rm -rf conftest*
19226   eval "ac_cv_header_$ac_safe=yes"
19227 else
19228   echo "$ac_err" >&5
19229   echo "configure: failed program was:" >&5
19230   cat conftest.$ac_ext >&5
19231   rm -rf conftest*
19232   eval "ac_cv_header_$ac_safe=no"
19233 fi
19234 rm -f conftest*
19235 fi
19236 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19237   echo "$ac_t""yes" 1>&6
19238   ac_has_langinfo_h=yes
19239 else
19240   echo "$ac_t""no" 1>&6
19241 ac_has_langinfo_h=no
19242 fi
19243
19244
19245             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
19246 echo "configure:19247: checking for iconv in -liconv" >&5
19247 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
19248 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
19249   echo $ac_n "(cached) $ac_c" 1>&6
19250 else
19251   ac_save_LIBS="$LIBS"
19252 LIBS="-liconv  $LIBS"
19253 cat > conftest.$ac_ext <<EOF
19254 #line 19255 "configure"
19255 #include "confdefs.h"
19256 /* Override any gcc2 internal prototype to avoid an error.  */
19257 /* We use char because int might match the return type of a gcc2
19258     builtin and then its argument prototype would still apply.  */
19259 char iconv();
19260
19261 int main() {
19262 iconv()
19263 ; return 0; }
19264 EOF
19265 if { (eval echo configure:19266: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19266   rm -rf conftest*
19267   eval "ac_cv_lib_$ac_lib_var=yes"
19268 else
19269   echo "configure: failed program was:" >&5
19270   cat conftest.$ac_ext >&5
19271   rm -rf conftest*
19272   eval "ac_cv_lib_$ac_lib_var=no"
19273 fi
19274 rm -f conftest*
19275 LIBS="$ac_save_LIBS"
19276
19277 fi
19278 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
19279   echo "$ac_t""yes" 1>&6
19280   libiconv="-liconv"
19281 else
19282   echo "$ac_t""no" 1>&6
19283 fi
19284
19285       ac_save_LIBS="$LIBS"
19286       LIBS="$LIBS $libiconv"
19287
19288       for ac_func in iconv_open iconv_close iconv nl_langinfo
19289 do
19290 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19291 echo "configure:19292: checking for $ac_func" >&5
19292 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19293   echo $ac_n "(cached) $ac_c" 1>&6
19294 else
19295   cat > conftest.$ac_ext <<EOF
19296 #line 19297 "configure"
19297 #include "confdefs.h"
19298 /* System header to define __stub macros and hopefully few prototypes,
19299     which can conflict with char $ac_func(); below.  */
19300 #include <assert.h>
19301 /* Override any gcc2 internal prototype to avoid an error.  */
19302 /* We use char because int might match the return type of a gcc2
19303     builtin and then its argument prototype would still apply.  */
19304 char $ac_func();
19305
19306 int main() {
19307
19308 /* The GNU C library defines this for functions which it implements
19309     to always fail with ENOSYS.  Some functions are actually named
19310     something starting with __ and the normal name is an alias.  */
19311 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19312 choke me
19313 #else
19314 $ac_func();
19315 #endif
19316
19317 ; return 0; }
19318 EOF
19319 if { (eval echo configure:19320: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19320   rm -rf conftest*
19321   eval "ac_cv_func_$ac_func=yes"
19322 else
19323   echo "configure: failed program was:" >&5
19324   cat conftest.$ac_ext >&5
19325   rm -rf conftest*
19326   eval "ac_cv_func_$ac_func=no"
19327 fi
19328 rm -f conftest*
19329 fi
19330
19331 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19332   echo "$ac_t""yes" 1>&6
19333     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19334   cat >> confdefs.h <<EOF
19335 #define $ac_tr_func 1
19336 EOF
19337  \
19338       ac_XPG2funcs=yes
19339 else
19340   echo "$ac_t""no" 1>&6
19341 ac_XPG2funcs=no
19342 fi
19343 done
19344
19345
19346       LIBS="$ac_save_LIBS"
19347
19348       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
19349 echo "configure:19350: checking for XPG2 wchar_t support" >&5
19350       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
19351          && test x"$ac_XPG2funcs" = xyes; then
19352         ac_XPG2_wchar_t=yes
19353       else
19354         ac_XPG2_wchar_t=no
19355       fi
19356       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
19357
19358                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
19359 echo "configure:19360: checking for enabled wchar_t specializations" >&5
19360       if test x"$ac_isoC99_wchar_t" = xyes \
19361          && test x"$ac_XPG2_wchar_t" = xyes; then
19362         libinst_wstring_la="libinst-wstring.la"
19363         cat >> confdefs.h <<\EOF
19364 #define _GLIBCPP_USE_WCHAR_T 1
19365 EOF
19366
19367         echo "$ac_t"""yes"" 1>&6
19368       else
19369         libinst_wstring_la=""
19370         echo "$ac_t"""no"" 1>&6
19371       fi
19372
19373
19374     else
19375       echo "configure: warning: <wchar.h> not found" 1>&2
19376     fi
19377
19378   else
19379         :
19380   fi
19381
19382
19383   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
19384 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
19385 echo "configure:19386: checking for ctype.h" >&5
19386 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19387   echo $ac_n "(cached) $ac_c" 1>&6
19388 else
19389   cat > conftest.$ac_ext <<EOF
19390 #line 19391 "configure"
19391 #include "confdefs.h"
19392 #include <ctype.h>
19393 EOF
19394 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19395 { (eval echo configure:19396: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19396 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19397 if test -z "$ac_err"; then
19398   rm -rf conftest*
19399   eval "ac_cv_header_$ac_safe=yes"
19400 else
19401   echo "$ac_err" >&5
19402   echo "configure: failed program was:" >&5
19403   cat conftest.$ac_ext >&5
19404   rm -rf conftest*
19405   eval "ac_cv_header_$ac_safe=no"
19406 fi
19407 rm -f conftest*
19408 fi
19409 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19410   echo "$ac_t""yes" 1>&6
19411
19412
19413         ctype_default=yes
19414
19415         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
19416 echo "configure:19417: checking <ctype> for GNU/Linux" >&5
19417     cat > conftest.$ac_ext <<EOF
19418 #line 19419 "configure"
19419 #include "confdefs.h"
19420 #include <ctype.h>
19421 int main() {
19422 int
19423     foo (int a)
19424     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
19425         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
19426         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
19427 ; return 0; }
19428 EOF
19429 if { (eval echo configure:19430: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19430   rm -rf conftest*
19431   \
19432     ctype_linux=yes
19433 else
19434   echo "configure: failed program was:" >&5
19435   cat conftest.$ac_ext >&5
19436   rm -rf conftest*
19437   ctype_linux=no
19438 fi
19439 rm -f conftest*
19440     echo "$ac_t""$ctype_linux" 1>&6
19441     if test $ctype_linux = "yes"; then
19442       ctype_include_dir="config/os/gnu-linux"
19443       ctype_default=no
19444     fi
19445
19446         if test $ctype_default = "yes"; then
19447     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
19448 echo "configure:19449: checking <ctype> for FreeBSD 4.0" >&5
19449     cat > conftest.$ac_ext <<EOF
19450 #line 19451 "configure"
19451 #include "confdefs.h"
19452 #include <ctype.h>
19453 int main() {
19454 int
19455     foo (int a)
19456     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
19457         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
19458 ; return 0; }
19459 EOF
19460 if { (eval echo configure:19461: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19461   rm -rf conftest*
19462   \
19463     ctype_bsd=yes
19464 else
19465   echo "configure: failed program was:" >&5
19466   cat conftest.$ac_ext >&5
19467   rm -rf conftest*
19468   ctype_bsd=no
19469 fi
19470 rm -f conftest*
19471     echo "$ac_t""$ctype_bsd" 1>&6
19472     if test $ctype_bsd = "yes"; then
19473       ctype_include_dir="config/os/bsd/freebsd"
19474       ctype_default=no
19475     fi
19476     fi
19477
19478         if test $ctype_default = "yes"; then
19479     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
19480 echo "configure:19481: checking <ctype> for FreeBSD 3.4" >&5
19481     cat > conftest.$ac_ext <<EOF
19482 #line 19483 "configure"
19483 #include "confdefs.h"
19484 #include <ctype.h>
19485 int main() {
19486 int
19487     foo (int a)
19488     { return _S + _R + _C + _U + _L + _A \
19489       + _D + _P + _X + _G + __istype (a, 0);}
19490 ; return 0; }
19491 EOF
19492 if { (eval echo configure:19493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19493   rm -rf conftest*
19494   \
19495     ctype_freebsd34=yes
19496 else
19497   echo "configure: failed program was:" >&5
19498   cat conftest.$ac_ext >&5
19499   rm -rf conftest*
19500   ctype_freebsd34=no
19501 fi
19502 rm -f conftest*
19503     echo "$ac_t""$ctype_freebsd34" 1>&6
19504     if test $ctype_freebsd34 = "yes"; then
19505       ctype_include_dir="config/os/bsd/freebsd"
19506       ctype_default=no
19507     fi
19508     fi
19509
19510         if test $ctype_default = "yes"; then
19511     echo $ac_n "checking <ctype> for NetBSD""... $ac_c" 1>&6
19512 echo "configure:19513: checking <ctype> for NetBSD" >&5
19513     cat > conftest.$ac_ext <<EOF
19514 #line 19515 "configure"
19515 #include "confdefs.h"
19516 #include <ctype.h>
19517 int main() {
19518 int
19519     foo (int a)
19520     { return _S + _C + _U + _L \
19521       + _N + _P + _X + _tolower_tab_[a] + _toupper_tab_[a];}
19522 ; return 0; }
19523 EOF
19524 if { (eval echo configure:19525: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19525   rm -rf conftest*
19526   \
19527     ctype_netbsd=yes
19528 else
19529   echo "configure: failed program was:" >&5
19530   cat conftest.$ac_ext >&5
19531   rm -rf conftest*
19532   ctype_netbsd=no
19533 fi
19534 rm -f conftest*
19535     echo "$ac_t""$ctype_netbsd" 1>&6
19536     if test $ctype_netbsd = "yes"; then
19537       ctype_include_dir="config/os/bsd/netbsd"
19538       ctype_default=no
19539     fi
19540     fi
19541
19542         if test $ctype_default = "yes"; then
19543     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
19544 echo "configure:19545: checking <ctype> for Solaris 2.6,7,8" >&5
19545     cat > conftest.$ac_ext <<EOF
19546 #line 19547 "configure"
19547 #include "confdefs.h"
19548 #include <ctype.h>
19549 int main() {
19550 int
19551     foo (int a)
19552     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
19553         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
19554         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
19555 ; return 0; }
19556 EOF
19557 if { (eval echo configure:19558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19558   rm -rf conftest*
19559   \
19560     ctype_solaris=yes
19561 else
19562   echo "configure: failed program was:" >&5
19563   cat conftest.$ac_ext >&5
19564   rm -rf conftest*
19565   ctype_solaris=no
19566 fi
19567 rm -f conftest*
19568     echo "$ac_t""$ctype_solaris" 1>&6
19569
19570     if test $ctype_solaris = "yes"; then
19571       echo $ac_n "checking   for version""... $ac_c" 1>&6
19572 echo "configure:19573: checking   for version" >&5
19573       ac_ext=C
19574 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19575 ac_cpp='$CXXCPP $CPPFLAGS'
19576 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19577 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19578 cross_compiling=$ac_cv_prog_cxx_cross
19579
19580       cat > conftest.$ac_ext <<EOF
19581 #line 19582 "configure"
19582 #include "confdefs.h"
19583 #include <ctype.h>
19584 int main() {
19585 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
19586 ; return 0; }
19587 EOF
19588 if { (eval echo configure:19589: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19589   rm -rf conftest*
19590   \
19591       ctype_solaris26=yes
19592 else
19593   echo "configure: failed program was:" >&5
19594   cat conftest.$ac_ext >&5
19595   rm -rf conftest*
19596   ctype_solaris26=no
19597 fi
19598 rm -f conftest*
19599       ac_ext=c
19600 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19601 ac_cpp='$CPP $CPPFLAGS'
19602 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19603 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19604 cross_compiling=$ac_cv_prog_cc_cross
19605
19606       if test $ctype_solaris26 = "yes"; then
19607         ctype_include_dir="config/os/solaris/solaris2.6"
19608         echo "$ac_t""Solaris 2.6" 1>&6
19609         ctype_default=no
19610       else
19611         ctype_include_dir="config/os/solaris/solaris2.7"
19612         echo "$ac_t""Solaris 7,8" 1>&6
19613         ctype_default=no
19614       fi
19615     fi
19616     fi
19617
19618         if test $ctype_default = "yes"; then
19619     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
19620 echo "configure:19621: checking <ctype> for Solaris 2.5.1" >&5
19621     cat > conftest.$ac_ext <<EOF
19622 #line 19623 "configure"
19623 #include "confdefs.h"
19624 #include <ctype.h>
19625 int main() {
19626 int
19627     foo (int a)
19628     { return _U + _L + _N + _S + _P + _C + _X + _B \
19629         + __ctype[a];}
19630 ; return 0; }
19631 EOF
19632 if { (eval echo configure:19633: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19633   rm -rf conftest*
19634   \
19635     ctype_solaris25=yes
19636 else
19637   echo "configure: failed program was:" >&5
19638   cat conftest.$ac_ext >&5
19639   rm -rf conftest*
19640   ctype_solaris25=no
19641 fi
19642 rm -f conftest*
19643     echo "$ac_t""$ctype_solaris25" 1>&6
19644     if test $ctype_solaris25 = "yes"; then
19645       ctype_include_dir="config/os/solaris/solaris2.5"
19646       ctype_default=no
19647     fi
19648     fi
19649
19650         if test $ctype_default = "yes"; then
19651     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
19652 echo "configure:19653: checking <ctype> for AIX" >&5
19653     cat > conftest.$ac_ext <<EOF
19654 #line 19655 "configure"
19655 #include "confdefs.h"
19656 #include <ctype.h>
19657 int main() {
19658 int
19659     foo (int a)
19660     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
19661         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
19662         + _VALC('a') + _IS('c', 0);}
19663 ; return 0; }
19664 EOF
19665 if { (eval echo configure:19666: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19666   rm -rf conftest*
19667   \
19668     ctype_aix=yes
19669 else
19670   echo "configure: failed program was:" >&5
19671   cat conftest.$ac_ext >&5
19672   rm -rf conftest*
19673   ctype_aix=no
19674 fi
19675 rm -f conftest*
19676     echo "$ac_t""$ctype_aix" 1>&6
19677     if test $ctype_aix = "yes"; then
19678       ctype_include_dir="config/os/aix"
19679       ctype_default=no
19680     fi
19681     fi
19682
19683         if test $ctype_default = "yes"; then
19684     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
19685 echo "configure:19686: checking <ctype> for IRIX" >&5
19686     cat > conftest.$ac_ext <<EOF
19687 #line 19688 "configure"
19688 #include "confdefs.h"
19689 #include <ctype.h>
19690 int main() {
19691 int
19692     foo (int a)
19693     { return _U + _L + _N + _S + _P + _C + _B + _X + \
19694              _A + _PR + _G + _BL;}
19695 ; return 0; }
19696 EOF
19697 if { (eval echo configure:19698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19698   rm -rf conftest*
19699   \
19700     ctype_irix=yes
19701 else
19702   echo "configure: failed program was:" >&5
19703   cat conftest.$ac_ext >&5
19704   rm -rf conftest*
19705   ctype_irix=no
19706 fi
19707 rm -f conftest*
19708     echo "$ac_t""$ctype_irix" 1>&6
19709     if test $ctype_irix = "yes"; then
19710       ctype_include_dir="config/os/irix"
19711       ctype_default=no
19712     fi
19713     fi
19714
19715         if test $ctype_default = "yes"; then
19716     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
19717 echo "configure:19718: checking <ctype> for newlib" >&5
19718     cat > conftest.$ac_ext <<EOF
19719 #line 19720 "configure"
19720 #include "confdefs.h"
19721 #include <ctype.h>
19722 int main() {
19723 int
19724     foo (int a)
19725     { return _U + _L + _N + _S + _P + _C + _X + _B \
19726         + _ctype_[a];}
19727 ; return 0; }
19728 EOF
19729 if { (eval echo configure:19730: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19730   rm -rf conftest*
19731   \
19732     ctype_newlib=yes
19733 else
19734   echo "configure: failed program was:" >&5
19735   cat conftest.$ac_ext >&5
19736   rm -rf conftest*
19737   ctype_newlib=no
19738 fi
19739 rm -f conftest*
19740     echo "$ac_t""$ctype_newlib" 1>&6
19741     if test $ctype_newlib = "yes"; then
19742       ctype_include_dir="config/os/newlib"
19743       ctype_default=no
19744     fi
19745     fi
19746
19747     if test $ctype_default = "yes"; then
19748       ctype_include_dir="config/os/generic"
19749       echo "configure: warning: "Using default ctype headers."" 1>&2
19750     fi
19751
19752 else
19753   echo "$ac_t""no" 1>&6
19754 fi
19755
19756
19757
19758   ac_test_CXXFLAGS="${CXXFLAGS+set}"
19759   ac_save_CXXFLAGS="$CXXFLAGS"
19760   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
19761
19762   for ac_func in strtof
19763 do
19764 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19765 echo "configure:19766: checking for $ac_func" >&5
19766 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19767   echo $ac_n "(cached) $ac_c" 1>&6
19768 else
19769   cat > conftest.$ac_ext <<EOF
19770 #line 19771 "configure"
19771 #include "confdefs.h"
19772 /* System header to define __stub macros and hopefully few prototypes,
19773     which can conflict with char $ac_func(); below.  */
19774 #include <assert.h>
19775 /* Override any gcc2 internal prototype to avoid an error.  */
19776 /* We use char because int might match the return type of a gcc2
19777     builtin and then its argument prototype would still apply.  */
19778 char $ac_func();
19779
19780 int main() {
19781
19782 /* The GNU C library defines this for functions which it implements
19783     to always fail with ENOSYS.  Some functions are actually named
19784     something starting with __ and the normal name is an alias.  */
19785 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19786 choke me
19787 #else
19788 $ac_func();
19789 #endif
19790
19791 ; return 0; }
19792 EOF
19793 if { (eval echo configure:19794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19794   rm -rf conftest*
19795   eval "ac_cv_func_$ac_func=yes"
19796 else
19797   echo "configure: failed program was:" >&5
19798   cat conftest.$ac_ext >&5
19799   rm -rf conftest*
19800   eval "ac_cv_func_$ac_func=no"
19801 fi
19802 rm -f conftest*
19803 fi
19804
19805 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19806   echo "$ac_t""yes" 1>&6
19807     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19808   cat >> confdefs.h <<EOF
19809 #define $ac_tr_func 1
19810 EOF
19811
19812 else
19813   echo "$ac_t""no" 1>&6
19814 fi
19815 done
19816
19817
19818   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
19819 echo "configure:19820: checking for strtold declaration" >&5
19820   if test x${glibcpp_cv_func_strtold_use+set} != xset; then
19821     if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
19822   echo $ac_n "(cached) $ac_c" 1>&6
19823 else
19824
19825
19826       ac_ext=C
19827 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19828 ac_cpp='$CXXCPP $CPPFLAGS'
19829 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19830 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19831 cross_compiling=$ac_cv_prog_cxx_cross
19832
19833       cat > conftest.$ac_ext <<EOF
19834 #line 19835 "configure"
19835 #include "confdefs.h"
19836 #include <stdlib.h>
19837 int main() {
19838  strtold(0, 0);
19839 ; return 0; }
19840 EOF
19841 if { (eval echo configure:19842: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19842   rm -rf conftest*
19843   glibcpp_cv_func_strtold_use=yes
19844 else
19845   echo "configure: failed program was:" >&5
19846   cat conftest.$ac_ext >&5
19847   rm -rf conftest*
19848   glibcpp_cv_func_strtold_use=no
19849 fi
19850 rm -f conftest*
19851       ac_ext=c
19852 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19853 ac_cpp='$CPP $CPPFLAGS'
19854 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19855 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19856 cross_compiling=$ac_cv_prog_cc_cross
19857
19858
19859 fi
19860
19861   fi
19862   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
19863   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
19864     for ac_func in strtold
19865 do
19866 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19867 echo "configure:19868: checking for $ac_func" >&5
19868 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19869   echo $ac_n "(cached) $ac_c" 1>&6
19870 else
19871   cat > conftest.$ac_ext <<EOF
19872 #line 19873 "configure"
19873 #include "confdefs.h"
19874 /* System header to define __stub macros and hopefully few prototypes,
19875     which can conflict with char $ac_func(); below.  */
19876 #include <assert.h>
19877 /* Override any gcc2 internal prototype to avoid an error.  */
19878 /* We use char because int might match the return type of a gcc2
19879     builtin and then its argument prototype would still apply.  */
19880 char $ac_func();
19881
19882 int main() {
19883
19884 /* The GNU C library defines this for functions which it implements
19885     to always fail with ENOSYS.  Some functions are actually named
19886     something starting with __ and the normal name is an alias.  */
19887 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19888 choke me
19889 #else
19890 $ac_func();
19891 #endif
19892
19893 ; return 0; }
19894 EOF
19895 if { (eval echo configure:19896: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19896   rm -rf conftest*
19897   eval "ac_cv_func_$ac_func=yes"
19898 else
19899   echo "configure: failed program was:" >&5
19900   cat conftest.$ac_ext >&5
19901   rm -rf conftest*
19902   eval "ac_cv_func_$ac_func=no"
19903 fi
19904 rm -f conftest*
19905 fi
19906
19907 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19908   echo "$ac_t""yes" 1>&6
19909     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19910   cat >> confdefs.h <<EOF
19911 #define $ac_tr_func 1
19912 EOF
19913
19914 else
19915   echo "$ac_t""no" 1>&6
19916 fi
19917 done
19918
19919   fi
19920
19921
19922   CXXFLAGS="$ac_save_CXXFLAGS"
19923
19924
19925   for ac_hdr in unistd.h
19926 do
19927 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
19928 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
19929 echo "configure:19930: checking for $ac_hdr" >&5
19930 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19931   echo $ac_n "(cached) $ac_c" 1>&6
19932 else
19933   cat > conftest.$ac_ext <<EOF
19934 #line 19935 "configure"
19935 #include "confdefs.h"
19936 #include <$ac_hdr>
19937 EOF
19938 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19939 { (eval echo configure:19940: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19940 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19941 if test -z "$ac_err"; then
19942   rm -rf conftest*
19943   eval "ac_cv_header_$ac_safe=yes"
19944 else
19945   echo "$ac_err" >&5
19946   echo "configure: failed program was:" >&5
19947   cat conftest.$ac_ext >&5
19948   rm -rf conftest*
19949   eval "ac_cv_header_$ac_safe=no"
19950 fi
19951 rm -f conftest*
19952 fi
19953 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19954   echo "$ac_t""yes" 1>&6
19955     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
19956   cat >> confdefs.h <<EOF
19957 #define $ac_tr_hdr 1
19958 EOF
19959
19960 else
19961   echo "$ac_t""no" 1>&6
19962 fi
19963 done
19964
19965 for ac_func in getpagesize
19966 do
19967 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19968 echo "configure:19969: checking for $ac_func" >&5
19969 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19970   echo $ac_n "(cached) $ac_c" 1>&6
19971 else
19972   cat > conftest.$ac_ext <<EOF
19973 #line 19974 "configure"
19974 #include "confdefs.h"
19975 /* System header to define __stub macros and hopefully few prototypes,
19976     which can conflict with char $ac_func(); below.  */
19977 #include <assert.h>
19978 /* Override any gcc2 internal prototype to avoid an error.  */
19979 /* We use char because int might match the return type of a gcc2
19980     builtin and then its argument prototype would still apply.  */
19981 char $ac_func();
19982
19983 int main() {
19984
19985 /* The GNU C library defines this for functions which it implements
19986     to always fail with ENOSYS.  Some functions are actually named
19987     something starting with __ and the normal name is an alias.  */
19988 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19989 choke me
19990 #else
19991 $ac_func();
19992 #endif
19993
19994 ; return 0; }
19995 EOF
19996 if { (eval echo configure:19997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19997   rm -rf conftest*
19998   eval "ac_cv_func_$ac_func=yes"
19999 else
20000   echo "configure: failed program was:" >&5
20001   cat conftest.$ac_ext >&5
20002   rm -rf conftest*
20003   eval "ac_cv_func_$ac_func=no"
20004 fi
20005 rm -f conftest*
20006 fi
20007
20008 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
20009   echo "$ac_t""yes" 1>&6
20010     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
20011   cat >> confdefs.h <<EOF
20012 #define $ac_tr_func 1
20013 EOF
20014
20015 else
20016   echo "$ac_t""no" 1>&6
20017 fi
20018 done
20019
20020 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
20021 echo "configure:20022: checking for working mmap" >&5
20022 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
20023   echo $ac_n "(cached) $ac_c" 1>&6
20024 else
20025   if test "$cross_compiling" = yes; then
20026   ac_cv_func_mmap_fixed_mapped=no
20027 else
20028   cat > conftest.$ac_ext <<EOF
20029 #line 20030 "configure"
20030 #include "confdefs.h"
20031
20032 /* Thanks to Mike Haertel and Jim Avera for this test.
20033    Here is a matrix of mmap possibilities:
20034         mmap private not fixed
20035         mmap private fixed at somewhere currently unmapped
20036         mmap private fixed at somewhere already mapped
20037         mmap shared not fixed
20038         mmap shared fixed at somewhere currently unmapped
20039         mmap shared fixed at somewhere already mapped
20040    For private mappings, we should verify that changes cannot be read()
20041    back from the file, nor mmap's back from the file at a different
20042    address.  (There have been systems where private was not correctly
20043    implemented like the infamous i386 svr4.0, and systems where the
20044    VM page cache was not coherent with the filesystem buffer cache
20045    like early versions of FreeBSD and possibly contemporary NetBSD.)
20046    For shared mappings, we should conversely verify that changes get
20047    propogated back to all the places they're supposed to be.
20048
20049    Grep wants private fixed already mapped.
20050    The main things grep needs to know about mmap are:
20051    * does it exist and is it safe to write into the mmap'd area
20052    * how to use it (BSD variants)  */
20053 #include <sys/types.h>
20054 #include <fcntl.h>
20055 #include <sys/mman.h>
20056
20057 /* This mess was copied from the GNU getpagesize.h.  */
20058 #ifndef HAVE_GETPAGESIZE
20059 # ifdef HAVE_UNISTD_H
20060 #  include <unistd.h>
20061 # endif
20062
20063 /* Assume that all systems that can run configure have sys/param.h.  */
20064 # ifndef HAVE_SYS_PARAM_H
20065 #  define HAVE_SYS_PARAM_H 1
20066 # endif
20067
20068 # ifdef _SC_PAGESIZE
20069 #  define getpagesize() sysconf(_SC_PAGESIZE)
20070 # else /* no _SC_PAGESIZE */
20071 #  ifdef HAVE_SYS_PARAM_H
20072 #   include <sys/param.h>
20073 #   ifdef EXEC_PAGESIZE
20074 #    define getpagesize() EXEC_PAGESIZE
20075 #   else /* no EXEC_PAGESIZE */
20076 #    ifdef NBPG
20077 #     define getpagesize() NBPG * CLSIZE
20078 #     ifndef CLSIZE
20079 #      define CLSIZE 1
20080 #     endif /* no CLSIZE */
20081 #    else /* no NBPG */
20082 #     ifdef NBPC
20083 #      define getpagesize() NBPC
20084 #     else /* no NBPC */
20085 #      ifdef PAGESIZE
20086 #       define getpagesize() PAGESIZE
20087 #      endif /* PAGESIZE */
20088 #     endif /* no NBPC */
20089 #    endif /* no NBPG */
20090 #   endif /* no EXEC_PAGESIZE */
20091 #  else /* no HAVE_SYS_PARAM_H */
20092 #   define getpagesize() 8192   /* punt totally */
20093 #  endif /* no HAVE_SYS_PARAM_H */
20094 # endif /* no _SC_PAGESIZE */
20095
20096 #endif /* no HAVE_GETPAGESIZE */
20097
20098 #ifdef __cplusplus
20099 extern "C" { void *malloc(unsigned); }
20100 #else
20101 char *malloc();
20102 #endif
20103
20104 int
20105 main()
20106 {
20107         char *data, *data2, *data3;
20108         int i, pagesize;
20109         int fd;
20110
20111         pagesize = getpagesize();
20112
20113         /*
20114          * First, make a file with some known garbage in it.
20115          */
20116         data = malloc(pagesize);
20117         if (!data)
20118                 exit(1);
20119         for (i = 0; i < pagesize; ++i)
20120                 *(data + i) = rand();
20121         umask(0);
20122         fd = creat("conftestmmap", 0600);
20123         if (fd < 0)
20124                 exit(1);
20125         if (write(fd, data, pagesize) != pagesize)
20126                 exit(1);
20127         close(fd);
20128
20129         /*
20130          * Next, try to mmap the file at a fixed address which
20131          * already has something else allocated at it.  If we can,
20132          * also make sure that we see the same garbage.
20133          */
20134         fd = open("conftestmmap", O_RDWR);
20135         if (fd < 0)
20136                 exit(1);
20137         data2 = malloc(2 * pagesize);
20138         if (!data2)
20139                 exit(1);
20140         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
20141         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
20142             MAP_PRIVATE | MAP_FIXED, fd, 0L))
20143                 exit(1);
20144         for (i = 0; i < pagesize; ++i)
20145                 if (*(data + i) != *(data2 + i))
20146                         exit(1);
20147
20148         /*
20149          * Finally, make sure that changes to the mapped area
20150          * do not percolate back to the file as seen by read().
20151          * (This is a bug on some variants of i386 svr4.0.)
20152          */
20153         for (i = 0; i < pagesize; ++i)
20154                 *(data2 + i) = *(data2 + i) + 1;
20155         data3 = malloc(pagesize);
20156         if (!data3)
20157                 exit(1);
20158         if (read(fd, data3, pagesize) != pagesize)
20159                 exit(1);
20160         for (i = 0; i < pagesize; ++i)
20161                 if (*(data + i) != *(data3 + i))
20162                         exit(1);
20163         close(fd);
20164         unlink("conftestmmap");
20165         exit(0);
20166 }
20167
20168 EOF
20169 if { (eval echo configure:20170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
20170 then
20171   ac_cv_func_mmap_fixed_mapped=yes
20172 else
20173   echo "configure: failed program was:" >&5
20174   cat conftest.$ac_ext >&5
20175   rm -fr conftest*
20176   ac_cv_func_mmap_fixed_mapped=no
20177 fi
20178 rm -fr conftest*
20179 fi
20180
20181 fi
20182
20183 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
20184 if test $ac_cv_func_mmap_fixed_mapped = yes; then
20185   cat >> confdefs.h <<\EOF
20186 #define HAVE_MMAP 1
20187 EOF
20188
20189 fi
20190
20191 fi
20192
20193 # Now that ctype is determined for all possible targets, we can do this...
20194
20195
20196
20197
20198
20199
20200 if test "$CANADIAN" = yes; then
20201   CANADIAN_TRUE=
20202   CANADIAN_FALSE='#'
20203 else
20204   CANADIAN_TRUE='#'
20205   CANADIAN_FALSE=
20206 fi
20207
20208
20209 if test "$NULL_TARGET" = yes; then
20210   NULL_TARGET_TRUE=
20211   NULL_TARGET_FALSE='#'
20212 else
20213   NULL_TARGET_TRUE='#'
20214   NULL_TARGET_FALSE=
20215 fi
20216
20217
20218 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
20219   NATIVE_TRUE=
20220   NATIVE_FALSE='#'
20221 else
20222   NATIVE_TRUE='#'
20223   NATIVE_FALSE=
20224 fi
20225
20226
20227 if test -z "$with_cross_host"; then
20228   USE_LIBDIR_TRUE=
20229   USE_LIBDIR_FALSE='#'
20230 else
20231   USE_LIBDIR_TRUE='#'
20232   USE_LIBDIR_FALSE=
20233 fi
20234
20235 cat > confcache <<\EOF
20236 # This file is a shell script that caches the results of configure
20237 # tests run on this system so they can be shared between configure
20238 # scripts and configure runs.  It is not useful on other systems.
20239 # If it contains results you don't want to keep, you may remove or edit it.
20240 #
20241 # By default, configure uses ./config.cache as the cache file,
20242 # creating it if it does not exist already.  You can give configure
20243 # the --cache-file=FILE option to use a different cache file; that is
20244 # what configure does when it calls configure scripts in
20245 # subdirectories, so they share the cache.
20246 # Giving --cache-file=/dev/null disables caching, for debugging configure.
20247 # config.status only pays attention to the cache file if you give it the
20248 # --recheck option to rerun configure.
20249 #
20250 EOF
20251 # The following way of writing the cache mishandles newlines in values,
20252 # but we know of no workaround that is simple, portable, and efficient.
20253 # So, don't put newlines in cache variables' values.
20254 # Ultrix sh set writes to stderr and can't be redirected directly,
20255 # and sets the high bit in the cache file unless we assign to the vars.
20256 (set) 2>&1 |
20257   case `(ac_space=' '; set | grep ac_space) 2>&1` in
20258   *ac_space=\ *)
20259     # `set' does not quote correctly, so add quotes (double-quote substitution
20260     # turns \\\\ into \\, and sed turns \\ into \).
20261     sed -n \
20262       -e "s/'/'\\\\''/g" \
20263       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
20264     ;;
20265   *)
20266     # `set' quotes correctly as required by POSIX, so do not add quotes.
20267     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
20268     ;;
20269   esac >> confcache
20270 if cmp -s $cache_file confcache; then
20271   :
20272 else
20273   if test -w $cache_file; then
20274     echo "updating cache $cache_file"
20275     cat confcache > $cache_file
20276   else
20277     echo "not updating unwritable cache $cache_file"
20278   fi
20279 fi
20280 rm -f confcache
20281
20282
20283   ac_safe=`echo "locale.h" | sed 'y%./+-%__p_%'`
20284 echo $ac_n "checking for locale.h""... $ac_c" 1>&6
20285 echo "configure:20286: checking for locale.h" >&5
20286 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
20287   echo $ac_n "(cached) $ac_c" 1>&6
20288 else
20289   cat > conftest.$ac_ext <<EOF
20290 #line 20291 "configure"
20291 #include "confdefs.h"
20292 #include <locale.h>
20293 EOF
20294 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
20295 { (eval echo configure:20296: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
20296 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
20297 if test -z "$ac_err"; then
20298   rm -rf conftest*
20299   eval "ac_cv_header_$ac_safe=yes"
20300 else
20301   echo "$ac_err" >&5
20302   echo "configure: failed program was:" >&5
20303   cat conftest.$ac_ext >&5
20304   rm -rf conftest*
20305   eval "ac_cv_header_$ac_safe=no"
20306 fi
20307 rm -f conftest*
20308 fi
20309 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
20310   echo "$ac_t""yes" 1>&6
20311
20312     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
20313 echo "configure:20314: checking for LC_MESSAGES" >&5
20314 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
20315   echo $ac_n "(cached) $ac_c" 1>&6
20316 else
20317   cat > conftest.$ac_ext <<EOF
20318 #line 20319 "configure"
20319 #include "confdefs.h"
20320 #include <locale.h>
20321 int main() {
20322 return LC_MESSAGES
20323 ; return 0; }
20324 EOF
20325 if { (eval echo configure:20326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
20326   rm -rf conftest*
20327   ac_cv_val_LC_MESSAGES=yes
20328 else
20329   echo "configure: failed program was:" >&5
20330   cat conftest.$ac_ext >&5
20331   rm -rf conftest*
20332   ac_cv_val_LC_MESSAGES=no
20333 fi
20334 rm -f conftest*
20335 fi
20336
20337 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
20338     if test $ac_cv_val_LC_MESSAGES = yes; then
20339       cat >> confdefs.h <<\EOF
20340 #define HAVE_LC_MESSAGES 1
20341 EOF
20342
20343     fi
20344
20345 else
20346   echo "$ac_t""no" 1>&6
20347 fi
20348
20349
20350
20351 if test "${multilib}" = "yes"; then
20352   multilib_arg="--enable-multilib"
20353 else
20354   multilib_arg=
20355 fi
20356
20357
20358 # Generate the various Makefiles, include files, and scripts.
20359
20360 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
20361 # Needed so that g++ can find the correct include subdir automatically.
20362 INTERFACE=v3
20363
20364 # Check for the interface version number for specifying where header
20365 # files are installed, if a version number is provided.
20366 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
20367 echo "configure:20368: checking for interface version number" >&5
20368 libstdcxx_interface=$INTERFACE
20369 echo "$ac_t""$libstdcxx_interface" 1>&6
20370
20371
20372 # Process the option --with-gxx-include-dir=<path to include-files directory>
20373 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
20374 echo "configure:20375: checking for --with-gxx-include-dir" >&5
20375 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
20376 if test "${with_gxx_include_dir+set}" = set; then
20377   withval="$with_gxx_include_dir"
20378   case "${withval}" in
20379   yes)
20380     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
20381     gxx_include_dir=no
20382     ;;
20383   no)
20384     gxx_include_dir=no
20385     ;;
20386   *)
20387     gxx_include_dir=${withval}
20388     ;;
20389 esac
20390 else
20391   gxx_include_dir=no
20392 fi
20393
20394 echo "$ac_t""$gxx_include_dir" 1>&6
20395
20396
20397
20398 if test x${gxx_include_dir} != xno; then
20399   GXX_INCLUDE_DIR_TRUE=
20400   GXX_INCLUDE_DIR_FALSE='#'
20401 else
20402   GXX_INCLUDE_DIR_TRUE='#'
20403   GXX_INCLUDE_DIR_FALSE=
20404 fi
20405
20406 # Process the option "--enable-version-specific-runtime-libs"
20407 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
20408 echo "configure:20409: checking for --enable-version-specific-runtime-libs" >&5
20409 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
20410 if test "${enable_version_specific_runtime_libs+set}" = set; then
20411   enableval="$enable_version_specific_runtime_libs"
20412     version_specific_libs=yes
20413 # Need the gcc compiler version to know where to install libraries
20414 # and header files if --enable-version-specific-runtime-libs option
20415 # is selected.
20416 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
20417 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
20418 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
20419 #gcc_version=$gcc_num-$gcc_date
20420 gcc_version=$gcc_num
20421
20422
20423 else
20424   version_specific_libs=no
20425 fi
20426
20427 echo "$ac_t""$version_specific_libs" 1>&6
20428 if test x${version_specific_libs} = xyes; then
20429
20430
20431 if test x${version_specific_libs} = xyes; then
20432   VERSION_SPECIFIC_LIBS_TRUE=
20433   VERSION_SPECIFIC_LIBS_FALSE='#'
20434 else
20435   VERSION_SPECIFIC_LIBS_TRUE='#'
20436   VERSION_SPECIFIC_LIBS_FALSE=
20437 fi
20438   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
20439 fi
20440
20441
20442
20443 # Export all the include and flag information to makefiles.
20444
20445   # Root level of the include sources.
20446   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
20447
20448   # Can either use include/c or include/c_std to grab "C" headers. This
20449   # variable is set to the include directory currently in use.
20450   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
20451
20452   # Passed down for canadian crosses.
20453   if  test x"$CANADIAN" = xyes; then
20454     TOPLEVEL_INCLUDES='-I$(includedir)'
20455   fi
20456
20457   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
20458
20459   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
20460
20461   #if GLIBCPP_NEED_LIBIO
20462   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
20463   #else
20464   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
20465   #endif
20466
20467   #if GLIBCPP_USE_CSHADOW
20468   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
20469   #                   -I$(top_blddir)/cshadow'
20470   #else
20471   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
20472   #endif
20473
20474   # Now, export this to all the little Makefiles....
20475
20476
20477
20478
20479
20480
20481
20482
20483   # Optimization flags that are probably a good idea for thrill-seekers. Just
20484   # uncomment the lines below and make, everything else is ready to go...
20485   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
20486   OPTIMIZE_CXXFLAGS=
20487
20488
20489   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
20490
20491
20492
20493 # This should be done by mkincludedir, but hack around it now.
20494 blddir=`pwd`
20495 echo "checking for $blddir/include"
20496
20497 if test ! -d "$blddir/include"; then
20498   mkdir "$blddir/include"
20499 fi
20500
20501 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
20502 # so that multilib installs will end up installed in the correct
20503 # place. To work around this not being passed down from config-ml.in
20504 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
20505 # append it here.
20506 trap '' 1 2 15
20507 cat > confcache <<\EOF
20508 # This file is a shell script that caches the results of configure
20509 # tests run on this system so they can be shared between configure
20510 # scripts and configure runs.  It is not useful on other systems.
20511 # If it contains results you don't want to keep, you may remove or edit it.
20512 #
20513 # By default, configure uses ./config.cache as the cache file,
20514 # creating it if it does not exist already.  You can give configure
20515 # the --cache-file=FILE option to use a different cache file; that is
20516 # what configure does when it calls configure scripts in
20517 # subdirectories, so they share the cache.
20518 # Giving --cache-file=/dev/null disables caching, for debugging configure.
20519 # config.status only pays attention to the cache file if you give it the
20520 # --recheck option to rerun configure.
20521 #
20522 EOF
20523 # The following way of writing the cache mishandles newlines in values,
20524 # but we know of no workaround that is simple, portable, and efficient.
20525 # So, don't put newlines in cache variables' values.
20526 # Ultrix sh set writes to stderr and can't be redirected directly,
20527 # and sets the high bit in the cache file unless we assign to the vars.
20528 (set) 2>&1 |
20529   case `(ac_space=' '; set | grep ac_space) 2>&1` in
20530   *ac_space=\ *)
20531     # `set' does not quote correctly, so add quotes (double-quote substitution
20532     # turns \\\\ into \\, and sed turns \\ into \).
20533     sed -n \
20534       -e "s/'/'\\\\''/g" \
20535       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
20536     ;;
20537   *)
20538     # `set' quotes correctly as required by POSIX, so do not add quotes.
20539     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
20540     ;;
20541   esac >> confcache
20542 if cmp -s $cache_file confcache; then
20543   :
20544 else
20545   if test -w $cache_file; then
20546     echo "updating cache $cache_file"
20547     cat confcache > $cache_file
20548   else
20549     echo "not updating unwritable cache $cache_file"
20550   fi
20551 fi
20552 rm -f confcache
20553
20554 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
20555
20556 test "x$prefix" = xNONE && prefix=$ac_default_prefix
20557 # Let make expand exec_prefix.
20558 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
20559
20560 # Any assignment to VPATH causes Sun make to only execute
20561 # the first set of double-colon rules, so remove it if not needed.
20562 # If there is a colon in the path, we need to keep it.
20563 if test "x$srcdir" = x.; then
20564   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
20565 fi
20566
20567 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
20568
20569 DEFS=-DHAVE_CONFIG_H
20570
20571 # Without the "./", some shells look in PATH for config.status.
20572 : ${CONFIG_STATUS=./config.status}
20573
20574 echo creating $CONFIG_STATUS
20575 rm -f $CONFIG_STATUS
20576 cat > $CONFIG_STATUS <<EOF
20577 #! /bin/sh
20578 # Generated automatically by configure.
20579 # Run this file to recreate the current configuration.
20580 # This directory was configured as follows,
20581 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
20582 #
20583 # $0 $ac_configure_args
20584 #
20585 # Compiler output produced by configure, useful for debugging
20586 # configure, is in ./config.log if it exists.
20587
20588 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
20589 for ac_option
20590 do
20591   case "\$ac_option" in
20592   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
20593     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
20594     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
20595   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
20596     echo "$CONFIG_STATUS generated by autoconf version 2.13"
20597     exit 0 ;;
20598   -help | --help | --hel | --he | --h)
20599     echo "\$ac_cs_usage"; exit 0 ;;
20600   *) echo "\$ac_cs_usage"; exit 1 ;;
20601   esac
20602 done
20603
20604 ac_given_srcdir=$srcdir
20605 ac_given_INSTALL="$INSTALL"
20606
20607 trap 'rm -fr `echo "tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
20608 EOF
20609 cat >> $CONFIG_STATUS <<EOF
20610
20611 # Protect against being on the right side of a sed subst in config.status.
20612 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
20613  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
20614 $ac_vpsub
20615 $extrasub
20616 s%@SHELL@%$SHELL%g
20617 s%@CFLAGS@%$CFLAGS%g
20618 s%@CPPFLAGS@%$CPPFLAGS%g
20619 s%@CXXFLAGS@%$CXXFLAGS%g
20620 s%@FFLAGS@%$FFLAGS%g
20621 s%@DEFS@%$DEFS%g
20622 s%@LDFLAGS@%$LDFLAGS%g
20623 s%@LIBS@%$LIBS%g
20624 s%@exec_prefix@%$exec_prefix%g
20625 s%@prefix@%$prefix%g
20626 s%@program_transform_name@%$program_transform_name%g
20627 s%@bindir@%$bindir%g
20628 s%@sbindir@%$sbindir%g
20629 s%@libexecdir@%$libexecdir%g
20630 s%@datadir@%$datadir%g
20631 s%@sysconfdir@%$sysconfdir%g
20632 s%@sharedstatedir@%$sharedstatedir%g
20633 s%@localstatedir@%$localstatedir%g
20634 s%@libdir@%$libdir%g
20635 s%@includedir@%$includedir%g
20636 s%@oldincludedir@%$oldincludedir%g
20637 s%@infodir@%$infodir%g
20638 s%@mandir@%$mandir%g
20639 s%@host@%$host%g
20640 s%@host_alias@%$host_alias%g
20641 s%@host_cpu@%$host_cpu%g
20642 s%@host_vendor@%$host_vendor%g
20643 s%@host_os@%$host_os%g
20644 s%@target@%$target%g
20645 s%@target_alias@%$target_alias%g
20646 s%@target_cpu@%$target_cpu%g
20647 s%@target_vendor@%$target_vendor%g
20648 s%@target_os@%$target_os%g
20649 s%@build@%$build%g
20650 s%@build_alias@%$build_alias%g
20651 s%@build_cpu@%$build_cpu%g
20652 s%@build_vendor@%$build_vendor%g
20653 s%@build_os@%$build_os%g
20654 s%@glibcpp_basedir@%$glibcpp_basedir%g
20655 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
20656 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
20657 s%@INSTALL_DATA@%$INSTALL_DATA%g
20658 s%@PACKAGE@%$PACKAGE%g
20659 s%@VERSION@%$VERSION%g
20660 s%@ACLOCAL@%$ACLOCAL%g
20661 s%@AUTOCONF@%$AUTOCONF%g
20662 s%@AUTOMAKE@%$AUTOMAKE%g
20663 s%@AUTOHEADER@%$AUTOHEADER%g
20664 s%@MAKEINFO@%$MAKEINFO%g
20665 s%@SET_MAKE@%$SET_MAKE%g
20666 s%@CC@%$CC%g
20667 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
20668 s%@CXX@%$CXX%g
20669 s%@AS@%$AS%g
20670 s%@AR@%$AR%g
20671 s%@RANLIB@%$RANLIB%g
20672 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
20673 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
20674 s%@MAINT@%$MAINT%g
20675 s%@EXEEXT@%$EXEEXT%g
20676 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
20677 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
20678 s%@LN_S@%$LN_S%g
20679 s%@OBJEXT@%$OBJEXT%g
20680 s%@STRIP@%$STRIP%g
20681 s%@LIBTOOL@%$LIBTOOL%g
20682 s%@CXXCPP@%$CXXCPP%g
20683 s%@enable_shared@%$enable_shared%g
20684 s%@enable_static@%$enable_static%g
20685 s%@ifGNUmake@%$ifGNUmake%g
20686 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
20687 s%@CPP@%$CPP%g
20688 s%@GLIBCPP_BUILD_LIBIO_TRUE@%$GLIBCPP_BUILD_LIBIO_TRUE%g
20689 s%@GLIBCPP_BUILD_LIBIO_FALSE@%$GLIBCPP_BUILD_LIBIO_FALSE%g
20690 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
20691 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
20692 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
20693 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
20694 s%@libio_la@%$libio_la%g
20695 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
20696 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
20697 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
20698 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
20699 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
20700 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
20701 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
20702 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
20703 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
20704 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
20705 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
20706 s%@libinst_wstring_la@%$libinst_wstring_la%g
20707 s%@WERROR@%$WERROR%g
20708 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
20709 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
20710 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
20711 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
20712 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
20713 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
20714 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
20715 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
20716 s%@libstdcxx_interface@%$libstdcxx_interface%g
20717 s%@gxx_include_dir@%$gxx_include_dir%g
20718 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
20719 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
20720 s%@gcc_version@%$gcc_version%g
20721 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
20722 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
20723 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
20724 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
20725 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
20726 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
20727 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
20728 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
20729 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
20730 s%@WARN_FLAGS@%$WARN_FLAGS%g
20731
20732 CEOF
20733 EOF
20734
20735 cat >> $CONFIG_STATUS <<\EOF
20736
20737 # Split the substitutions into bite-sized pieces for seds with
20738 # small command number limits, like on Digital OSF/1 and HP-UX.
20739 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
20740 ac_file=1 # Number of current file.
20741 ac_beg=1 # First line for current file.
20742 ac_end=$ac_max_sed_cmds # Line after last line for current file.
20743 ac_more_lines=:
20744 ac_sed_cmds=""
20745 while $ac_more_lines; do
20746   if test $ac_beg -gt 1; then
20747     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
20748   else
20749     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
20750   fi
20751   if test ! -s conftest.s$ac_file; then
20752     ac_more_lines=false
20753     rm -f conftest.s$ac_file
20754   else
20755     if test -z "$ac_sed_cmds"; then
20756       ac_sed_cmds="sed -f conftest.s$ac_file"
20757     else
20758       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
20759     fi
20760     ac_file=`expr $ac_file + 1`
20761     ac_beg=$ac_end
20762     ac_end=`expr $ac_end + $ac_max_sed_cmds`
20763   fi
20764 done
20765 if test -z "$ac_sed_cmds"; then
20766   ac_sed_cmds=cat
20767 fi
20768 EOF
20769
20770 cat >> $CONFIG_STATUS <<EOF
20771
20772 CONFIG_FILES=\${CONFIG_FILES-"tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
20773 EOF
20774 cat >> $CONFIG_STATUS <<\EOF
20775 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
20776   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20777   case "$ac_file" in
20778   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20779        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20780   *) ac_file_in="${ac_file}.in" ;;
20781   esac
20782
20783   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
20784
20785   # Remove last slash and all that follows it.  Not all systems have dirname.
20786   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20787   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20788     # The file is in a subdirectory.
20789     test ! -d "$ac_dir" && mkdir "$ac_dir"
20790     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
20791     # A "../" for each directory in $ac_dir_suffix.
20792     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
20793   else
20794     ac_dir_suffix= ac_dots=
20795   fi
20796
20797   case "$ac_given_srcdir" in
20798   .)  srcdir=.
20799       if test -z "$ac_dots"; then top_srcdir=.
20800       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
20801   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
20802   *) # Relative path.
20803     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
20804     top_srcdir="$ac_dots$ac_given_srcdir" ;;
20805   esac
20806
20807   case "$ac_given_INSTALL" in
20808   [/$]*) INSTALL="$ac_given_INSTALL" ;;
20809   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
20810   esac
20811
20812   echo creating "$ac_file"
20813   rm -f "$ac_file"
20814   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
20815   case "$ac_file" in
20816   *Makefile*) ac_comsub="1i\\
20817 # $configure_input" ;;
20818   *) ac_comsub= ;;
20819   esac
20820
20821   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20822   sed -e "$ac_comsub
20823 s%@configure_input@%$configure_input%g
20824 s%@srcdir@%$srcdir%g
20825 s%@top_srcdir@%$top_srcdir%g
20826 s%@INSTALL@%$INSTALL%g
20827 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
20828 fi; done
20829 rm -f conftest.s*
20830
20831 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
20832 # NAME is the cpp macro being defined and VALUE is the value it is being given.
20833 #
20834 # ac_d sets the value in "#define NAME VALUE" lines.
20835 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
20836 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
20837 ac_dC='\3'
20838 ac_dD='%g'
20839 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
20840 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20841 ac_uB='\([      ]\)%\1#\2define\3'
20842 ac_uC=' '
20843 ac_uD='\4%g'
20844 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
20845 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20846 ac_eB='$%\1#\2define\3'
20847 ac_eC=' '
20848 ac_eD='%g'
20849
20850 if test "${CONFIG_HEADERS+set}" != set; then
20851 EOF
20852 cat >> $CONFIG_STATUS <<EOF
20853   CONFIG_HEADERS="config.h"
20854 EOF
20855 cat >> $CONFIG_STATUS <<\EOF
20856 fi
20857 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
20858   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20859   case "$ac_file" in
20860   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20861        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20862   *) ac_file_in="${ac_file}.in" ;;
20863   esac
20864
20865   echo creating $ac_file
20866
20867   rm -f conftest.frag conftest.in conftest.out
20868   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20869   cat $ac_file_inputs > conftest.in
20870
20871 EOF
20872
20873 # Transform confdefs.h into a sed script conftest.vals that substitutes
20874 # the proper values into config.h.in to produce config.h.  And first:
20875 # Protect against being on the right side of a sed subst in config.status.
20876 # Protect against being in an unquoted here document in config.status.
20877 rm -f conftest.vals
20878 cat > conftest.hdr <<\EOF
20879 s/[\\&%]/\\&/g
20880 s%[\\$`]%\\&%g
20881 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
20882 s%ac_d%ac_u%gp
20883 s%ac_u%ac_e%gp
20884 EOF
20885 sed -n -f conftest.hdr confdefs.h > conftest.vals
20886 rm -f conftest.hdr
20887
20888 # This sed command replaces #undef with comments.  This is necessary, for
20889 # example, in the case of _POSIX_SOURCE, which is predefined and required
20890 # on some systems where configure will not decide to define it.
20891 cat >> conftest.vals <<\EOF
20892 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
20893 EOF
20894
20895 # Break up conftest.vals because some shells have a limit on
20896 # the size of here documents, and old seds have small limits too.
20897
20898 rm -f conftest.tail
20899 while :
20900 do
20901   ac_lines=`grep -c . conftest.vals`
20902   # grep -c gives empty output for an empty file on some AIX systems.
20903   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
20904   # Write a limited-size here document to conftest.frag.
20905   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
20906   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
20907   echo 'CEOF
20908   sed -f conftest.frag conftest.in > conftest.out
20909   rm -f conftest.in
20910   mv conftest.out conftest.in
20911 ' >> $CONFIG_STATUS
20912   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
20913   rm -f conftest.vals
20914   mv conftest.tail conftest.vals
20915 done
20916 rm -f conftest.vals
20917
20918 cat >> $CONFIG_STATUS <<\EOF
20919   rm -f conftest.frag conftest.h
20920   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
20921   cat conftest.in >> conftest.h
20922   rm -f conftest.in
20923   if cmp -s $ac_file conftest.h 2>/dev/null; then
20924     echo "$ac_file is unchanged"
20925     rm -f conftest.h
20926   else
20927     # Remove last slash and all that follows it.  Not all systems have dirname.
20928       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20929       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20930       # The file is in a subdirectory.
20931       test ! -d "$ac_dir" && mkdir "$ac_dir"
20932     fi
20933     rm -f $ac_file
20934     mv conftest.h $ac_file
20935   fi
20936 fi; done
20937
20938 EOF
20939
20940 cat >> $CONFIG_STATUS <<EOF
20941 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"
20942 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 \
20943 include/bits/ctype_base.h \
20944 include/bits/ctype_inline.h \
20945 include/bits/ctype_noninline.h"
20946 EOF
20947
20948 cat >> $CONFIG_STATUS <<\EOF
20949 srcdir=$ac_given_srcdir
20950 while test -n "$ac_sources"; do
20951   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
20952   set $ac_sources; ac_source=$1; shift; ac_sources=$*
20953
20954   echo "linking $srcdir/$ac_source to $ac_dest"
20955
20956   if test ! -r $srcdir/$ac_source; then
20957     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
20958   fi
20959   rm -f $ac_dest
20960
20961   # Make relative symlinks.
20962   # Remove last slash and all that follows it.  Not all systems have dirname.
20963   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
20964   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
20965     # The dest file is in a subdirectory.
20966     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
20967     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
20968     # A "../" for each directory in $ac_dest_dir_suffix.
20969     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
20970   else
20971     ac_dest_dir_suffix= ac_dots=
20972   fi
20973
20974   case "$srcdir" in
20975   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
20976   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
20977   esac
20978
20979   # Make a symlink if possible; otherwise try a hard link.
20980   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
20981     ln $srcdir/$ac_source $ac_dest; then :
20982   else
20983     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
20984   fi
20985 done
20986 EOF
20987 cat >> $CONFIG_STATUS <<EOF
20988
20989 srcdir=${srcdir}
20990 host=${host}
20991 target=${target}
20992 with_multisubdir=${with_multisubdir}
20993 ac_configure_args="${multilib_arg} ${ac_configure_args}"
20994 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
20995 glibcpp_basedir=${glibcpp_basedir}
20996 CC="${CC}"
20997 CXX="${CXX}"
20998
20999 EOF
21000 cat >> $CONFIG_STATUS <<\EOF
21001 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
21002 if test -n "$CONFIG_FILES"; then
21003   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
21004   grep '^MULTISUBDIR =' Makefile >> src/Makefile
21005 fi
21006 chmod +x tests_flags
21007 chmod +x mkcheck
21008
21009 exit 0
21010 EOF
21011 chmod +x $CONFIG_STATUS
21012 rm -fr confdefs* $ac_clean_files
21013 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
21014
21015
21016
21017 # Generate bits/c++config.h
21018 # NB: This must be the first generated file as others include it. . .
21019 $srcdir/mkc++config $blddir $srcdir
21020
21021 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
21022 if test ! -f stamp-limits; then
21023   $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
21024   touch stamp-limits
21025 fi
21026
21027
21028 # Sanity checking & User-visible messages.
21029 # Checks down here, otherwise they get scrolled off before
21030 # the user will notice.
21031
21032 # Trying to get more people to read documentation.  Possibly remove
21033 # check and warn all the time. There is no "informational" AC_MSG_
21034 # macro, so these are going to be printed even when --quiet/--silent
21035 # is given.
21036 if test ! -f stamp-sanity-warned; then
21037   touch stamp-sanity-warned
21038   echo ""
21039   echo "Please make certain that you read the installation information here:"
21040   echo "  faster => ${srcdir}/docs/install.html"
21041   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
21042   echo ""
21043   echo "and the configuration information here:"
21044   echo "  faster => ${srcdir}/docs/configopts.html"
21045   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
21046   echo ""
21047   echo "before proceeding with ${_cv_gnu_make_command}."
21048   echo ""
21049 fi