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=no]"
  45 ac_help="$ac_help
  46   --enable-cheaders construct "C" header files for
  47                            g++ [default=c_std]"
  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/ios.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=no
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 c header strategy to use""... $ac_c" 1>&6
3050 echo "configure:3051: checking for c header strategy to use" >&5
3051 # Check whether --enable-cheaders or --disable-cheaders was given.
3052 if test "${enable_cheaders+set}" = set; then
3053   enableval="$enable_cheaders"
3054
3055   case "$enableval" in
3056    c)
3057         enable_cheaders=c
3058         ;;
3059    c_std)
3060         enable_cheaders=c_std
3061         ;;
3062    c_shadow)
3063         enable_cheaders=c_shadow
3064         ;;
3065    *)   { echo "configure: error: Unknown argument to enable/disable "C" headers" 1>&2; exit 1; }
3066         ;;
3067   esac
3068 else
3069   enable_cheaders=c_std
3070 fi
3071
3072   echo "$ac_t""$enable_cheaders" 1>&6
3073
3074     case "$enable_cheaders" in
3075     c_shadow)
3076         CSHADOW_FLAGS="-fno-builtin"
3077         C_INCLUDE_DIR='${top_srcdir}/include/c_shadow'
3078         cat >> confdefs.h <<\EOF
3079 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3080 EOF
3081
3082         ;;
3083     c_std)
3084         CSHADOW_FLAGS=""
3085         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3086         ;;
3087     c)
3088         CSHADOW_FLAGS=""
3089         C_INCLUDE_DIR='${top_srcdir}/include/c'
3090         ;;
3091   esac
3092
3093
3094
3095
3096
3097 if test "$enable_cheaders" = c_shadow; then
3098   GLIBCPP_USE_CSHADOW_TRUE=
3099   GLIBCPP_USE_CSHADOW_FALSE='#'
3100 else
3101   GLIBCPP_USE_CSHADOW_TRUE='#'
3102   GLIBCPP_USE_CSHADOW_FALSE=
3103 fi
3104
3105
3106       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3107 echo "configure:3108: checking for threads package to use" >&5
3108   # Check whether --enable-threads or --disable-threads was given.
3109 if test "${enable_threads+set}" = set; then
3110   enableval="$enable_threads"
3111   if test x$enable_threads = xno; then
3112     enable_threads=''
3113   fi
3114 else
3115   enable_threads=''
3116 fi
3117
3118
3119   enable_threads_flag=$enable_threads
3120
3121     case x${enable_threads_flag} in
3122         x | xno | xnone)
3123                 # No threads
3124                 target_thread_file='single'
3125                 ;;
3126         xyes)
3127                 # default
3128                 target_thread_file='posix'
3129                 ;;
3130         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3131         xsolaris | xwin32 | xdce | xvxworks)
3132                 target_thread_file=$enable_threads_flag
3133                 ;;
3134         *)
3135                 echo "$enable_threads is an unknown thread package" 1>&2
3136                 exit 1
3137                 ;;
3138   esac
3139
3140     THREADH=
3141   case "$target_thread_file" in
3142     no | none | single)
3143       THREADH=threads-no.h
3144       ;;
3145     posix | pthreads)
3146       THREADH=threads-posix.h
3147       ;;
3148     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3149       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3150       ;;
3151     *)
3152       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3153       ;;
3154   esac
3155   echo "$ac_t""$THREADH" 1>&6
3156
3157
3158   if test $THREADH != threads-no.h; then
3159     cat >> confdefs.h <<\EOF
3160 #define _GLIBCPP_USE_THREADS 1
3161 EOF
3162
3163   fi
3164
3165
3166     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3167 echo "configure:3168: checking for atomicity.h" >&5
3168     # We have ATOMICITY already from GLIBCPP_CONFIGURE
3169     if test "$ATOMICITYH" = "config/cpu/generic"; then
3170       echo "configure: warning: No ATOMICITY settings found, using generic atomic ops." 1>&2
3171     fi
3172     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3173
3174
3175 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3176 if test "${enable_cxx_flags+set}" = set; then
3177   enableval="$enable_cxx_flags"
3178   case "x$enableval" in
3179  xyes)
3180         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3181  xno|x)
3182         enable_cxx_flags='' ;;
3183  *)
3184         enable_cxx_flags="$enableval" ;;
3185  esac
3186 else
3187   enable_cxx_flags='none'
3188 fi
3189
3190
3191 if test "$enable_cxx_flags" = "none"; then
3192   enable_cxx_flags='';
3193 fi
3194
3195 if test -n "$enable_cxx_flags"; then
3196     for f in $enable_cxx_flags; do
3197         case "$f" in
3198             -fhonor-std)  ;;
3199             -*)  ;;
3200             *)   # and we're trying to pass /what/ exactly?
3201                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3202         esac
3203     done
3204 fi
3205 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3206
3207
3208
3209 if test -n "$with_cross_host"; then
3210
3211   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3212   # may not work correctly, because the compiler may not be able to
3213   # link executables.
3214   xcompiling=1
3215   NATIVE=no
3216
3217   # If Canadian cross, then don't pick up tools from the build
3218   # directory.
3219   if test x"$build" != x"$with_cross_host" && x"$build" != x"$target"; then
3220     CANADIAN=yes
3221     NULL_TARGET=yes
3222   else
3223     CANADIAN=no
3224     NULL_TARGET=no
3225   fi
3226
3227   case "$target_alias" in
3228     *-linux-*)
3229         # Construct linux crosses by hand, eliminating bits that need ld...
3230         # Check for available headers.
3231         for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h \
3232         machine/endian.h machine/param.h sys/machine.h fp.h locale.h \
3233         float.h inttypes.h
3234 do
3235 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3236 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3237 echo "configure:3238: checking for $ac_hdr" >&5
3238 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3239   echo $ac_n "(cached) $ac_c" 1>&6
3240 else
3241   cat > conftest.$ac_ext <<EOF
3242 #line 3243 "configure"
3243 #include "confdefs.h"
3244 #include <$ac_hdr>
3245 EOF
3246 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3247 { (eval echo configure:3248: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3248 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3249 if test -z "$ac_err"; then
3250   rm -rf conftest*
3251   eval "ac_cv_header_$ac_safe=yes"
3252 else
3253   echo "$ac_err" >&5
3254   echo "configure: failed program was:" >&5
3255   cat conftest.$ac_ext >&5
3256   rm -rf conftest*
3257   eval "ac_cv_header_$ac_safe=no"
3258 fi
3259 rm -f conftest*
3260 fi
3261 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3262   echo "$ac_t""yes" 1>&6
3263     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3264   cat >> confdefs.h <<EOF
3265 #define $ac_tr_hdr 1
3266 EOF
3267
3268 else
3269   echo "$ac_t""no" 1>&6
3270 fi
3271 done
3272
3273
3274         # GLIBCPP_CHECK_COMPILER_FEATURES
3275         WFMT_FLAGS='-fdiagnostics-show-location=once'
3276         SECTION_FLAGS='-ffunction-sections -fdata-sections'
3277
3278
3279
3280   # If we're not using GNU ld, then there's no point in even trying these
3281   # tests.  Check for that first.  We should have already tested for gld
3282   # by now (in libtool), but require it now just to be safe...
3283   SECTION_LDFLAGS=''
3284   OPT_LDFLAGS=''
3285
3286
3287   # Set --gc-sections.
3288   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
3289     # GNU ld it is!  Joy and bunny rabbits!
3290
3291     # All these tests are for C++; save the language and the compiler flags.
3292     # Need to do this so that g++ won't try to link in libstdc++
3293     ac_test_CFLAGS="${CFLAGS+set}"
3294     ac_save_CFLAGS="$CFLAGS"
3295     CFLAGS='-x c++  -Wl,--gc-sections'
3296
3297     # Check for -Wl,--gc-sections
3298     # XXX This test is broken at the moment, as symbols required for
3299     # linking are now in libsupc++ (not built yet.....). In addition,
3300     # this test has cored on solaris in the past. In addition,
3301     # --gc-sections doesn't really work at the moment (keeps on discarding
3302     # used sections, first .eh_frame and now some of the glibc sections for
3303     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3304     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3305 echo "configure:3306: checking for ld that supports -Wl,--gc-sections" >&5
3306     if test "$cross_compiling" = yes; then
3307   ac_sectionLDflags=yes
3308 else
3309   cat > conftest.$ac_ext <<EOF
3310 #line 3311 "configure"
3311 #include "confdefs.h"
3312
3313      int main(void)
3314      {
3315        try { throw 1; }
3316        catch (...) { };
3317        return 0;
3318      }
3319
3320 EOF
3321 if { (eval echo configure:3322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3322 then
3323   ac_sectionLDflags=yes
3324 else
3325   echo "configure: failed program was:" >&5
3326   cat conftest.$ac_ext >&5
3327   rm -fr conftest*
3328   ac_sectionLFflags=no
3329 fi
3330 rm -fr conftest*
3331 fi
3332
3333     if test "$ac_test_CFLAGS" = set; then
3334       CFLAGS="$ac_save_CFLAGS"
3335     else
3336       # this is the suspicious part
3337       CFLAGS=''
3338     fi
3339     if test "$ac_sectionLDflags" = "yes"; then
3340       SECTION_LDFLAGS='-Wl,--gc-sections'
3341     fi
3342     echo "$ac_t""$ac_sectionLDflags" 1>&6
3343   fi
3344
3345   # Set linker optimization flags.
3346   if test x"$ac_cv_prog_gnu_ld" = x"yes" && test x"$enable_debug" = x"no"; then
3347     OPT_LDFLAGS='-Wl,-O1'
3348   fi
3349
3350
3351
3352
3353         # GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
3354         # GLIBCPP_CHECK_MATH_SUPPORT
3355         cat >> confdefs.h <<\EOF
3356 #define HAVE_ACOSF 1
3357 EOF
3358
3359         cat >> confdefs.h <<\EOF
3360 #define HAVE_ASINF 1
3361 EOF
3362
3363         cat >> confdefs.h <<\EOF
3364 #define HAVE_ATAN2F 1
3365 EOF
3366
3367         cat >> confdefs.h <<\EOF
3368 #define HAVE_ATANF 1
3369 EOF
3370
3371         cat >> confdefs.h <<\EOF
3372 #define HAVE_CEILF 1
3373 EOF
3374
3375         cat >> confdefs.h <<\EOF
3376 #define HAVE_COPYSIGN 1
3377 EOF
3378
3379         cat >> confdefs.h <<\EOF
3380 #define HAVE_COPYSIGNF 1
3381 EOF
3382
3383         cat >> confdefs.h <<\EOF
3384 #define HAVE_COSF 1
3385 EOF
3386
3387         cat >> confdefs.h <<\EOF
3388 #define HAVE_COSHF 1
3389 EOF
3390
3391         cat >> confdefs.h <<\EOF
3392 #define HAVE_EXPF 1
3393 EOF
3394
3395         cat >> confdefs.h <<\EOF
3396 #define HAVE_FABSF 1
3397 EOF
3398
3399         cat >> confdefs.h <<\EOF
3400 #define HAVE_FINITE 1
3401 EOF
3402
3403         cat >> confdefs.h <<\EOF
3404 #define HAVE_FINITEF 1
3405 EOF
3406
3407         cat >> confdefs.h <<\EOF
3408 #define HAVE_FLOORF 1
3409 EOF
3410
3411         cat >> confdefs.h <<\EOF
3412 #define HAVE_FMODF 1
3413 EOF
3414
3415         cat >> confdefs.h <<\EOF
3416 #define HAVE_FREXPF 1
3417 EOF
3418
3419         cat >> confdefs.h <<\EOF
3420 #define HAVE_ISINF 1
3421 EOF
3422
3423         cat >> confdefs.h <<\EOF
3424 #define HAVE_ISINFF 1
3425 EOF
3426
3427         cat >> confdefs.h <<\EOF
3428 #define HAVE_ISNAN 1
3429 EOF
3430
3431         cat >> confdefs.h <<\EOF
3432 #define HAVE_ISNANF 1
3433 EOF
3434
3435         cat >> confdefs.h <<\EOF
3436 #define HAVE_LDEXPF 1
3437 EOF
3438
3439         cat >> confdefs.h <<\EOF
3440 #define HAVE_LOG10F 1
3441 EOF
3442
3443         cat >> confdefs.h <<\EOF
3444 #define HAVE_LOGF 1
3445 EOF
3446
3447         cat >> confdefs.h <<\EOF
3448 #define HAVE_MODFF 1
3449 EOF
3450
3451         cat >> confdefs.h <<\EOF
3452 #define HAVE_POWF 1
3453 EOF
3454
3455         cat >> confdefs.h <<\EOF
3456 #define HAVE_SINCOS 1
3457 EOF
3458
3459         cat >> confdefs.h <<\EOF
3460 #define HAVE_SINCOSF 1
3461 EOF
3462
3463         cat >> confdefs.h <<\EOF
3464 #define HAVE_SINF 1
3465 EOF
3466
3467         cat >> confdefs.h <<\EOF
3468 #define HAVE_SINHF 1
3469 EOF
3470
3471         cat >> confdefs.h <<\EOF
3472 #define HAVE_SQRTF 1
3473 EOF
3474
3475         cat >> confdefs.h <<\EOF
3476 #define HAVE_TANF 1
3477 EOF
3478
3479         cat >> confdefs.h <<\EOF
3480 #define HAVE_TANHF 1
3481 EOF
3482
3483
3484         # At some point, we should differentiate between architectures
3485         # like x86, which have long double versions, and alpha/powerpc/etc.,
3486         # which don't. For the time being, punt.
3487         if test x"long_double_math_on_this_cpu" = x"yes"; then
3488           cat >> confdefs.h <<\EOF
3489 #define HAVE_ACOSL 1
3490 EOF
3491
3492           cat >> confdefs.h <<\EOF
3493 #define HAVE_ASINL 1
3494 EOF
3495
3496           cat >> confdefs.h <<\EOF
3497 #define HAVE_ATAN2L 1
3498 EOF
3499
3500           cat >> confdefs.h <<\EOF
3501 #define HAVE_ATANL 1
3502 EOF
3503
3504           cat >> confdefs.h <<\EOF
3505 #define HAVE_CEILL 1
3506 EOF
3507
3508           cat >> confdefs.h <<\EOF
3509 #define HAVE_COPYSIGNL 1
3510 EOF
3511
3512           cat >> confdefs.h <<\EOF
3513 #define HAVE_COSL 1
3514 EOF
3515
3516           cat >> confdefs.h <<\EOF
3517 #define HAVE_COSHL 1
3518 EOF
3519
3520           cat >> confdefs.h <<\EOF
3521 #define HAVE_EXPL 1
3522 EOF
3523
3524           cat >> confdefs.h <<\EOF
3525 #define HAVE_FABSL 1
3526 EOF
3527
3528           cat >> confdefs.h <<\EOF
3529 #define HAVE_FINITEL 1
3530 EOF
3531
3532           cat >> confdefs.h <<\EOF
3533 #define HAVE_FLOORL 1
3534 EOF
3535
3536           cat >> confdefs.h <<\EOF
3537 #define HAVE_FMODL 1
3538 EOF
3539
3540           cat >> confdefs.h <<\EOF
3541 #define HAVE_FREXPL 1
3542 EOF
3543
3544           cat >> confdefs.h <<\EOF
3545 #define HAVE_ISINFL 1
3546 EOF
3547
3548           cat >> confdefs.h <<\EOF
3549 #define HAVE_ISNANL 1
3550 EOF
3551
3552           cat >> confdefs.h <<\EOF
3553 #define HAVE_LDEXPL 1
3554 EOF
3555
3556           cat >> confdefs.h <<\EOF
3557 #define HAVE_LOG10L 1
3558 EOF
3559
3560           cat >> confdefs.h <<\EOF
3561 #define HAVE_LOGL 1
3562 EOF
3563
3564           cat >> confdefs.h <<\EOF
3565 #define HAVE_MODFL 1
3566 EOF
3567
3568           cat >> confdefs.h <<\EOF
3569 #define HAVE_POWL 1
3570 EOF
3571
3572           cat >> confdefs.h <<\EOF
3573 #define HAVE_SINCOSL 1
3574 EOF
3575
3576           cat >> confdefs.h <<\EOF
3577 #define HAVE_SINL 1
3578 EOF
3579
3580           cat >> confdefs.h <<\EOF
3581 #define HAVE_SINHL 1
3582 EOF
3583
3584           cat >> confdefs.h <<\EOF
3585 #define HAVE_SQRTL 1
3586 EOF
3587
3588           cat >> confdefs.h <<\EOF
3589 #define HAVE_TANL 1
3590 EOF
3591
3592           cat >> confdefs.h <<\EOF
3593 #define HAVE_TANHL 1
3594 EOF
3595
3596         fi
3597
3598     echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
3599 echo "configure:3600: checking for main in -lm" >&5
3600 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
3601 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
3602   echo $ac_n "(cached) $ac_c" 1>&6
3603 else
3604   ac_save_LIBS="$LIBS"
3605 LIBS="-lm  $LIBS"
3606 cat > conftest.$ac_ext <<EOF
3607 #line 3608 "configure"
3608 #include "confdefs.h"
3609
3610 int main() {
3611 main()
3612 ; return 0; }
3613 EOF
3614 if { (eval echo configure:3615: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3615   rm -rf conftest*
3616   eval "ac_cv_lib_$ac_lib_var=yes"
3617 else
3618   echo "configure: failed program was:" >&5
3619   cat conftest.$ac_ext >&5
3620   rm -rf conftest*
3621   eval "ac_cv_lib_$ac_lib_var=no"
3622 fi
3623 rm -f conftest*
3624 LIBS="$ac_save_LIBS"
3625
3626 fi
3627 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
3628   echo "$ac_t""yes" 1>&6
3629     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
3630     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
3631   cat >> confdefs.h <<EOF
3632 #define $ac_tr_lib 1
3633 EOF
3634
3635   LIBS="-lm $LIBS"
3636
3637 else
3638   echo "$ac_t""no" 1>&6
3639 fi
3640
3641   for ac_func in nan hypot hypotf atan2f expf copysignf
3642 do
3643 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3644 echo "configure:3645: checking for $ac_func" >&5
3645 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3646   echo $ac_n "(cached) $ac_c" 1>&6
3647 else
3648   cat > conftest.$ac_ext <<EOF
3649 #line 3650 "configure"
3650 #include "confdefs.h"
3651 /* System header to define __stub macros and hopefully few prototypes,
3652     which can conflict with char $ac_func(); below.  */
3653 #include <assert.h>
3654 /* Override any gcc2 internal prototype to avoid an error.  */
3655 /* We use char because int might match the return type of a gcc2
3656     builtin and then its argument prototype would still apply.  */
3657 char $ac_func();
3658
3659 int main() {
3660
3661 /* The GNU C library defines this for functions which it implements
3662     to always fail with ENOSYS.  Some functions are actually named
3663     something starting with __ and the normal name is an alias.  */
3664 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3665 choke me
3666 #else
3667 $ac_func();
3668 #endif
3669
3670 ; return 0; }
3671 EOF
3672 if { (eval echo configure:3673: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3673   rm -rf conftest*
3674   eval "ac_cv_func_$ac_func=yes"
3675 else
3676   echo "configure: failed program was:" >&5
3677   cat conftest.$ac_ext >&5
3678   rm -rf conftest*
3679   eval "ac_cv_func_$ac_func=no"
3680 fi
3681 rm -f conftest*
3682 fi
3683
3684 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3685   echo "$ac_t""yes" 1>&6
3686     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3687   cat >> confdefs.h <<EOF
3688 #define $ac_tr_func 1
3689 EOF
3690
3691 else
3692   echo "$ac_t""no" 1>&6
3693 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3694 fi
3695 done
3696
3697
3698
3699           USE_COMPLEX_LONG_DOUBLE=no
3700   if test x$ac_cv_func_atan2l = x"yes" \
3701      && test x$ac_cv_func_copysignl = x"yes"; then
3702     USE_COMPLEX_LONG_DOUBLE=yes
3703     for ac_func in hypotl signbitl
3704 do
3705 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3706 echo "configure:3707: checking for $ac_func" >&5
3707 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3708   echo $ac_n "(cached) $ac_c" 1>&6
3709 else
3710   cat > conftest.$ac_ext <<EOF
3711 #line 3712 "configure"
3712 #include "confdefs.h"
3713 /* System header to define __stub macros and hopefully few prototypes,
3714     which can conflict with char $ac_func(); below.  */
3715 #include <assert.h>
3716 /* Override any gcc2 internal prototype to avoid an error.  */
3717 /* We use char because int might match the return type of a gcc2
3718     builtin and then its argument prototype would still apply.  */
3719 char $ac_func();
3720
3721 int main() {
3722
3723 /* The GNU C library defines this for functions which it implements
3724     to always fail with ENOSYS.  Some functions are actually named
3725     something starting with __ and the normal name is an alias.  */
3726 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3727 choke me
3728 #else
3729 $ac_func();
3730 #endif
3731
3732 ; return 0; }
3733 EOF
3734 if { (eval echo configure:3735: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3735   rm -rf conftest*
3736   eval "ac_cv_func_$ac_func=yes"
3737 else
3738   echo "configure: failed program was:" >&5
3739   cat conftest.$ac_ext >&5
3740   rm -rf conftest*
3741   eval "ac_cv_func_$ac_func=no"
3742 fi
3743 rm -f conftest*
3744 fi
3745
3746 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3747   echo "$ac_t""yes" 1>&6
3748     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3749   cat >> confdefs.h <<EOF
3750 #define $ac_tr_func 1
3751 EOF
3752
3753 else
3754   echo "$ac_t""no" 1>&6
3755 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3756 fi
3757 done
3758
3759
3760   fi
3761
3762
3763
3764
3765
3766
3767   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
3768 echo "configure:3769: checking for GNU C++ __complex__ support" >&5
3769   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
3770   echo $ac_n "(cached) $ac_c" 1>&6
3771 else
3772
3773
3774     ac_ext=C
3775 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3776 ac_cpp='$CXXCPP $CPPFLAGS'
3777 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3778 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3779 cross_compiling=$ac_cv_prog_cxx_cross
3780
3781     cat > conftest.$ac_ext <<EOF
3782 #line 3783 "configure"
3783 #include "confdefs.h"
3784 struct dcomplex { __complex__ double x; }; \
3785                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
3786 int main() {
3787 \
3788                      dcomplex x; f(x);
3789 ; return 0; }
3790 EOF
3791 if { (eval echo configure:3792: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3792   rm -rf conftest*
3793   glibcpp_cv_complex=ok
3794 else
3795   echo "configure: failed program was:" >&5
3796   cat conftest.$ac_ext >&5
3797   rm -rf conftest*
3798   glibcpp_cv_complex=buggy
3799
3800 fi
3801 rm -f conftest*
3802     ac_ext=c
3803 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3804 ac_cpp='$CPP $CPPFLAGS'
3805 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3806 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3807 cross_compiling=$ac_cv_prog_cc_cross
3808
3809
3810 fi
3811
3812   echo "$ac_t""$glibcpp_cv_complex" 1>&6
3813   if test $glibcpp_cv_complex = buggy; then
3814     cat >> confdefs.h <<\EOF
3815 #define _GLIBCPP_BUGGY_COMPLEX 1
3816 EOF
3817
3818   fi
3819
3820   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
3821 echo "configure:3822: checking for GNU C++ __complex__ float support" >&5
3822   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
3823   echo $ac_n "(cached) $ac_c" 1>&6
3824 else
3825
3826
3827     ac_ext=C
3828 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3829 ac_cpp='$CXXCPP $CPPFLAGS'
3830 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3831 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3832 cross_compiling=$ac_cv_prog_cxx_cross
3833
3834     rm -f conftest.h
3835     cat > conftest.h <<EOB
3836       //
3837       // Check for buggy __complex__ that causes ICE in most versions of egcs
3838       // and gcc-2.95.x on certain platforms (eg., x86-win32).
3839       //
3840       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
3841       // more info on the bug itself.
3842       //
3843       struct
3844       float_complex
3845       {
3846        __complex__ float m_value;
3847        float_complex (float = 0.0f, float = 0.0f);
3848        float_complex (__complex__ float val) : m_value (val) {}
3849        float_complex foo (const float_complex &val)
3850          { return float_complex (~val.m_value); }
3851       };
3852 EOB
3853     cat > conftest.$ac_ext <<EOF
3854 #line 3855 "configure"
3855 #include "confdefs.h"
3856 #include "conftest.h"
3857 int main() {
3858
3859 ; return 0; }
3860 EOF
3861 if { (eval echo configure:3862: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3862   rm -rf conftest*
3863   glibcpp_cv_float_complex=ok
3864 else
3865   echo "configure: failed program was:" >&5
3866   cat conftest.$ac_ext >&5
3867   rm -rf conftest*
3868   glibcpp_cv_float_complex=buggy
3869
3870 fi
3871 rm -f conftest*
3872     ac_ext=c
3873 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3874 ac_cpp='$CPP $CPPFLAGS'
3875 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3876 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3877 cross_compiling=$ac_cv_prog_cc_cross
3878
3879
3880 fi
3881
3882   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
3883   if test $glibcpp_cv_float_complex = buggy; then
3884     cat >> confdefs.h <<\EOF
3885 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3886 EOF
3887
3888   fi
3889
3890
3891   if test x$enable_c_mbchar != xno; then
3892
3893         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
3894 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
3895 echo "configure:3896: checking for wchar.h" >&5
3896 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3897   echo $ac_n "(cached) $ac_c" 1>&6
3898 else
3899   cat > conftest.$ac_ext <<EOF
3900 #line 3901 "configure"
3901 #include "confdefs.h"
3902 #include <wchar.h>
3903 EOF
3904 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3905 { (eval echo configure:3906: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3906 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3907 if test -z "$ac_err"; then
3908   rm -rf conftest*
3909   eval "ac_cv_header_$ac_safe=yes"
3910 else
3911   echo "$ac_err" >&5
3912   echo "configure: failed program was:" >&5
3913   cat conftest.$ac_ext >&5
3914   rm -rf conftest*
3915   eval "ac_cv_header_$ac_safe=no"
3916 fi
3917 rm -f conftest*
3918 fi
3919 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3920   echo "$ac_t""yes" 1>&6
3921   ac_has_wchar_h=yes
3922 else
3923   echo "$ac_t""no" 1>&6
3924 ac_has_wchar_h=no
3925 fi
3926
3927     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
3928 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
3929 echo "configure:3930: checking for wctype.h" >&5
3930 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3931   echo $ac_n "(cached) $ac_c" 1>&6
3932 else
3933   cat > conftest.$ac_ext <<EOF
3934 #line 3935 "configure"
3935 #include "confdefs.h"
3936 #include <wctype.h>
3937 EOF
3938 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3939 { (eval echo configure:3940: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3940 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3941 if test -z "$ac_err"; then
3942   rm -rf conftest*
3943   eval "ac_cv_header_$ac_safe=yes"
3944 else
3945   echo "$ac_err" >&5
3946   echo "configure: failed program was:" >&5
3947   cat conftest.$ac_ext >&5
3948   rm -rf conftest*
3949   eval "ac_cv_header_$ac_safe=no"
3950 fi
3951 rm -f conftest*
3952 fi
3953 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3954   echo "$ac_t""yes" 1>&6
3955   ac_has_wctype_h=yes
3956 else
3957   echo "$ac_t""no" 1>&6
3958 ac_has_wctype_h=no
3959 fi
3960
3961
3962         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
3963
3964                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
3965 echo "configure:3966: checking for mbstate_t" >&5
3966       cat > conftest.$ac_ext <<EOF
3967 #line 3968 "configure"
3968 #include "confdefs.h"
3969 #include <wchar.h>
3970 int main() {
3971 mbstate_t teststate;
3972 ; return 0; }
3973 EOF
3974 if { (eval echo configure:3975: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3975   rm -rf conftest*
3976   use_native_mbstatet=yes
3977 else
3978   echo "configure: failed program was:" >&5
3979   cat conftest.$ac_ext >&5
3980   rm -rf conftest*
3981   use_native_mbstatet=no
3982 fi
3983 rm -f conftest*
3984       echo "$ac_t""$use_native_mbstatet" 1>&6
3985
3986                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
3987 echo "configure:3988: checking for WCHAR_MIN and WCHAR_MAX" >&5
3988       cat > conftest.$ac_ext <<EOF
3989 #line 3990 "configure"
3990 #include "confdefs.h"
3991 #include <wchar.h>
3992 int main() {
3993 int i = WCHAR_MIN; int j = WCHAR_MAX;
3994 ; return 0; }
3995 EOF
3996 if { (eval echo configure:3997: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3997   rm -rf conftest*
3998   has_wchar_minmax=yes
3999 else
4000   echo "configure: failed program was:" >&5
4001   cat conftest.$ac_ext >&5
4002   rm -rf conftest*
4003   has_wchar_minmax=no
4004 fi
4005 rm -f conftest*
4006       echo "$ac_t""$has_wchar_minmax" 1>&6
4007
4008                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
4009 echo "configure:4010: checking for WEOF" >&5
4010       cat > conftest.$ac_ext <<EOF
4011 #line 4012 "configure"
4012 #include "confdefs.h"
4013
4014         #include <wchar.h>
4015         #include <stddef.h>
4016 int main() {
4017 wint_t i = WEOF;
4018 ; return 0; }
4019 EOF
4020 if { (eval echo configure:4021: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4021   rm -rf conftest*
4022   has_weof=yes
4023 else
4024   echo "configure: failed program was:" >&5
4025   cat conftest.$ac_ext >&5
4026   rm -rf conftest*
4027   has_weof=no
4028 fi
4029 rm -f conftest*
4030       echo "$ac_t""$has_weof" 1>&6
4031
4032             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
4033       wcsrtombs mbsrtowcs
4034 do
4035 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4036 echo "configure:4037: checking for $ac_func" >&5
4037 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4038   echo $ac_n "(cached) $ac_c" 1>&6
4039 else
4040   cat > conftest.$ac_ext <<EOF
4041 #line 4042 "configure"
4042 #include "confdefs.h"
4043 /* System header to define __stub macros and hopefully few prototypes,
4044     which can conflict with char $ac_func(); below.  */
4045 #include <assert.h>
4046 /* Override any gcc2 internal prototype to avoid an error.  */
4047 /* We use char because int might match the return type of a gcc2
4048     builtin and then its argument prototype would still apply.  */
4049 char $ac_func();
4050
4051 int main() {
4052
4053 /* The GNU C library defines this for functions which it implements
4054     to always fail with ENOSYS.  Some functions are actually named
4055     something starting with __ and the normal name is an alias.  */
4056 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4057 choke me
4058 #else
4059 $ac_func();
4060 #endif
4061
4062 ; return 0; }
4063 EOF
4064 if { (eval echo configure:4065: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4065   rm -rf conftest*
4066   eval "ac_cv_func_$ac_func=yes"
4067 else
4068   echo "configure: failed program was:" >&5
4069   cat conftest.$ac_ext >&5
4070   rm -rf conftest*
4071   eval "ac_cv_func_$ac_func=no"
4072 fi
4073 rm -f conftest*
4074 fi
4075
4076 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4077   echo "$ac_t""yes" 1>&6
4078     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4079   cat >> confdefs.h <<EOF
4080 #define $ac_tr_func 1
4081 EOF
4082  ac_wfuncs=yes
4083 else
4084   echo "$ac_t""no" 1>&6
4085 ac_wfuncs=no
4086 fi
4087 done
4088
4089
4090       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
4091 echo "configure:4092: checking for ISO C99 wchar_t support" >&5
4092       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
4093          && test x"$ac_wfuncs" = xyes; then
4094         ac_isoC99_wchar_t=yes
4095       else
4096         ac_isoC99_wchar_t=no
4097       fi
4098       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
4099
4100                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
4101 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
4102 echo "configure:4103: checking for iconv.h" >&5
4103 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4104   echo $ac_n "(cached) $ac_c" 1>&6
4105 else
4106   cat > conftest.$ac_ext <<EOF
4107 #line 4108 "configure"
4108 #include "confdefs.h"
4109 #include <iconv.h>
4110 EOF
4111 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4112 { (eval echo configure:4113: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4113 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4114 if test -z "$ac_err"; then
4115   rm -rf conftest*
4116   eval "ac_cv_header_$ac_safe=yes"
4117 else
4118   echo "$ac_err" >&5
4119   echo "configure: failed program was:" >&5
4120   cat conftest.$ac_ext >&5
4121   rm -rf conftest*
4122   eval "ac_cv_header_$ac_safe=no"
4123 fi
4124 rm -f conftest*
4125 fi
4126 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4127   echo "$ac_t""yes" 1>&6
4128   ac_has_iconv_h=yes
4129 else
4130   echo "$ac_t""no" 1>&6
4131 ac_has_iconv_h=no
4132 fi
4133
4134       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
4135 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
4136 echo "configure:4137: checking for langinfo.h" >&5
4137 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4138   echo $ac_n "(cached) $ac_c" 1>&6
4139 else
4140   cat > conftest.$ac_ext <<EOF
4141 #line 4142 "configure"
4142 #include "confdefs.h"
4143 #include <langinfo.h>
4144 EOF
4145 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4146 { (eval echo configure:4147: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4147 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4148 if test -z "$ac_err"; then
4149   rm -rf conftest*
4150   eval "ac_cv_header_$ac_safe=yes"
4151 else
4152   echo "$ac_err" >&5
4153   echo "configure: failed program was:" >&5
4154   cat conftest.$ac_ext >&5
4155   rm -rf conftest*
4156   eval "ac_cv_header_$ac_safe=no"
4157 fi
4158 rm -f conftest*
4159 fi
4160 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4161   echo "$ac_t""yes" 1>&6
4162   ac_has_langinfo_h=yes
4163 else
4164   echo "$ac_t""no" 1>&6
4165 ac_has_langinfo_h=no
4166 fi
4167
4168
4169             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
4170 echo "configure:4171: checking for iconv in -liconv" >&5
4171 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
4172 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4173   echo $ac_n "(cached) $ac_c" 1>&6
4174 else
4175   ac_save_LIBS="$LIBS"
4176 LIBS="-liconv  $LIBS"
4177 cat > conftest.$ac_ext <<EOF
4178 #line 4179 "configure"
4179 #include "confdefs.h"
4180 /* Override any gcc2 internal prototype to avoid an error.  */
4181 /* We use char because int might match the return type of a gcc2
4182     builtin and then its argument prototype would still apply.  */
4183 char iconv();
4184
4185 int main() {
4186 iconv()
4187 ; return 0; }
4188 EOF
4189 if { (eval echo configure:4190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4190   rm -rf conftest*
4191   eval "ac_cv_lib_$ac_lib_var=yes"
4192 else
4193   echo "configure: failed program was:" >&5
4194   cat conftest.$ac_ext >&5
4195   rm -rf conftest*
4196   eval "ac_cv_lib_$ac_lib_var=no"
4197 fi
4198 rm -f conftest*
4199 LIBS="$ac_save_LIBS"
4200
4201 fi
4202 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4203   echo "$ac_t""yes" 1>&6
4204   libiconv="-liconv"
4205 else
4206   echo "$ac_t""no" 1>&6
4207 fi
4208
4209       ac_save_LIBS="$LIBS"
4210       LIBS="$LIBS $libiconv"
4211
4212       for ac_func in iconv_open iconv_close iconv nl_langinfo
4213 do
4214 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4215 echo "configure:4216: checking for $ac_func" >&5
4216 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4217   echo $ac_n "(cached) $ac_c" 1>&6
4218 else
4219   cat > conftest.$ac_ext <<EOF
4220 #line 4221 "configure"
4221 #include "confdefs.h"
4222 /* System header to define __stub macros and hopefully few prototypes,
4223     which can conflict with char $ac_func(); below.  */
4224 #include <assert.h>
4225 /* Override any gcc2 internal prototype to avoid an error.  */
4226 /* We use char because int might match the return type of a gcc2
4227     builtin and then its argument prototype would still apply.  */
4228 char $ac_func();
4229
4230 int main() {
4231
4232 /* The GNU C library defines this for functions which it implements
4233     to always fail with ENOSYS.  Some functions are actually named
4234     something starting with __ and the normal name is an alias.  */
4235 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4236 choke me
4237 #else
4238 $ac_func();
4239 #endif
4240
4241 ; return 0; }
4242 EOF
4243 if { (eval echo configure:4244: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4244   rm -rf conftest*
4245   eval "ac_cv_func_$ac_func=yes"
4246 else
4247   echo "configure: failed program was:" >&5
4248   cat conftest.$ac_ext >&5
4249   rm -rf conftest*
4250   eval "ac_cv_func_$ac_func=no"
4251 fi
4252 rm -f conftest*
4253 fi
4254
4255 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4256   echo "$ac_t""yes" 1>&6
4257     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4258   cat >> confdefs.h <<EOF
4259 #define $ac_tr_func 1
4260 EOF
4261  \
4262       ac_XPG2funcs=yes
4263 else
4264   echo "$ac_t""no" 1>&6
4265 ac_XPG2funcs=no
4266 fi
4267 done
4268
4269
4270       LIBS="$ac_save_LIBS"
4271
4272       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
4273 echo "configure:4274: checking for XPG2 wchar_t support" >&5
4274       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
4275          && test x"$ac_XPG2funcs" = xyes; then
4276         ac_XPG2_wchar_t=yes
4277       else
4278         ac_XPG2_wchar_t=no
4279       fi
4280       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
4281
4282                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
4283 echo "configure:4284: checking for enabled wchar_t specializations" >&5
4284       if test x"$ac_isoC99_wchar_t" = xyes \
4285          && test x"$ac_XPG2_wchar_t" = xyes; then
4286         libinst_wstring_la="libinst-wstring.la"
4287         cat >> confdefs.h <<\EOF
4288 #define _GLIBCPP_USE_WCHAR_T 1
4289 EOF
4290
4291         echo "$ac_t"""yes"" 1>&6
4292       else
4293         libinst_wstring_la=""
4294         echo "$ac_t"""no"" 1>&6
4295       fi
4296
4297
4298     else
4299       echo "configure: warning: <wchar.h> not found" 1>&2
4300     fi
4301
4302   else
4303         :
4304   fi
4305
4306         # GLIBCPP_CHECK_CTYPE_SUPPORT
4307         ctype_include_dir="config/os/gnu-linux"
4308         # GLIBCPP_CHECK_STDLIB_SUPPORT
4309         cat >> confdefs.h <<\EOF
4310 #define HAVE_STRTOF 1
4311 EOF
4312
4313         cat >> confdefs.h <<\EOF
4314 #define HAVE_STRTOLD 1
4315 EOF
4316
4317         # AC_FUNC_MMAP
4318         cat >> confdefs.h <<\EOF
4319 #define HAVE_MMAP 1
4320 EOF
4321
4322         ;;
4323     *)
4324         # We assume newlib.  This lets us hard-code the functions we know
4325         # we'll have.
4326         cat >> confdefs.h <<\EOF
4327 #define HAVE_FINITE 1
4328 EOF
4329
4330         cat >> confdefs.h <<\EOF
4331 #define HAVE_ISNAN 1
4332 EOF
4333
4334         cat >> confdefs.h <<\EOF
4335 #define HAVE_ISNANF 1
4336 EOF
4337
4338         cat >> confdefs.h <<\EOF
4339 #define HAVE_ISINF 1
4340 EOF
4341
4342         cat >> confdefs.h <<\EOF
4343 #define HAVE_ISINFF 1
4344 EOF
4345
4346
4347         ctype_include_dir="config/os/newlib"
4348         os_include_dir="config/os/newlib"
4349
4350         cat >> confdefs.h <<\EOF
4351 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
4352 EOF
4353
4354         cat >> confdefs.h <<\EOF
4355 #define _GLIBCPP_BUGGY_COMPLEX 1
4356 EOF
4357
4358         # need to check for faster f versions of math functions, ie sinf?
4359         ;;
4360   esac
4361 else
4362
4363   # We are being configured natively. We can do more elaborate tests
4364   # that include AC_TRY_COMPILE now, as the linker is assumed to be
4365   # working.
4366   xcompiling=0
4367   NATIVE=yes
4368   CANADIAN=no
4369   NULL_TARGET=no
4370
4371   # Check for available headers.
4372   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
4373   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
4374 do
4375 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
4376 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
4377 echo "configure:4378: checking for $ac_hdr" >&5
4378 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4379   echo $ac_n "(cached) $ac_c" 1>&6
4380 else
4381   cat > conftest.$ac_ext <<EOF
4382 #line 4383 "configure"
4383 #include "confdefs.h"
4384 #include <$ac_hdr>
4385 EOF
4386 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4387 { (eval echo configure:4388: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4388 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4389 if test -z "$ac_err"; then
4390   rm -rf conftest*
4391   eval "ac_cv_header_$ac_safe=yes"
4392 else
4393   echo "$ac_err" >&5
4394   echo "configure: failed program was:" >&5
4395   cat conftest.$ac_ext >&5
4396   rm -rf conftest*
4397   eval "ac_cv_header_$ac_safe=no"
4398 fi
4399 rm -f conftest*
4400 fi
4401 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4402   echo "$ac_t""yes" 1>&6
4403     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
4404   cat >> confdefs.h <<EOF
4405 #define $ac_tr_hdr 1
4406 EOF
4407
4408 else
4409   echo "$ac_t""no" 1>&6
4410 fi
4411 done
4412
4413
4414
4415   # All these tests are for C++; save the language and the compiler flags.
4416   # The CXXFLAGS thing is suspicious, but based on similar bits
4417   # found in GLIBCPP_CONFIGURE.
4418
4419   ac_ext=C
4420 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4421 ac_cpp='$CXXCPP $CPPFLAGS'
4422 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4423 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4424 cross_compiling=$ac_cv_prog_cxx_cross
4425
4426   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4427   ac_save_CXXFLAGS="$CXXFLAGS"
4428
4429   # Check for maintainer-mode bits.
4430   if test x"$USE_MAINTAINER_MODE" = xno; then
4431     WERROR=''
4432   else
4433     WERROR='-Werror'
4434   fi
4435
4436   # Check for more sophisticated diagnostic control.
4437   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
4438 echo "configure:4439: checking for g++ that supports -fdiagnostics-show-location=once" >&5
4439   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
4440   cat > conftest.$ac_ext <<EOF
4441 #line 4442 "configure"
4442 #include "confdefs.h"
4443
4444 int main() {
4445 int foo;
4446
4447 ; return 0; }
4448 EOF
4449 if { (eval echo configure:4450: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4450   rm -rf conftest*
4451   ac_gabydiags=yes
4452 else
4453   echo "configure: failed program was:" >&5
4454   cat conftest.$ac_ext >&5
4455   rm -rf conftest*
4456   ac_gabydiags=no
4457 fi
4458 rm -f conftest*
4459   if test "$ac_test_CXXFLAGS" = set; then
4460     CXXFLAGS="$ac_save_CXXFLAGS"
4461   else
4462     # this is the suspicious part
4463     CXXFLAGS=''
4464   fi
4465   if test x"$ac_gabydiags" = x"yes"; then
4466     WFMT_FLAGS='-fdiagnostics-show-location=once'
4467   fi
4468   echo "$ac_t""$ac_gabydiags" 1>&6
4469
4470   # Check for -ffunction-sections -fdata-sections
4471   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
4472 echo "configure:4473: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
4473   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
4474   cat > conftest.$ac_ext <<EOF
4475 #line 4476 "configure"
4476 #include "confdefs.h"
4477
4478 int main() {
4479 int foo;
4480
4481 ; return 0; }
4482 EOF
4483 if { (eval echo configure:4484: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4484   rm -rf conftest*
4485   ac_fdsections=yes
4486 else
4487   echo "configure: failed program was:" >&5
4488   cat conftest.$ac_ext >&5
4489   rm -rf conftest*
4490   ac_fdsections=no
4491 fi
4492 rm -f conftest*
4493   if test "$ac_test_CXXFLAGS" = set; then
4494     CXXFLAGS="$ac_save_CXXFLAGS"
4495   else
4496     # this is the suspicious part
4497     CXXFLAGS=''
4498   fi
4499   if test x"$ac_fdsections" = x"yes" && test x"$enable_debug" = x"no"; then
4500     SECTION_FLAGS='-ffunction-sections -fdata-sections'
4501   fi
4502   echo "$ac_t""$ac_fdsections" 1>&6
4503
4504   ac_ext=c
4505 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4506 ac_cpp='$CPP $CPPFLAGS'
4507 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4508 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4509 cross_compiling=$ac_cv_prog_cc_cross
4510
4511
4512
4513
4514
4515
4516   # If we're not using GNU ld, then there's no point in even trying these
4517   # tests.  Check for that first.  We should have already tested for gld
4518   # by now (in libtool), but require it now just to be safe...
4519   SECTION_LDFLAGS=''
4520   OPT_LDFLAGS=''
4521
4522
4523   # Set --gc-sections.
4524   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
4525     # GNU ld it is!  Joy and bunny rabbits!
4526
4527     # All these tests are for C++; save the language and the compiler flags.
4528     # Need to do this so that g++ won't try to link in libstdc++
4529     ac_test_CFLAGS="${CFLAGS+set}"
4530     ac_save_CFLAGS="$CFLAGS"
4531     CFLAGS='-x c++  -Wl,--gc-sections'
4532
4533     # Check for -Wl,--gc-sections
4534     # XXX This test is broken at the moment, as symbols required for
4535     # linking are now in libsupc++ (not built yet.....). In addition,
4536     # this test has cored on solaris in the past. In addition,
4537     # --gc-sections doesn't really work at the moment (keeps on discarding
4538     # used sections, first .eh_frame and now some of the glibc sections for
4539     # iconv). Bzzzzt. Thanks for playing, maybe next time.
4540     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
4541 echo "configure:4542: checking for ld that supports -Wl,--gc-sections" >&5
4542     if test "$cross_compiling" = yes; then
4543   ac_sectionLDflags=yes
4544 else
4545   cat > conftest.$ac_ext <<EOF
4546 #line 4547 "configure"
4547 #include "confdefs.h"
4548
4549      int main(void)
4550      {
4551        try { throw 1; }
4552        catch (...) { };
4553        return 0;
4554      }
4555
4556 EOF
4557 if { (eval echo configure:4558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
4558 then
4559   ac_sectionLDflags=yes
4560 else
4561   echo "configure: failed program was:" >&5
4562   cat conftest.$ac_ext >&5
4563   rm -fr conftest*
4564   ac_sectionLFflags=no
4565 fi
4566 rm -fr conftest*
4567 fi
4568
4569     if test "$ac_test_CFLAGS" = set; then
4570       CFLAGS="$ac_save_CFLAGS"
4571     else
4572       # this is the suspicious part
4573       CFLAGS=''
4574     fi
4575     if test "$ac_sectionLDflags" = "yes"; then
4576       SECTION_LDFLAGS='-Wl,--gc-sections'
4577     fi
4578     echo "$ac_t""$ac_sectionLDflags" 1>&6
4579   fi
4580
4581   # Set linker optimization flags.
4582   if test x"$ac_cv_prog_gnu_ld" = x"yes" && test x"$enable_debug" = x"no"; then
4583     OPT_LDFLAGS='-Wl,-O1'
4584   fi
4585
4586
4587
4588
4589
4590
4591   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
4592 echo "configure:4593: checking for __builtin_abs declaration" >&5
4593   if test x${glibcpp_cv_func___builtin_abs_use+set} != xset; then
4594     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
4595   echo $ac_n "(cached) $ac_c" 1>&6
4596 else
4597
4598
4599       ac_ext=C
4600 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4601 ac_cpp='$CXXCPP $CPPFLAGS'
4602 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4603 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4604 cross_compiling=$ac_cv_prog_cxx_cross
4605
4606       cat > conftest.$ac_ext <<EOF
4607 #line 4608 "configure"
4608 #include "confdefs.h"
4609 #include <math.h>
4610 int main() {
4611  __builtin_abs(0);
4612 ; return 0; }
4613 EOF
4614 if { (eval echo configure:4615: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4615   rm -rf conftest*
4616   glibcpp_cv_func___builtin_abs_use=yes
4617 else
4618   echo "configure: failed program was:" >&5
4619   cat conftest.$ac_ext >&5
4620   rm -rf conftest*
4621   glibcpp_cv_func___builtin_abs_use=no
4622 fi
4623 rm -f conftest*
4624       ac_ext=c
4625 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4626 ac_cpp='$CPP $CPPFLAGS'
4627 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4628 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4629 cross_compiling=$ac_cv_prog_cc_cross
4630
4631
4632 fi
4633
4634   fi
4635   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
4636   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
4637     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
4638 echo "configure:4639: checking for __builtin_abs linkage" >&5
4639     if test x${glibcpp_cv_func___builtin_abs_link+set} != xset; then
4640       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
4641   echo $ac_n "(cached) $ac_c" 1>&6
4642 else
4643
4644         cat > conftest.$ac_ext <<EOF
4645 #line 4646 "configure"
4646 #include "confdefs.h"
4647 #include <math.h>
4648 int main() {
4649  __builtin_abs(0);
4650 ; return 0; }
4651 EOF
4652 if { (eval echo configure:4653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4653   rm -rf conftest*
4654   glibcpp_cv_func___builtin_abs_link=yes
4655 else
4656   echo "configure: failed program was:" >&5
4657   cat conftest.$ac_ext >&5
4658   rm -rf conftest*
4659   glibcpp_cv_func___builtin_abs_link=no
4660 fi
4661 rm -f conftest*
4662
4663 fi
4664
4665     fi
4666     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
4667     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
4668       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4669       cat >> confdefs.h <<EOF
4670 #define ${ac_tr_func} 1
4671 EOF
4672
4673     fi
4674   fi
4675
4676
4677   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
4678 echo "configure:4679: checking for __builtin_fabsf declaration" >&5
4679   if test x${glibcpp_cv_func___builtin_fabsf_use+set} != xset; then
4680     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
4681   echo $ac_n "(cached) $ac_c" 1>&6
4682 else
4683
4684
4685       ac_ext=C
4686 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4687 ac_cpp='$CXXCPP $CPPFLAGS'
4688 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4689 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4690 cross_compiling=$ac_cv_prog_cxx_cross
4691
4692       cat > conftest.$ac_ext <<EOF
4693 #line 4694 "configure"
4694 #include "confdefs.h"
4695 #include <math.h>
4696 int main() {
4697  __builtin_fabsf(0);
4698 ; return 0; }
4699 EOF
4700 if { (eval echo configure:4701: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4701   rm -rf conftest*
4702   glibcpp_cv_func___builtin_fabsf_use=yes
4703 else
4704   echo "configure: failed program was:" >&5
4705   cat conftest.$ac_ext >&5
4706   rm -rf conftest*
4707   glibcpp_cv_func___builtin_fabsf_use=no
4708 fi
4709 rm -f conftest*
4710       ac_ext=c
4711 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4712 ac_cpp='$CPP $CPPFLAGS'
4713 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4714 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4715 cross_compiling=$ac_cv_prog_cc_cross
4716
4717
4718 fi
4719
4720   fi
4721   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
4722   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
4723     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
4724 echo "configure:4725: checking for __builtin_fabsf linkage" >&5
4725     if test x${glibcpp_cv_func___builtin_fabsf_link+set} != xset; then
4726       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
4727   echo $ac_n "(cached) $ac_c" 1>&6
4728 else
4729
4730         cat > conftest.$ac_ext <<EOF
4731 #line 4732 "configure"
4732 #include "confdefs.h"
4733 #include <math.h>
4734 int main() {
4735  __builtin_fabsf(0);
4736 ; return 0; }
4737 EOF
4738 if { (eval echo configure:4739: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4739   rm -rf conftest*
4740   glibcpp_cv_func___builtin_fabsf_link=yes
4741 else
4742   echo "configure: failed program was:" >&5
4743   cat conftest.$ac_ext >&5
4744   rm -rf conftest*
4745   glibcpp_cv_func___builtin_fabsf_link=no
4746 fi
4747 rm -f conftest*
4748
4749 fi
4750
4751     fi
4752     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
4753     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
4754       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4755       cat >> confdefs.h <<EOF
4756 #define ${ac_tr_func} 1
4757 EOF
4758
4759     fi
4760   fi
4761
4762
4763   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
4764 echo "configure:4765: checking for __builtin_fabs declaration" >&5
4765   if test x${glibcpp_cv_func___builtin_fabs_use+set} != xset; then
4766     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
4767   echo $ac_n "(cached) $ac_c" 1>&6
4768 else
4769
4770
4771       ac_ext=C
4772 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4773 ac_cpp='$CXXCPP $CPPFLAGS'
4774 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4775 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4776 cross_compiling=$ac_cv_prog_cxx_cross
4777
4778       cat > conftest.$ac_ext <<EOF
4779 #line 4780 "configure"
4780 #include "confdefs.h"
4781 #include <math.h>
4782 int main() {
4783  __builtin_fabs(0);
4784 ; return 0; }
4785 EOF
4786 if { (eval echo configure:4787: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4787   rm -rf conftest*
4788   glibcpp_cv_func___builtin_fabs_use=yes
4789 else
4790   echo "configure: failed program was:" >&5
4791   cat conftest.$ac_ext >&5
4792   rm -rf conftest*
4793   glibcpp_cv_func___builtin_fabs_use=no
4794 fi
4795 rm -f conftest*
4796       ac_ext=c
4797 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4798 ac_cpp='$CPP $CPPFLAGS'
4799 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4800 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4801 cross_compiling=$ac_cv_prog_cc_cross
4802
4803
4804 fi
4805
4806   fi
4807   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
4808   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
4809     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
4810 echo "configure:4811: checking for __builtin_fabs linkage" >&5
4811     if test x${glibcpp_cv_func___builtin_fabs_link+set} != xset; then
4812       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
4813   echo $ac_n "(cached) $ac_c" 1>&6
4814 else
4815
4816         cat > conftest.$ac_ext <<EOF
4817 #line 4818 "configure"
4818 #include "confdefs.h"
4819 #include <math.h>
4820 int main() {
4821  __builtin_fabs(0);
4822 ; return 0; }
4823 EOF
4824 if { (eval echo configure:4825: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4825   rm -rf conftest*
4826   glibcpp_cv_func___builtin_fabs_link=yes
4827 else
4828   echo "configure: failed program was:" >&5
4829   cat conftest.$ac_ext >&5
4830   rm -rf conftest*
4831   glibcpp_cv_func___builtin_fabs_link=no
4832 fi
4833 rm -f conftest*
4834
4835 fi
4836
4837     fi
4838     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
4839     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
4840       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4841       cat >> confdefs.h <<EOF
4842 #define ${ac_tr_func} 1
4843 EOF
4844
4845     fi
4846   fi
4847
4848
4849   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
4850 echo "configure:4851: checking for __builtin_fabsl declaration" >&5
4851   if test x${glibcpp_cv_func___builtin_fabsl_use+set} != xset; then
4852     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
4853   echo $ac_n "(cached) $ac_c" 1>&6
4854 else
4855
4856
4857       ac_ext=C
4858 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4859 ac_cpp='$CXXCPP $CPPFLAGS'
4860 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4861 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4862 cross_compiling=$ac_cv_prog_cxx_cross
4863
4864       cat > conftest.$ac_ext <<EOF
4865 #line 4866 "configure"
4866 #include "confdefs.h"
4867 #include <math.h>
4868 int main() {
4869  __builtin_fabsl(0);
4870 ; return 0; }
4871 EOF
4872 if { (eval echo configure:4873: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4873   rm -rf conftest*
4874   glibcpp_cv_func___builtin_fabsl_use=yes
4875 else
4876   echo "configure: failed program was:" >&5
4877   cat conftest.$ac_ext >&5
4878   rm -rf conftest*
4879   glibcpp_cv_func___builtin_fabsl_use=no
4880 fi
4881 rm -f conftest*
4882       ac_ext=c
4883 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4884 ac_cpp='$CPP $CPPFLAGS'
4885 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4886 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4887 cross_compiling=$ac_cv_prog_cc_cross
4888
4889
4890 fi
4891
4892   fi
4893   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
4894   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
4895     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
4896 echo "configure:4897: checking for __builtin_fabsl linkage" >&5
4897     if test x${glibcpp_cv_func___builtin_fabsl_link+set} != xset; then
4898       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
4899   echo $ac_n "(cached) $ac_c" 1>&6
4900 else
4901
4902         cat > conftest.$ac_ext <<EOF
4903 #line 4904 "configure"
4904 #include "confdefs.h"
4905 #include <math.h>
4906 int main() {
4907  __builtin_fabsl(0);
4908 ; return 0; }
4909 EOF
4910 if { (eval echo configure:4911: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4911   rm -rf conftest*
4912   glibcpp_cv_func___builtin_fabsl_link=yes
4913 else
4914   echo "configure: failed program was:" >&5
4915   cat conftest.$ac_ext >&5
4916   rm -rf conftest*
4917   glibcpp_cv_func___builtin_fabsl_link=no
4918 fi
4919 rm -f conftest*
4920
4921 fi
4922
4923     fi
4924     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
4925     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
4926       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4927       cat >> confdefs.h <<EOF
4928 #define ${ac_tr_func} 1
4929 EOF
4930
4931     fi
4932   fi
4933
4934
4935   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
4936 echo "configure:4937: checking for __builtin_labs declaration" >&5
4937   if test x${glibcpp_cv_func___builtin_labs_use+set} != xset; then
4938     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
4939   echo $ac_n "(cached) $ac_c" 1>&6
4940 else
4941
4942
4943       ac_ext=C
4944 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4945 ac_cpp='$CXXCPP $CPPFLAGS'
4946 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4947 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4948 cross_compiling=$ac_cv_prog_cxx_cross
4949
4950       cat > conftest.$ac_ext <<EOF
4951 #line 4952 "configure"
4952 #include "confdefs.h"
4953 #include <math.h>
4954 int main() {
4955  __builtin_labs(0);
4956 ; return 0; }
4957 EOF
4958 if { (eval echo configure:4959: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4959   rm -rf conftest*
4960   glibcpp_cv_func___builtin_labs_use=yes
4961 else
4962   echo "configure: failed program was:" >&5
4963   cat conftest.$ac_ext >&5
4964   rm -rf conftest*
4965   glibcpp_cv_func___builtin_labs_use=no
4966 fi
4967 rm -f conftest*
4968       ac_ext=c
4969 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4970 ac_cpp='$CPP $CPPFLAGS'
4971 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4972 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4973 cross_compiling=$ac_cv_prog_cc_cross
4974
4975
4976 fi
4977
4978   fi
4979   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
4980   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
4981     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
4982 echo "configure:4983: checking for __builtin_labs linkage" >&5
4983     if test x${glibcpp_cv_func___builtin_labs_link+set} != xset; then
4984       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
4985   echo $ac_n "(cached) $ac_c" 1>&6
4986 else
4987
4988         cat > conftest.$ac_ext <<EOF
4989 #line 4990 "configure"
4990 #include "confdefs.h"
4991 #include <math.h>
4992 int main() {
4993  __builtin_labs(0);
4994 ; return 0; }
4995 EOF
4996 if { (eval echo configure:4997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4997   rm -rf conftest*
4998   glibcpp_cv_func___builtin_labs_link=yes
4999 else
5000   echo "configure: failed program was:" >&5
5001   cat conftest.$ac_ext >&5
5002   rm -rf conftest*
5003   glibcpp_cv_func___builtin_labs_link=no
5004 fi
5005 rm -f conftest*
5006
5007 fi
5008
5009     fi
5010     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
5011     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
5012       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5013       cat >> confdefs.h <<EOF
5014 #define ${ac_tr_func} 1
5015 EOF
5016
5017     fi
5018   fi
5019
5020
5021
5022   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
5023 echo "configure:5024: checking for __builtin_sqrtf declaration" >&5
5024   if test x${glibcpp_cv_func___builtin_sqrtf_use+set} != xset; then
5025     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
5026   echo $ac_n "(cached) $ac_c" 1>&6
5027 else
5028
5029
5030       ac_ext=C
5031 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5032 ac_cpp='$CXXCPP $CPPFLAGS'
5033 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5034 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5035 cross_compiling=$ac_cv_prog_cxx_cross
5036
5037       cat > conftest.$ac_ext <<EOF
5038 #line 5039 "configure"
5039 #include "confdefs.h"
5040 #include <math.h>
5041 int main() {
5042  __builtin_sqrtf(0);
5043 ; return 0; }
5044 EOF
5045 if { (eval echo configure:5046: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5046   rm -rf conftest*
5047   glibcpp_cv_func___builtin_sqrtf_use=yes
5048 else
5049   echo "configure: failed program was:" >&5
5050   cat conftest.$ac_ext >&5
5051   rm -rf conftest*
5052   glibcpp_cv_func___builtin_sqrtf_use=no
5053 fi
5054 rm -f conftest*
5055       ac_ext=c
5056 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5057 ac_cpp='$CPP $CPPFLAGS'
5058 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5059 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5060 cross_compiling=$ac_cv_prog_cc_cross
5061
5062
5063 fi
5064
5065   fi
5066   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
5067   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
5068     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
5069 echo "configure:5070: checking for __builtin_sqrtf linkage" >&5
5070     if test x${glibcpp_cv_func___builtin_sqrtf_link+set} != xset; then
5071       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
5072   echo $ac_n "(cached) $ac_c" 1>&6
5073 else
5074
5075         cat > conftest.$ac_ext <<EOF
5076 #line 5077 "configure"
5077 #include "confdefs.h"
5078 #include <math.h>
5079 int main() {
5080  __builtin_sqrtf(0);
5081 ; return 0; }
5082 EOF
5083 if { (eval echo configure:5084: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5084   rm -rf conftest*
5085   glibcpp_cv_func___builtin_sqrtf_link=yes
5086 else
5087   echo "configure: failed program was:" >&5
5088   cat conftest.$ac_ext >&5
5089   rm -rf conftest*
5090   glibcpp_cv_func___builtin_sqrtf_link=no
5091 fi
5092 rm -f conftest*
5093
5094 fi
5095
5096     fi
5097     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
5098     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
5099       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5100       cat >> confdefs.h <<EOF
5101 #define ${ac_tr_func} 1
5102 EOF
5103
5104     fi
5105   fi
5106
5107
5108   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
5109 echo "configure:5110: checking for __builtin_fsqrt declaration" >&5
5110   if test x${glibcpp_cv_func___builtin_fsqrt_use+set} != xset; then
5111     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
5112   echo $ac_n "(cached) $ac_c" 1>&6
5113 else
5114
5115
5116       ac_ext=C
5117 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5118 ac_cpp='$CXXCPP $CPPFLAGS'
5119 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5120 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5121 cross_compiling=$ac_cv_prog_cxx_cross
5122
5123       cat > conftest.$ac_ext <<EOF
5124 #line 5125 "configure"
5125 #include "confdefs.h"
5126 #include <math.h>
5127 int main() {
5128  __builtin_fsqrt(0);
5129 ; return 0; }
5130 EOF
5131 if { (eval echo configure:5132: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5132   rm -rf conftest*
5133   glibcpp_cv_func___builtin_fsqrt_use=yes
5134 else
5135   echo "configure: failed program was:" >&5
5136   cat conftest.$ac_ext >&5
5137   rm -rf conftest*
5138   glibcpp_cv_func___builtin_fsqrt_use=no
5139 fi
5140 rm -f conftest*
5141       ac_ext=c
5142 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5143 ac_cpp='$CPP $CPPFLAGS'
5144 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5145 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5146 cross_compiling=$ac_cv_prog_cc_cross
5147
5148
5149 fi
5150
5151   fi
5152   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
5153   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
5154     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
5155 echo "configure:5156: checking for __builtin_fsqrt linkage" >&5
5156     if test x${glibcpp_cv_func___builtin_fsqrt_link+set} != xset; then
5157       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
5158   echo $ac_n "(cached) $ac_c" 1>&6
5159 else
5160
5161         cat > conftest.$ac_ext <<EOF
5162 #line 5163 "configure"
5163 #include "confdefs.h"
5164 #include <math.h>
5165 int main() {
5166  __builtin_fsqrt(0);
5167 ; return 0; }
5168 EOF
5169 if { (eval echo configure:5170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5170   rm -rf conftest*
5171   glibcpp_cv_func___builtin_fsqrt_link=yes
5172 else
5173   echo "configure: failed program was:" >&5
5174   cat conftest.$ac_ext >&5
5175   rm -rf conftest*
5176   glibcpp_cv_func___builtin_fsqrt_link=no
5177 fi
5178 rm -f conftest*
5179
5180 fi
5181
5182     fi
5183     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
5184     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
5185       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5186       cat >> confdefs.h <<EOF
5187 #define ${ac_tr_func} 1
5188 EOF
5189
5190     fi
5191   fi
5192
5193
5194   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
5195 echo "configure:5196: checking for __builtin_sqrtl declaration" >&5
5196   if test x${glibcpp_cv_func___builtin_sqrtl_use+set} != xset; then
5197     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
5198   echo $ac_n "(cached) $ac_c" 1>&6
5199 else
5200
5201
5202       ac_ext=C
5203 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5204 ac_cpp='$CXXCPP $CPPFLAGS'
5205 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5206 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5207 cross_compiling=$ac_cv_prog_cxx_cross
5208
5209       cat > conftest.$ac_ext <<EOF
5210 #line 5211 "configure"
5211 #include "confdefs.h"
5212 #include <math.h>
5213 int main() {
5214  __builtin_sqrtl(0);
5215 ; return 0; }
5216 EOF
5217 if { (eval echo configure:5218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5218   rm -rf conftest*
5219   glibcpp_cv_func___builtin_sqrtl_use=yes
5220 else
5221   echo "configure: failed program was:" >&5
5222   cat conftest.$ac_ext >&5
5223   rm -rf conftest*
5224   glibcpp_cv_func___builtin_sqrtl_use=no
5225 fi
5226 rm -f conftest*
5227       ac_ext=c
5228 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5229 ac_cpp='$CPP $CPPFLAGS'
5230 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5231 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5232 cross_compiling=$ac_cv_prog_cc_cross
5233
5234
5235 fi
5236
5237   fi
5238   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
5239   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
5240     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
5241 echo "configure:5242: checking for __builtin_sqrtl linkage" >&5
5242     if test x${glibcpp_cv_func___builtin_sqrtl_link+set} != xset; then
5243       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
5244   echo $ac_n "(cached) $ac_c" 1>&6
5245 else
5246
5247         cat > conftest.$ac_ext <<EOF
5248 #line 5249 "configure"
5249 #include "confdefs.h"
5250 #include <math.h>
5251 int main() {
5252  __builtin_sqrtl(0);
5253 ; return 0; }
5254 EOF
5255 if { (eval echo configure:5256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5256   rm -rf conftest*
5257   glibcpp_cv_func___builtin_sqrtl_link=yes
5258 else
5259   echo "configure: failed program was:" >&5
5260   cat conftest.$ac_ext >&5
5261   rm -rf conftest*
5262   glibcpp_cv_func___builtin_sqrtl_link=no
5263 fi
5264 rm -f conftest*
5265
5266 fi
5267
5268     fi
5269     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
5270     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
5271       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5272       cat >> confdefs.h <<EOF
5273 #define ${ac_tr_func} 1
5274 EOF
5275
5276     fi
5277   fi
5278
5279
5280
5281   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
5282 echo "configure:5283: checking for __builtin_sinf declaration" >&5
5283   if test x${glibcpp_cv_func___builtin_sinf_use+set} != xset; then
5284     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
5285   echo $ac_n "(cached) $ac_c" 1>&6
5286 else
5287
5288
5289       ac_ext=C
5290 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5291 ac_cpp='$CXXCPP $CPPFLAGS'
5292 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5293 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5294 cross_compiling=$ac_cv_prog_cxx_cross
5295
5296       cat > conftest.$ac_ext <<EOF
5297 #line 5298 "configure"
5298 #include "confdefs.h"
5299 #include <math.h>
5300 int main() {
5301  __builtin_sinf(0);
5302 ; return 0; }
5303 EOF
5304 if { (eval echo configure:5305: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5305   rm -rf conftest*
5306   glibcpp_cv_func___builtin_sinf_use=yes
5307 else
5308   echo "configure: failed program was:" >&5
5309   cat conftest.$ac_ext >&5
5310   rm -rf conftest*
5311   glibcpp_cv_func___builtin_sinf_use=no
5312 fi
5313 rm -f conftest*
5314       ac_ext=c
5315 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5316 ac_cpp='$CPP $CPPFLAGS'
5317 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5318 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5319 cross_compiling=$ac_cv_prog_cc_cross
5320
5321
5322 fi
5323
5324   fi
5325   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
5326   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
5327     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
5328 echo "configure:5329: checking for __builtin_sinf linkage" >&5
5329     if test x${glibcpp_cv_func___builtin_sinf_link+set} != xset; then
5330       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
5331   echo $ac_n "(cached) $ac_c" 1>&6
5332 else
5333
5334         cat > conftest.$ac_ext <<EOF
5335 #line 5336 "configure"
5336 #include "confdefs.h"
5337 #include <math.h>
5338 int main() {
5339  __builtin_sinf(0);
5340 ; return 0; }
5341 EOF
5342 if { (eval echo configure:5343: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5343   rm -rf conftest*
5344   glibcpp_cv_func___builtin_sinf_link=yes
5345 else
5346   echo "configure: failed program was:" >&5
5347   cat conftest.$ac_ext >&5
5348   rm -rf conftest*
5349   glibcpp_cv_func___builtin_sinf_link=no
5350 fi
5351 rm -f conftest*
5352
5353 fi
5354
5355     fi
5356     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
5357     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
5358       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5359       cat >> confdefs.h <<EOF
5360 #define ${ac_tr_func} 1
5361 EOF
5362
5363     fi
5364   fi
5365
5366
5367   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
5368 echo "configure:5369: checking for __builtin_sin declaration" >&5
5369   if test x${glibcpp_cv_func___builtin_sin_use+set} != xset; then
5370     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
5371   echo $ac_n "(cached) $ac_c" 1>&6
5372 else
5373
5374
5375       ac_ext=C
5376 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5377 ac_cpp='$CXXCPP $CPPFLAGS'
5378 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5379 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5380 cross_compiling=$ac_cv_prog_cxx_cross
5381
5382       cat > conftest.$ac_ext <<EOF
5383 #line 5384 "configure"
5384 #include "confdefs.h"
5385 #include <math.h>
5386 int main() {
5387  __builtin_sin(0);
5388 ; return 0; }
5389 EOF
5390 if { (eval echo configure:5391: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5391   rm -rf conftest*
5392   glibcpp_cv_func___builtin_sin_use=yes
5393 else
5394   echo "configure: failed program was:" >&5
5395   cat conftest.$ac_ext >&5
5396   rm -rf conftest*
5397   glibcpp_cv_func___builtin_sin_use=no
5398 fi
5399 rm -f conftest*
5400       ac_ext=c
5401 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5402 ac_cpp='$CPP $CPPFLAGS'
5403 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5404 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5405 cross_compiling=$ac_cv_prog_cc_cross
5406
5407
5408 fi
5409
5410   fi
5411   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
5412   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
5413     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
5414 echo "configure:5415: checking for __builtin_sin linkage" >&5
5415     if test x${glibcpp_cv_func___builtin_sin_link+set} != xset; then
5416       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
5417   echo $ac_n "(cached) $ac_c" 1>&6
5418 else
5419
5420         cat > conftest.$ac_ext <<EOF
5421 #line 5422 "configure"
5422 #include "confdefs.h"
5423 #include <math.h>
5424 int main() {
5425  __builtin_sin(0);
5426 ; return 0; }
5427 EOF
5428 if { (eval echo configure:5429: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5429   rm -rf conftest*
5430   glibcpp_cv_func___builtin_sin_link=yes
5431 else
5432   echo "configure: failed program was:" >&5
5433   cat conftest.$ac_ext >&5
5434   rm -rf conftest*
5435   glibcpp_cv_func___builtin_sin_link=no
5436 fi
5437 rm -f conftest*
5438
5439 fi
5440
5441     fi
5442     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
5443     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
5444       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5445       cat >> confdefs.h <<EOF
5446 #define ${ac_tr_func} 1
5447 EOF
5448
5449     fi
5450   fi
5451
5452
5453   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
5454 echo "configure:5455: checking for __builtin_sinl declaration" >&5
5455   if test x${glibcpp_cv_func___builtin_sinl_use+set} != xset; then
5456     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
5457   echo $ac_n "(cached) $ac_c" 1>&6
5458 else
5459
5460
5461       ac_ext=C
5462 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5463 ac_cpp='$CXXCPP $CPPFLAGS'
5464 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5465 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5466 cross_compiling=$ac_cv_prog_cxx_cross
5467
5468       cat > conftest.$ac_ext <<EOF
5469 #line 5470 "configure"
5470 #include "confdefs.h"
5471 #include <math.h>
5472 int main() {
5473  __builtin_sinl(0);
5474 ; return 0; }
5475 EOF
5476 if { (eval echo configure:5477: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5477   rm -rf conftest*
5478   glibcpp_cv_func___builtin_sinl_use=yes
5479 else
5480   echo "configure: failed program was:" >&5
5481   cat conftest.$ac_ext >&5
5482   rm -rf conftest*
5483   glibcpp_cv_func___builtin_sinl_use=no
5484 fi
5485 rm -f conftest*
5486       ac_ext=c
5487 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5488 ac_cpp='$CPP $CPPFLAGS'
5489 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5490 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5491 cross_compiling=$ac_cv_prog_cc_cross
5492
5493
5494 fi
5495
5496   fi
5497   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
5498   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
5499     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
5500 echo "configure:5501: checking for __builtin_sinl linkage" >&5
5501     if test x${glibcpp_cv_func___builtin_sinl_link+set} != xset; then
5502       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
5503   echo $ac_n "(cached) $ac_c" 1>&6
5504 else
5505
5506         cat > conftest.$ac_ext <<EOF
5507 #line 5508 "configure"
5508 #include "confdefs.h"
5509 #include <math.h>
5510 int main() {
5511  __builtin_sinl(0);
5512 ; return 0; }
5513 EOF
5514 if { (eval echo configure:5515: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5515   rm -rf conftest*
5516   glibcpp_cv_func___builtin_sinl_link=yes
5517 else
5518   echo "configure: failed program was:" >&5
5519   cat conftest.$ac_ext >&5
5520   rm -rf conftest*
5521   glibcpp_cv_func___builtin_sinl_link=no
5522 fi
5523 rm -f conftest*
5524
5525 fi
5526
5527     fi
5528     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
5529     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
5530       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5531       cat >> confdefs.h <<EOF
5532 #define ${ac_tr_func} 1
5533 EOF
5534
5535     fi
5536   fi
5537
5538
5539
5540   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
5541 echo "configure:5542: checking for __builtin_cosf declaration" >&5
5542   if test x${glibcpp_cv_func___builtin_cosf_use+set} != xset; then
5543     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
5544   echo $ac_n "(cached) $ac_c" 1>&6
5545 else
5546
5547
5548       ac_ext=C
5549 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5550 ac_cpp='$CXXCPP $CPPFLAGS'
5551 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5552 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5553 cross_compiling=$ac_cv_prog_cxx_cross
5554
5555       cat > conftest.$ac_ext <<EOF
5556 #line 5557 "configure"
5557 #include "confdefs.h"
5558 #include <math.h>
5559 int main() {
5560  __builtin_cosf(0);
5561 ; return 0; }
5562 EOF
5563 if { (eval echo configure:5564: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5564   rm -rf conftest*
5565   glibcpp_cv_func___builtin_cosf_use=yes
5566 else
5567   echo "configure: failed program was:" >&5
5568   cat conftest.$ac_ext >&5
5569   rm -rf conftest*
5570   glibcpp_cv_func___builtin_cosf_use=no
5571 fi
5572 rm -f conftest*
5573       ac_ext=c
5574 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5575 ac_cpp='$CPP $CPPFLAGS'
5576 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5577 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5578 cross_compiling=$ac_cv_prog_cc_cross
5579
5580
5581 fi
5582
5583   fi
5584   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
5585   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
5586     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
5587 echo "configure:5588: checking for __builtin_cosf linkage" >&5
5588     if test x${glibcpp_cv_func___builtin_cosf_link+set} != xset; then
5589       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
5590   echo $ac_n "(cached) $ac_c" 1>&6
5591 else
5592
5593         cat > conftest.$ac_ext <<EOF
5594 #line 5595 "configure"
5595 #include "confdefs.h"
5596 #include <math.h>
5597 int main() {
5598  __builtin_cosf(0);
5599 ; return 0; }
5600 EOF
5601 if { (eval echo configure:5602: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5602   rm -rf conftest*
5603   glibcpp_cv_func___builtin_cosf_link=yes
5604 else
5605   echo "configure: failed program was:" >&5
5606   cat conftest.$ac_ext >&5
5607   rm -rf conftest*
5608   glibcpp_cv_func___builtin_cosf_link=no
5609 fi
5610 rm -f conftest*
5611
5612 fi
5613
5614     fi
5615     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
5616     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
5617       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5618       cat >> confdefs.h <<EOF
5619 #define ${ac_tr_func} 1
5620 EOF
5621
5622     fi
5623   fi
5624
5625
5626   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
5627 echo "configure:5628: checking for __builtin_cos declaration" >&5
5628   if test x${glibcpp_cv_func___builtin_cos_use+set} != xset; then
5629     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
5630   echo $ac_n "(cached) $ac_c" 1>&6
5631 else
5632
5633
5634       ac_ext=C
5635 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5636 ac_cpp='$CXXCPP $CPPFLAGS'
5637 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5638 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5639 cross_compiling=$ac_cv_prog_cxx_cross
5640
5641       cat > conftest.$ac_ext <<EOF
5642 #line 5643 "configure"
5643 #include "confdefs.h"
5644 #include <math.h>
5645 int main() {
5646  __builtin_cos(0);
5647 ; return 0; }
5648 EOF
5649 if { (eval echo configure:5650: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5650   rm -rf conftest*
5651   glibcpp_cv_func___builtin_cos_use=yes
5652 else
5653   echo "configure: failed program was:" >&5
5654   cat conftest.$ac_ext >&5
5655   rm -rf conftest*
5656   glibcpp_cv_func___builtin_cos_use=no
5657 fi
5658 rm -f conftest*
5659       ac_ext=c
5660 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5661 ac_cpp='$CPP $CPPFLAGS'
5662 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5663 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5664 cross_compiling=$ac_cv_prog_cc_cross
5665
5666
5667 fi
5668
5669   fi
5670   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
5671   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
5672     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
5673 echo "configure:5674: checking for __builtin_cos linkage" >&5
5674     if test x${glibcpp_cv_func___builtin_cos_link+set} != xset; then
5675       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
5676   echo $ac_n "(cached) $ac_c" 1>&6
5677 else
5678
5679         cat > conftest.$ac_ext <<EOF
5680 #line 5681 "configure"
5681 #include "confdefs.h"
5682 #include <math.h>
5683 int main() {
5684  __builtin_cos(0);
5685 ; return 0; }
5686 EOF
5687 if { (eval echo configure:5688: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5688   rm -rf conftest*
5689   glibcpp_cv_func___builtin_cos_link=yes
5690 else
5691   echo "configure: failed program was:" >&5
5692   cat conftest.$ac_ext >&5
5693   rm -rf conftest*
5694   glibcpp_cv_func___builtin_cos_link=no
5695 fi
5696 rm -f conftest*
5697
5698 fi
5699
5700     fi
5701     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
5702     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
5703       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5704       cat >> confdefs.h <<EOF
5705 #define ${ac_tr_func} 1
5706 EOF
5707
5708     fi
5709   fi
5710
5711
5712   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
5713 echo "configure:5714: checking for __builtin_cosl declaration" >&5
5714   if test x${glibcpp_cv_func___builtin_cosl_use+set} != xset; then
5715     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
5716   echo $ac_n "(cached) $ac_c" 1>&6
5717 else
5718
5719
5720       ac_ext=C
5721 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5722 ac_cpp='$CXXCPP $CPPFLAGS'
5723 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5724 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5725 cross_compiling=$ac_cv_prog_cxx_cross
5726
5727       cat > conftest.$ac_ext <<EOF
5728 #line 5729 "configure"
5729 #include "confdefs.h"
5730 #include <math.h>
5731 int main() {
5732  __builtin_cosl(0);
5733 ; return 0; }
5734 EOF
5735 if { (eval echo configure:5736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5736   rm -rf conftest*
5737   glibcpp_cv_func___builtin_cosl_use=yes
5738 else
5739   echo "configure: failed program was:" >&5
5740   cat conftest.$ac_ext >&5
5741   rm -rf conftest*
5742   glibcpp_cv_func___builtin_cosl_use=no
5743 fi
5744 rm -f conftest*
5745       ac_ext=c
5746 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5747 ac_cpp='$CPP $CPPFLAGS'
5748 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5749 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5750 cross_compiling=$ac_cv_prog_cc_cross
5751
5752
5753 fi
5754
5755   fi
5756   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
5757   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
5758     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
5759 echo "configure:5760: checking for __builtin_cosl linkage" >&5
5760     if test x${glibcpp_cv_func___builtin_cosl_link+set} != xset; then
5761       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
5762   echo $ac_n "(cached) $ac_c" 1>&6
5763 else
5764
5765         cat > conftest.$ac_ext <<EOF
5766 #line 5767 "configure"
5767 #include "confdefs.h"
5768 #include <math.h>
5769 int main() {
5770  __builtin_cosl(0);
5771 ; return 0; }
5772 EOF
5773 if { (eval echo configure:5774: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5774   rm -rf conftest*
5775   glibcpp_cv_func___builtin_cosl_link=yes
5776 else
5777   echo "configure: failed program was:" >&5
5778   cat conftest.$ac_ext >&5
5779   rm -rf conftest*
5780   glibcpp_cv_func___builtin_cosl_link=no
5781 fi
5782 rm -f conftest*
5783
5784 fi
5785
5786     fi
5787     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
5788     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
5789       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5790       cat >> confdefs.h <<EOF
5791 #define ${ac_tr_func} 1
5792 EOF
5793
5794     fi
5795   fi
5796
5797
5798               dummyvar=no
5799   if test x$dummyvar = x"yes"; then
5800     cat >> confdefs.h <<\EOF
5801 #define HAVE___BUILTIN_ABS 1
5802 EOF
5803
5804     cat >> confdefs.h <<\EOF
5805 #define HAVE___BUILTIN_LABS 1
5806 EOF
5807
5808     cat >> confdefs.h <<\EOF
5809 #define HAVE___BUILTIN_COS 1
5810 EOF
5811
5812     cat >> confdefs.h <<\EOF
5813 #define HAVE___BUILTIN_COSF 1
5814 EOF
5815
5816     cat >> confdefs.h <<\EOF
5817 #define HAVE___BUILTIN_COSL 1
5818 EOF
5819
5820     cat >> confdefs.h <<\EOF
5821 #define HAVE___BUILTIN_FABS 1
5822 EOF
5823
5824     cat >> confdefs.h <<\EOF
5825 #define HAVE___BUILTIN_FABSF 1
5826 EOF
5827
5828     cat >> confdefs.h <<\EOF
5829 #define HAVE___BUILTIN_FABSL 1
5830 EOF
5831
5832     cat >> confdefs.h <<\EOF
5833 #define HAVE___BUILTIN_SIN 1
5834 EOF
5835
5836     cat >> confdefs.h <<\EOF
5837 #define HAVE___BUILTIN_SINF 1
5838 EOF
5839
5840     cat >> confdefs.h <<\EOF
5841 #define HAVE___BUILTIN_SINL 1
5842 EOF
5843
5844     cat >> confdefs.h <<\EOF
5845 #define HAVE___BUILTIN_FSQRT 1
5846 EOF
5847
5848     cat >> confdefs.h <<\EOF
5849 #define HAVE___BUILTIN_SQRTF 1
5850 EOF
5851
5852     cat >> confdefs.h <<\EOF
5853 #define HAVE___BUILTIN_SQRTL 1
5854 EOF
5855
5856   fi
5857
5858
5859   ac_test_CXXFLAGS="${CXXFLAGS+set}"
5860   ac_save_CXXFLAGS="$CXXFLAGS"
5861   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
5862
5863     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
5864 echo "configure:5865: checking for sin in -lm" >&5
5865 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
5866 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
5867   echo $ac_n "(cached) $ac_c" 1>&6
5868 else
5869   ac_save_LIBS="$LIBS"
5870 LIBS="-lm  $LIBS"
5871 cat > conftest.$ac_ext <<EOF
5872 #line 5873 "configure"
5873 #include "confdefs.h"
5874 /* Override any gcc2 internal prototype to avoid an error.  */
5875 /* We use char because int might match the return type of a gcc2
5876     builtin and then its argument prototype would still apply.  */
5877 char sin();
5878
5879 int main() {
5880 sin()
5881 ; return 0; }
5882 EOF
5883 if { (eval echo configure:5884: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5884   rm -rf conftest*
5885   eval "ac_cv_lib_$ac_lib_var=yes"
5886 else
5887   echo "configure: failed program was:" >&5
5888   cat conftest.$ac_ext >&5
5889   rm -rf conftest*
5890   eval "ac_cv_lib_$ac_lib_var=no"
5891 fi
5892 rm -f conftest*
5893 LIBS="$ac_save_LIBS"
5894
5895 fi
5896 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
5897   echo "$ac_t""yes" 1>&6
5898   libm="-lm"
5899 else
5900   echo "$ac_t""no" 1>&6
5901 fi
5902
5903   ac_save_LIBS="$LIBS"
5904   LIBS="$LIBS $libm"
5905
5906
5907   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
5908 echo "configure:5909: checking for isinf declaration" >&5
5909   if test x${glibcpp_cv_func_isinf_use+set} != xset; then
5910     if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
5911   echo $ac_n "(cached) $ac_c" 1>&6
5912 else
5913
5914
5915       ac_ext=C
5916 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5917 ac_cpp='$CXXCPP $CPPFLAGS'
5918 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5919 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5920 cross_compiling=$ac_cv_prog_cxx_cross
5921
5922       cat > conftest.$ac_ext <<EOF
5923 #line 5924 "configure"
5924 #include "confdefs.h"
5925 #include <math.h>
5926 int main() {
5927  isinf(0);
5928 ; return 0; }
5929 EOF
5930 if { (eval echo configure:5931: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5931   rm -rf conftest*
5932   glibcpp_cv_func_isinf_use=yes
5933 else
5934   echo "configure: failed program was:" >&5
5935   cat conftest.$ac_ext >&5
5936   rm -rf conftest*
5937   glibcpp_cv_func_isinf_use=no
5938 fi
5939 rm -f conftest*
5940       ac_ext=c
5941 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5942 ac_cpp='$CPP $CPPFLAGS'
5943 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5944 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5945 cross_compiling=$ac_cv_prog_cc_cross
5946
5947
5948 fi
5949
5950   fi
5951   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
5952   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
5953     for ac_func in isinf
5954 do
5955 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5956 echo "configure:5957: checking for $ac_func" >&5
5957 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5958   echo $ac_n "(cached) $ac_c" 1>&6
5959 else
5960   cat > conftest.$ac_ext <<EOF
5961 #line 5962 "configure"
5962 #include "confdefs.h"
5963 /* System header to define __stub macros and hopefully few prototypes,
5964     which can conflict with char $ac_func(); below.  */
5965 #include <assert.h>
5966 /* Override any gcc2 internal prototype to avoid an error.  */
5967 /* We use char because int might match the return type of a gcc2
5968     builtin and then its argument prototype would still apply.  */
5969 char $ac_func();
5970
5971 int main() {
5972
5973 /* The GNU C library defines this for functions which it implements
5974     to always fail with ENOSYS.  Some functions are actually named
5975     something starting with __ and the normal name is an alias.  */
5976 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5977 choke me
5978 #else
5979 $ac_func();
5980 #endif
5981
5982 ; return 0; }
5983 EOF
5984 if { (eval echo configure:5985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5985   rm -rf conftest*
5986   eval "ac_cv_func_$ac_func=yes"
5987 else
5988   echo "configure: failed program was:" >&5
5989   cat conftest.$ac_ext >&5
5990   rm -rf conftest*
5991   eval "ac_cv_func_$ac_func=no"
5992 fi
5993 rm -f conftest*
5994 fi
5995
5996 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5997   echo "$ac_t""yes" 1>&6
5998     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5999   cat >> confdefs.h <<EOF
6000 #define $ac_tr_func 1
6001 EOF
6002
6003 else
6004   echo "$ac_t""no" 1>&6
6005 fi
6006 done
6007
6008   fi
6009
6010
6011   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
6012 echo "configure:6013: checking for isnan declaration" >&5
6013   if test x${glibcpp_cv_func_isnan_use+set} != xset; then
6014     if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
6015   echo $ac_n "(cached) $ac_c" 1>&6
6016 else
6017
6018
6019       ac_ext=C
6020 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6021 ac_cpp='$CXXCPP $CPPFLAGS'
6022 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6023 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6024 cross_compiling=$ac_cv_prog_cxx_cross
6025
6026       cat > conftest.$ac_ext <<EOF
6027 #line 6028 "configure"
6028 #include "confdefs.h"
6029 #include <math.h>
6030 int main() {
6031  isnan(0);
6032 ; return 0; }
6033 EOF
6034 if { (eval echo configure:6035: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6035   rm -rf conftest*
6036   glibcpp_cv_func_isnan_use=yes
6037 else
6038   echo "configure: failed program was:" >&5
6039   cat conftest.$ac_ext >&5
6040   rm -rf conftest*
6041   glibcpp_cv_func_isnan_use=no
6042 fi
6043 rm -f conftest*
6044       ac_ext=c
6045 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6046 ac_cpp='$CPP $CPPFLAGS'
6047 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6048 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6049 cross_compiling=$ac_cv_prog_cc_cross
6050
6051
6052 fi
6053
6054   fi
6055   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
6056   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
6057     for ac_func in isnan
6058 do
6059 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6060 echo "configure:6061: checking for $ac_func" >&5
6061 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6062   echo $ac_n "(cached) $ac_c" 1>&6
6063 else
6064   cat > conftest.$ac_ext <<EOF
6065 #line 6066 "configure"
6066 #include "confdefs.h"
6067 /* System header to define __stub macros and hopefully few prototypes,
6068     which can conflict with char $ac_func(); below.  */
6069 #include <assert.h>
6070 /* Override any gcc2 internal prototype to avoid an error.  */
6071 /* We use char because int might match the return type of a gcc2
6072     builtin and then its argument prototype would still apply.  */
6073 char $ac_func();
6074
6075 int main() {
6076
6077 /* The GNU C library defines this for functions which it implements
6078     to always fail with ENOSYS.  Some functions are actually named
6079     something starting with __ and the normal name is an alias.  */
6080 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6081 choke me
6082 #else
6083 $ac_func();
6084 #endif
6085
6086 ; return 0; }
6087 EOF
6088 if { (eval echo configure:6089: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6089   rm -rf conftest*
6090   eval "ac_cv_func_$ac_func=yes"
6091 else
6092   echo "configure: failed program was:" >&5
6093   cat conftest.$ac_ext >&5
6094   rm -rf conftest*
6095   eval "ac_cv_func_$ac_func=no"
6096 fi
6097 rm -f conftest*
6098 fi
6099
6100 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6101   echo "$ac_t""yes" 1>&6
6102     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6103   cat >> confdefs.h <<EOF
6104 #define $ac_tr_func 1
6105 EOF
6106
6107 else
6108   echo "$ac_t""no" 1>&6
6109 fi
6110 done
6111
6112   fi
6113
6114
6115   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
6116 echo "configure:6117: checking for finite declaration" >&5
6117   if test x${glibcpp_cv_func_finite_use+set} != xset; then
6118     if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
6119   echo $ac_n "(cached) $ac_c" 1>&6
6120 else
6121
6122
6123       ac_ext=C
6124 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6125 ac_cpp='$CXXCPP $CPPFLAGS'
6126 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6127 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6128 cross_compiling=$ac_cv_prog_cxx_cross
6129
6130       cat > conftest.$ac_ext <<EOF
6131 #line 6132 "configure"
6132 #include "confdefs.h"
6133 #include <math.h>
6134 int main() {
6135  finite(0);
6136 ; return 0; }
6137 EOF
6138 if { (eval echo configure:6139: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6139   rm -rf conftest*
6140   glibcpp_cv_func_finite_use=yes
6141 else
6142   echo "configure: failed program was:" >&5
6143   cat conftest.$ac_ext >&5
6144   rm -rf conftest*
6145   glibcpp_cv_func_finite_use=no
6146 fi
6147 rm -f conftest*
6148       ac_ext=c
6149 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6150 ac_cpp='$CPP $CPPFLAGS'
6151 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6152 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6153 cross_compiling=$ac_cv_prog_cc_cross
6154
6155
6156 fi
6157
6158   fi
6159   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
6160   if test x$glibcpp_cv_func_finite_use = x"yes"; then
6161     for ac_func in finite
6162 do
6163 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6164 echo "configure:6165: checking for $ac_func" >&5
6165 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6166   echo $ac_n "(cached) $ac_c" 1>&6
6167 else
6168   cat > conftest.$ac_ext <<EOF
6169 #line 6170 "configure"
6170 #include "confdefs.h"
6171 /* System header to define __stub macros and hopefully few prototypes,
6172     which can conflict with char $ac_func(); below.  */
6173 #include <assert.h>
6174 /* Override any gcc2 internal prototype to avoid an error.  */
6175 /* We use char because int might match the return type of a gcc2
6176     builtin and then its argument prototype would still apply.  */
6177 char $ac_func();
6178
6179 int main() {
6180
6181 /* The GNU C library defines this for functions which it implements
6182     to always fail with ENOSYS.  Some functions are actually named
6183     something starting with __ and the normal name is an alias.  */
6184 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6185 choke me
6186 #else
6187 $ac_func();
6188 #endif
6189
6190 ; return 0; }
6191 EOF
6192 if { (eval echo configure:6193: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6193   rm -rf conftest*
6194   eval "ac_cv_func_$ac_func=yes"
6195 else
6196   echo "configure: failed program was:" >&5
6197   cat conftest.$ac_ext >&5
6198   rm -rf conftest*
6199   eval "ac_cv_func_$ac_func=no"
6200 fi
6201 rm -f conftest*
6202 fi
6203
6204 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6205   echo "$ac_t""yes" 1>&6
6206     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6207   cat >> confdefs.h <<EOF
6208 #define $ac_tr_func 1
6209 EOF
6210
6211 else
6212   echo "$ac_t""no" 1>&6
6213 fi
6214 done
6215
6216   fi
6217
6218
6219   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
6220 echo "configure:6221: checking for copysign declaration" >&5
6221   if test x${glibcpp_cv_func_copysign_use+set} != xset; then
6222     if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
6223   echo $ac_n "(cached) $ac_c" 1>&6
6224 else
6225
6226
6227       ac_ext=C
6228 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6229 ac_cpp='$CXXCPP $CPPFLAGS'
6230 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6231 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6232 cross_compiling=$ac_cv_prog_cxx_cross
6233
6234       cat > conftest.$ac_ext <<EOF
6235 #line 6236 "configure"
6236 #include "confdefs.h"
6237 #include <math.h>
6238 int main() {
6239  copysign(0, 0);
6240 ; return 0; }
6241 EOF
6242 if { (eval echo configure:6243: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6243   rm -rf conftest*
6244   glibcpp_cv_func_copysign_use=yes
6245 else
6246   echo "configure: failed program was:" >&5
6247   cat conftest.$ac_ext >&5
6248   rm -rf conftest*
6249   glibcpp_cv_func_copysign_use=no
6250 fi
6251 rm -f conftest*
6252       ac_ext=c
6253 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6254 ac_cpp='$CPP $CPPFLAGS'
6255 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6256 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6257 cross_compiling=$ac_cv_prog_cc_cross
6258
6259
6260 fi
6261
6262   fi
6263   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
6264   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
6265     for ac_func in copysign
6266 do
6267 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6268 echo "configure:6269: checking for $ac_func" >&5
6269 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6270   echo $ac_n "(cached) $ac_c" 1>&6
6271 else
6272   cat > conftest.$ac_ext <<EOF
6273 #line 6274 "configure"
6274 #include "confdefs.h"
6275 /* System header to define __stub macros and hopefully few prototypes,
6276     which can conflict with char $ac_func(); below.  */
6277 #include <assert.h>
6278 /* Override any gcc2 internal prototype to avoid an error.  */
6279 /* We use char because int might match the return type of a gcc2
6280     builtin and then its argument prototype would still apply.  */
6281 char $ac_func();
6282
6283 int main() {
6284
6285 /* The GNU C library defines this for functions which it implements
6286     to always fail with ENOSYS.  Some functions are actually named
6287     something starting with __ and the normal name is an alias.  */
6288 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6289 choke me
6290 #else
6291 $ac_func();
6292 #endif
6293
6294 ; return 0; }
6295 EOF
6296 if { (eval echo configure:6297: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6297   rm -rf conftest*
6298   eval "ac_cv_func_$ac_func=yes"
6299 else
6300   echo "configure: failed program was:" >&5
6301   cat conftest.$ac_ext >&5
6302   rm -rf conftest*
6303   eval "ac_cv_func_$ac_func=no"
6304 fi
6305 rm -f conftest*
6306 fi
6307
6308 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6309   echo "$ac_t""yes" 1>&6
6310     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6311   cat >> confdefs.h <<EOF
6312 #define $ac_tr_func 1
6313 EOF
6314
6315 else
6316   echo "$ac_t""no" 1>&6
6317 fi
6318 done
6319
6320   fi
6321
6322
6323   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
6324 echo "configure:6325: checking for sincos declaration" >&5
6325   if test x${glibcpp_cv_func_sincos_use+set} != xset; then
6326     if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
6327   echo $ac_n "(cached) $ac_c" 1>&6
6328 else
6329
6330
6331       ac_ext=C
6332 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6333 ac_cpp='$CXXCPP $CPPFLAGS'
6334 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6335 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6336 cross_compiling=$ac_cv_prog_cxx_cross
6337
6338       cat > conftest.$ac_ext <<EOF
6339 #line 6340 "configure"
6340 #include "confdefs.h"
6341 #include <math.h>
6342 int main() {
6343  sincos(0, 0, 0);
6344 ; return 0; }
6345 EOF
6346 if { (eval echo configure:6347: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6347   rm -rf conftest*
6348   glibcpp_cv_func_sincos_use=yes
6349 else
6350   echo "configure: failed program was:" >&5
6351   cat conftest.$ac_ext >&5
6352   rm -rf conftest*
6353   glibcpp_cv_func_sincos_use=no
6354 fi
6355 rm -f conftest*
6356       ac_ext=c
6357 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6358 ac_cpp='$CPP $CPPFLAGS'
6359 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6360 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6361 cross_compiling=$ac_cv_prog_cc_cross
6362
6363
6364 fi
6365
6366   fi
6367   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
6368   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
6369     for ac_func in sincos
6370 do
6371 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6372 echo "configure:6373: checking for $ac_func" >&5
6373 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6374   echo $ac_n "(cached) $ac_c" 1>&6
6375 else
6376   cat > conftest.$ac_ext <<EOF
6377 #line 6378 "configure"
6378 #include "confdefs.h"
6379 /* System header to define __stub macros and hopefully few prototypes,
6380     which can conflict with char $ac_func(); below.  */
6381 #include <assert.h>
6382 /* Override any gcc2 internal prototype to avoid an error.  */
6383 /* We use char because int might match the return type of a gcc2
6384     builtin and then its argument prototype would still apply.  */
6385 char $ac_func();
6386
6387 int main() {
6388
6389 /* The GNU C library defines this for functions which it implements
6390     to always fail with ENOSYS.  Some functions are actually named
6391     something starting with __ and the normal name is an alias.  */
6392 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6393 choke me
6394 #else
6395 $ac_func();
6396 #endif
6397
6398 ; return 0; }
6399 EOF
6400 if { (eval echo configure:6401: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6401   rm -rf conftest*
6402   eval "ac_cv_func_$ac_func=yes"
6403 else
6404   echo "configure: failed program was:" >&5
6405   cat conftest.$ac_ext >&5
6406   rm -rf conftest*
6407   eval "ac_cv_func_$ac_func=no"
6408 fi
6409 rm -f conftest*
6410 fi
6411
6412 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6413   echo "$ac_t""yes" 1>&6
6414     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6415   cat >> confdefs.h <<EOF
6416 #define $ac_tr_func 1
6417 EOF
6418
6419 else
6420   echo "$ac_t""no" 1>&6
6421 fi
6422 done
6423
6424   fi
6425
6426
6427   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
6428 echo "configure:6429: checking for fpclass declaration" >&5
6429   if test x${glibcpp_cv_func_fpclass_use+set} != xset; then
6430     if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
6431   echo $ac_n "(cached) $ac_c" 1>&6
6432 else
6433
6434
6435       ac_ext=C
6436 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6437 ac_cpp='$CXXCPP $CPPFLAGS'
6438 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6439 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6440 cross_compiling=$ac_cv_prog_cxx_cross
6441
6442       cat > conftest.$ac_ext <<EOF
6443 #line 6444 "configure"
6444 #include "confdefs.h"
6445 #include <math.h>
6446 int main() {
6447  fpclass(0);
6448 ; return 0; }
6449 EOF
6450 if { (eval echo configure:6451: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6451   rm -rf conftest*
6452   glibcpp_cv_func_fpclass_use=yes
6453 else
6454   echo "configure: failed program was:" >&5
6455   cat conftest.$ac_ext >&5
6456   rm -rf conftest*
6457   glibcpp_cv_func_fpclass_use=no
6458 fi
6459 rm -f conftest*
6460       ac_ext=c
6461 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6462 ac_cpp='$CPP $CPPFLAGS'
6463 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6464 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6465 cross_compiling=$ac_cv_prog_cc_cross
6466
6467
6468 fi
6469
6470   fi
6471   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
6472   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
6473     for ac_func in fpclass
6474 do
6475 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6476 echo "configure:6477: checking for $ac_func" >&5
6477 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6478   echo $ac_n "(cached) $ac_c" 1>&6
6479 else
6480   cat > conftest.$ac_ext <<EOF
6481 #line 6482 "configure"
6482 #include "confdefs.h"
6483 /* System header to define __stub macros and hopefully few prototypes,
6484     which can conflict with char $ac_func(); below.  */
6485 #include <assert.h>
6486 /* Override any gcc2 internal prototype to avoid an error.  */
6487 /* We use char because int might match the return type of a gcc2
6488     builtin and then its argument prototype would still apply.  */
6489 char $ac_func();
6490
6491 int main() {
6492
6493 /* The GNU C library defines this for functions which it implements
6494     to always fail with ENOSYS.  Some functions are actually named
6495     something starting with __ and the normal name is an alias.  */
6496 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6497 choke me
6498 #else
6499 $ac_func();
6500 #endif
6501
6502 ; return 0; }
6503 EOF
6504 if { (eval echo configure:6505: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6505   rm -rf conftest*
6506   eval "ac_cv_func_$ac_func=yes"
6507 else
6508   echo "configure: failed program was:" >&5
6509   cat conftest.$ac_ext >&5
6510   rm -rf conftest*
6511   eval "ac_cv_func_$ac_func=no"
6512 fi
6513 rm -f conftest*
6514 fi
6515
6516 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6517   echo "$ac_t""yes" 1>&6
6518     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6519   cat >> confdefs.h <<EOF
6520 #define $ac_tr_func 1
6521 EOF
6522
6523 else
6524   echo "$ac_t""no" 1>&6
6525 fi
6526 done
6527
6528   fi
6529
6530
6531   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
6532 echo "configure:6533: checking for qfpclass declaration" >&5
6533   if test x${glibcpp_cv_func_qfpclass_use+set} != xset; then
6534     if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
6535   echo $ac_n "(cached) $ac_c" 1>&6
6536 else
6537
6538
6539       ac_ext=C
6540 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6541 ac_cpp='$CXXCPP $CPPFLAGS'
6542 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6543 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6544 cross_compiling=$ac_cv_prog_cxx_cross
6545
6546       cat > conftest.$ac_ext <<EOF
6547 #line 6548 "configure"
6548 #include "confdefs.h"
6549 #include <math.h>
6550 int main() {
6551  qfpclass(0);
6552 ; return 0; }
6553 EOF
6554 if { (eval echo configure:6555: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6555   rm -rf conftest*
6556   glibcpp_cv_func_qfpclass_use=yes
6557 else
6558   echo "configure: failed program was:" >&5
6559   cat conftest.$ac_ext >&5
6560   rm -rf conftest*
6561   glibcpp_cv_func_qfpclass_use=no
6562 fi
6563 rm -f conftest*
6564       ac_ext=c
6565 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6566 ac_cpp='$CPP $CPPFLAGS'
6567 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6568 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6569 cross_compiling=$ac_cv_prog_cc_cross
6570
6571
6572 fi
6573
6574   fi
6575   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
6576   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
6577     for ac_func in qfpclass
6578 do
6579 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6580 echo "configure:6581: checking for $ac_func" >&5
6581 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6582   echo $ac_n "(cached) $ac_c" 1>&6
6583 else
6584   cat > conftest.$ac_ext <<EOF
6585 #line 6586 "configure"
6586 #include "confdefs.h"
6587 /* System header to define __stub macros and hopefully few prototypes,
6588     which can conflict with char $ac_func(); below.  */
6589 #include <assert.h>
6590 /* Override any gcc2 internal prototype to avoid an error.  */
6591 /* We use char because int might match the return type of a gcc2
6592     builtin and then its argument prototype would still apply.  */
6593 char $ac_func();
6594
6595 int main() {
6596
6597 /* The GNU C library defines this for functions which it implements
6598     to always fail with ENOSYS.  Some functions are actually named
6599     something starting with __ and the normal name is an alias.  */
6600 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6601 choke me
6602 #else
6603 $ac_func();
6604 #endif
6605
6606 ; return 0; }
6607 EOF
6608 if { (eval echo configure:6609: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6609   rm -rf conftest*
6610   eval "ac_cv_func_$ac_func=yes"
6611 else
6612   echo "configure: failed program was:" >&5
6613   cat conftest.$ac_ext >&5
6614   rm -rf conftest*
6615   eval "ac_cv_func_$ac_func=no"
6616 fi
6617 rm -f conftest*
6618 fi
6619
6620 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6621   echo "$ac_t""yes" 1>&6
6622     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6623   cat >> confdefs.h <<EOF
6624 #define $ac_tr_func 1
6625 EOF
6626
6627 else
6628   echo "$ac_t""no" 1>&6
6629 fi
6630 done
6631
6632   fi
6633
6634
6635
6636   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
6637 echo "configure:6638: checking for isnanf declaration" >&5
6638   if test x${glibcpp_cv_func_isnanf_use+set} != xset; then
6639     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
6640   echo $ac_n "(cached) $ac_c" 1>&6
6641 else
6642
6643
6644       ac_ext=C
6645 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6646 ac_cpp='$CXXCPP $CPPFLAGS'
6647 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6648 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6649 cross_compiling=$ac_cv_prog_cxx_cross
6650
6651       cat > conftest.$ac_ext <<EOF
6652 #line 6653 "configure"
6653 #include "confdefs.h"
6654 #include <math.h>
6655 int main() {
6656  isnanf(0);
6657 ; return 0; }
6658 EOF
6659 if { (eval echo configure:6660: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6660   rm -rf conftest*
6661   glibcpp_cv_func_isnanf_use=yes
6662 else
6663   echo "configure: failed program was:" >&5
6664   cat conftest.$ac_ext >&5
6665   rm -rf conftest*
6666   glibcpp_cv_func_isnanf_use=no
6667 fi
6668 rm -f conftest*
6669       ac_ext=c
6670 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6671 ac_cpp='$CPP $CPPFLAGS'
6672 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6673 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6674 cross_compiling=$ac_cv_prog_cc_cross
6675
6676
6677 fi
6678
6679   fi
6680   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
6681   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
6682     for ac_func in isnanf
6683 do
6684 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6685 echo "configure:6686: checking for $ac_func" >&5
6686 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6687   echo $ac_n "(cached) $ac_c" 1>&6
6688 else
6689   cat > conftest.$ac_ext <<EOF
6690 #line 6691 "configure"
6691 #include "confdefs.h"
6692 /* System header to define __stub macros and hopefully few prototypes,
6693     which can conflict with char $ac_func(); below.  */
6694 #include <assert.h>
6695 /* Override any gcc2 internal prototype to avoid an error.  */
6696 /* We use char because int might match the return type of a gcc2
6697     builtin and then its argument prototype would still apply.  */
6698 char $ac_func();
6699
6700 int main() {
6701
6702 /* The GNU C library defines this for functions which it implements
6703     to always fail with ENOSYS.  Some functions are actually named
6704     something starting with __ and the normal name is an alias.  */
6705 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6706 choke me
6707 #else
6708 $ac_func();
6709 #endif
6710
6711 ; return 0; }
6712 EOF
6713 if { (eval echo configure:6714: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6714   rm -rf conftest*
6715   eval "ac_cv_func_$ac_func=yes"
6716 else
6717   echo "configure: failed program was:" >&5
6718   cat conftest.$ac_ext >&5
6719   rm -rf conftest*
6720   eval "ac_cv_func_$ac_func=no"
6721 fi
6722 rm -f conftest*
6723 fi
6724
6725 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6726   echo "$ac_t""yes" 1>&6
6727     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6728   cat >> confdefs.h <<EOF
6729 #define $ac_tr_func 1
6730 EOF
6731
6732 else
6733   echo "$ac_t""no" 1>&6
6734 fi
6735 done
6736
6737   fi
6738
6739
6740   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
6741 echo "configure:6742: checking for isinff declaration" >&5
6742   if test x${glibcpp_cv_func_isinff_use+set} != xset; then
6743     if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
6744   echo $ac_n "(cached) $ac_c" 1>&6
6745 else
6746
6747
6748       ac_ext=C
6749 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6750 ac_cpp='$CXXCPP $CPPFLAGS'
6751 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6752 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6753 cross_compiling=$ac_cv_prog_cxx_cross
6754
6755       cat > conftest.$ac_ext <<EOF
6756 #line 6757 "configure"
6757 #include "confdefs.h"
6758 #include <math.h>
6759 int main() {
6760  isinff(0);
6761 ; return 0; }
6762 EOF
6763 if { (eval echo configure:6764: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6764   rm -rf conftest*
6765   glibcpp_cv_func_isinff_use=yes
6766 else
6767   echo "configure: failed program was:" >&5
6768   cat conftest.$ac_ext >&5
6769   rm -rf conftest*
6770   glibcpp_cv_func_isinff_use=no
6771 fi
6772 rm -f conftest*
6773       ac_ext=c
6774 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6775 ac_cpp='$CPP $CPPFLAGS'
6776 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6777 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6778 cross_compiling=$ac_cv_prog_cc_cross
6779
6780
6781 fi
6782
6783   fi
6784   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
6785   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
6786     for ac_func in isinff
6787 do
6788 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6789 echo "configure:6790: checking for $ac_func" >&5
6790 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6791   echo $ac_n "(cached) $ac_c" 1>&6
6792 else
6793   cat > conftest.$ac_ext <<EOF
6794 #line 6795 "configure"
6795 #include "confdefs.h"
6796 /* System header to define __stub macros and hopefully few prototypes,
6797     which can conflict with char $ac_func(); below.  */
6798 #include <assert.h>
6799 /* Override any gcc2 internal prototype to avoid an error.  */
6800 /* We use char because int might match the return type of a gcc2
6801     builtin and then its argument prototype would still apply.  */
6802 char $ac_func();
6803
6804 int main() {
6805
6806 /* The GNU C library defines this for functions which it implements
6807     to always fail with ENOSYS.  Some functions are actually named
6808     something starting with __ and the normal name is an alias.  */
6809 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6810 choke me
6811 #else
6812 $ac_func();
6813 #endif
6814
6815 ; return 0; }
6816 EOF
6817 if { (eval echo configure:6818: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6818   rm -rf conftest*
6819   eval "ac_cv_func_$ac_func=yes"
6820 else
6821   echo "configure: failed program was:" >&5
6822   cat conftest.$ac_ext >&5
6823   rm -rf conftest*
6824   eval "ac_cv_func_$ac_func=no"
6825 fi
6826 rm -f conftest*
6827 fi
6828
6829 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6830   echo "$ac_t""yes" 1>&6
6831     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6832   cat >> confdefs.h <<EOF
6833 #define $ac_tr_func 1
6834 EOF
6835
6836 else
6837   echo "$ac_t""no" 1>&6
6838 fi
6839 done
6840
6841   fi
6842
6843
6844   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
6845 echo "configure:6846: checking for acosf declaration" >&5
6846   if test x${glibcpp_cv_func_acosf_use+set} != xset; then
6847     if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
6848   echo $ac_n "(cached) $ac_c" 1>&6
6849 else
6850
6851
6852       ac_ext=C
6853 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6854 ac_cpp='$CXXCPP $CPPFLAGS'
6855 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6856 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6857 cross_compiling=$ac_cv_prog_cxx_cross
6858
6859       cat > conftest.$ac_ext <<EOF
6860 #line 6861 "configure"
6861 #include "confdefs.h"
6862 #include <math.h>
6863 int main() {
6864  acosf(0);
6865 ; return 0; }
6866 EOF
6867 if { (eval echo configure:6868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6868   rm -rf conftest*
6869   glibcpp_cv_func_acosf_use=yes
6870 else
6871   echo "configure: failed program was:" >&5
6872   cat conftest.$ac_ext >&5
6873   rm -rf conftest*
6874   glibcpp_cv_func_acosf_use=no
6875 fi
6876 rm -f conftest*
6877       ac_ext=c
6878 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6879 ac_cpp='$CPP $CPPFLAGS'
6880 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6881 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6882 cross_compiling=$ac_cv_prog_cc_cross
6883
6884
6885 fi
6886
6887   fi
6888   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
6889   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
6890     for ac_func in acosf
6891 do
6892 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6893 echo "configure:6894: checking for $ac_func" >&5
6894 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6895   echo $ac_n "(cached) $ac_c" 1>&6
6896 else
6897   cat > conftest.$ac_ext <<EOF
6898 #line 6899 "configure"
6899 #include "confdefs.h"
6900 /* System header to define __stub macros and hopefully few prototypes,
6901     which can conflict with char $ac_func(); below.  */
6902 #include <assert.h>
6903 /* Override any gcc2 internal prototype to avoid an error.  */
6904 /* We use char because int might match the return type of a gcc2
6905     builtin and then its argument prototype would still apply.  */
6906 char $ac_func();
6907
6908 int main() {
6909
6910 /* The GNU C library defines this for functions which it implements
6911     to always fail with ENOSYS.  Some functions are actually named
6912     something starting with __ and the normal name is an alias.  */
6913 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6914 choke me
6915 #else
6916 $ac_func();
6917 #endif
6918
6919 ; return 0; }
6920 EOF
6921 if { (eval echo configure:6922: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6922   rm -rf conftest*
6923   eval "ac_cv_func_$ac_func=yes"
6924 else
6925   echo "configure: failed program was:" >&5
6926   cat conftest.$ac_ext >&5
6927   rm -rf conftest*
6928   eval "ac_cv_func_$ac_func=no"
6929 fi
6930 rm -f conftest*
6931 fi
6932
6933 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6934   echo "$ac_t""yes" 1>&6
6935     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6936   cat >> confdefs.h <<EOF
6937 #define $ac_tr_func 1
6938 EOF
6939
6940 else
6941   echo "$ac_t""no" 1>&6
6942 fi
6943 done
6944
6945   fi
6946
6947
6948   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
6949 echo "configure:6950: checking for asinf declaration" >&5
6950   if test x${glibcpp_cv_func_asinf_use+set} != xset; then
6951     if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
6952   echo $ac_n "(cached) $ac_c" 1>&6
6953 else
6954
6955
6956       ac_ext=C
6957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6958 ac_cpp='$CXXCPP $CPPFLAGS'
6959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6961 cross_compiling=$ac_cv_prog_cxx_cross
6962
6963       cat > conftest.$ac_ext <<EOF
6964 #line 6965 "configure"
6965 #include "confdefs.h"
6966 #include <math.h>
6967 int main() {
6968  asinf(0);
6969 ; return 0; }
6970 EOF
6971 if { (eval echo configure:6972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6972   rm -rf conftest*
6973   glibcpp_cv_func_asinf_use=yes
6974 else
6975   echo "configure: failed program was:" >&5
6976   cat conftest.$ac_ext >&5
6977   rm -rf conftest*
6978   glibcpp_cv_func_asinf_use=no
6979 fi
6980 rm -f conftest*
6981       ac_ext=c
6982 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6983 ac_cpp='$CPP $CPPFLAGS'
6984 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6985 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6986 cross_compiling=$ac_cv_prog_cc_cross
6987
6988
6989 fi
6990
6991   fi
6992   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
6993   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
6994     for ac_func in asinf
6995 do
6996 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6997 echo "configure:6998: checking for $ac_func" >&5
6998 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6999   echo $ac_n "(cached) $ac_c" 1>&6
7000 else
7001   cat > conftest.$ac_ext <<EOF
7002 #line 7003 "configure"
7003 #include "confdefs.h"
7004 /* System header to define __stub macros and hopefully few prototypes,
7005     which can conflict with char $ac_func(); below.  */
7006 #include <assert.h>
7007 /* Override any gcc2 internal prototype to avoid an error.  */
7008 /* We use char because int might match the return type of a gcc2
7009     builtin and then its argument prototype would still apply.  */
7010 char $ac_func();
7011
7012 int main() {
7013
7014 /* The GNU C library defines this for functions which it implements
7015     to always fail with ENOSYS.  Some functions are actually named
7016     something starting with __ and the normal name is an alias.  */
7017 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7018 choke me
7019 #else
7020 $ac_func();
7021 #endif
7022
7023 ; return 0; }
7024 EOF
7025 if { (eval echo configure:7026: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7026   rm -rf conftest*
7027   eval "ac_cv_func_$ac_func=yes"
7028 else
7029   echo "configure: failed program was:" >&5
7030   cat conftest.$ac_ext >&5
7031   rm -rf conftest*
7032   eval "ac_cv_func_$ac_func=no"
7033 fi
7034 rm -f conftest*
7035 fi
7036
7037 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7038   echo "$ac_t""yes" 1>&6
7039     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7040   cat >> confdefs.h <<EOF
7041 #define $ac_tr_func 1
7042 EOF
7043
7044 else
7045   echo "$ac_t""no" 1>&6
7046 fi
7047 done
7048
7049   fi
7050
7051
7052   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
7053 echo "configure:7054: checking for atanf declaration" >&5
7054   if test x${glibcpp_cv_func_atanf_use+set} != xset; then
7055     if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
7056   echo $ac_n "(cached) $ac_c" 1>&6
7057 else
7058
7059
7060       ac_ext=C
7061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7062 ac_cpp='$CXXCPP $CPPFLAGS'
7063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7065 cross_compiling=$ac_cv_prog_cxx_cross
7066
7067       cat > conftest.$ac_ext <<EOF
7068 #line 7069 "configure"
7069 #include "confdefs.h"
7070 #include <math.h>
7071 int main() {
7072  atanf(0);
7073 ; return 0; }
7074 EOF
7075 if { (eval echo configure:7076: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7076   rm -rf conftest*
7077   glibcpp_cv_func_atanf_use=yes
7078 else
7079   echo "configure: failed program was:" >&5
7080   cat conftest.$ac_ext >&5
7081   rm -rf conftest*
7082   glibcpp_cv_func_atanf_use=no
7083 fi
7084 rm -f conftest*
7085       ac_ext=c
7086 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7087 ac_cpp='$CPP $CPPFLAGS'
7088 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7089 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7090 cross_compiling=$ac_cv_prog_cc_cross
7091
7092
7093 fi
7094
7095   fi
7096   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
7097   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
7098     for ac_func in atanf
7099 do
7100 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7101 echo "configure:7102: checking for $ac_func" >&5
7102 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7103   echo $ac_n "(cached) $ac_c" 1>&6
7104 else
7105   cat > conftest.$ac_ext <<EOF
7106 #line 7107 "configure"
7107 #include "confdefs.h"
7108 /* System header to define __stub macros and hopefully few prototypes,
7109     which can conflict with char $ac_func(); below.  */
7110 #include <assert.h>
7111 /* Override any gcc2 internal prototype to avoid an error.  */
7112 /* We use char because int might match the return type of a gcc2
7113     builtin and then its argument prototype would still apply.  */
7114 char $ac_func();
7115
7116 int main() {
7117
7118 /* The GNU C library defines this for functions which it implements
7119     to always fail with ENOSYS.  Some functions are actually named
7120     something starting with __ and the normal name is an alias.  */
7121 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7122 choke me
7123 #else
7124 $ac_func();
7125 #endif
7126
7127 ; return 0; }
7128 EOF
7129 if { (eval echo configure:7130: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7130   rm -rf conftest*
7131   eval "ac_cv_func_$ac_func=yes"
7132 else
7133   echo "configure: failed program was:" >&5
7134   cat conftest.$ac_ext >&5
7135   rm -rf conftest*
7136   eval "ac_cv_func_$ac_func=no"
7137 fi
7138 rm -f conftest*
7139 fi
7140
7141 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7142   echo "$ac_t""yes" 1>&6
7143     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7144   cat >> confdefs.h <<EOF
7145 #define $ac_tr_func 1
7146 EOF
7147
7148 else
7149   echo "$ac_t""no" 1>&6
7150 fi
7151 done
7152
7153   fi
7154
7155
7156   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
7157 echo "configure:7158: checking for ceilf declaration" >&5
7158   if test x${glibcpp_cv_func_ceilf_use+set} != xset; then
7159     if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
7160   echo $ac_n "(cached) $ac_c" 1>&6
7161 else
7162
7163
7164       ac_ext=C
7165 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7166 ac_cpp='$CXXCPP $CPPFLAGS'
7167 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7168 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7169 cross_compiling=$ac_cv_prog_cxx_cross
7170
7171       cat > conftest.$ac_ext <<EOF
7172 #line 7173 "configure"
7173 #include "confdefs.h"
7174 #include <math.h>
7175 int main() {
7176  ceilf(0);
7177 ; return 0; }
7178 EOF
7179 if { (eval echo configure:7180: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7180   rm -rf conftest*
7181   glibcpp_cv_func_ceilf_use=yes
7182 else
7183   echo "configure: failed program was:" >&5
7184   cat conftest.$ac_ext >&5
7185   rm -rf conftest*
7186   glibcpp_cv_func_ceilf_use=no
7187 fi
7188 rm -f conftest*
7189       ac_ext=c
7190 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7191 ac_cpp='$CPP $CPPFLAGS'
7192 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7193 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7194 cross_compiling=$ac_cv_prog_cc_cross
7195
7196
7197 fi
7198
7199   fi
7200   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
7201   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
7202     for ac_func in ceilf
7203 do
7204 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7205 echo "configure:7206: checking for $ac_func" >&5
7206 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7207   echo $ac_n "(cached) $ac_c" 1>&6
7208 else
7209   cat > conftest.$ac_ext <<EOF
7210 #line 7211 "configure"
7211 #include "confdefs.h"
7212 /* System header to define __stub macros and hopefully few prototypes,
7213     which can conflict with char $ac_func(); below.  */
7214 #include <assert.h>
7215 /* Override any gcc2 internal prototype to avoid an error.  */
7216 /* We use char because int might match the return type of a gcc2
7217     builtin and then its argument prototype would still apply.  */
7218 char $ac_func();
7219
7220 int main() {
7221
7222 /* The GNU C library defines this for functions which it implements
7223     to always fail with ENOSYS.  Some functions are actually named
7224     something starting with __ and the normal name is an alias.  */
7225 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7226 choke me
7227 #else
7228 $ac_func();
7229 #endif
7230
7231 ; return 0; }
7232 EOF
7233 if { (eval echo configure:7234: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7234   rm -rf conftest*
7235   eval "ac_cv_func_$ac_func=yes"
7236 else
7237   echo "configure: failed program was:" >&5
7238   cat conftest.$ac_ext >&5
7239   rm -rf conftest*
7240   eval "ac_cv_func_$ac_func=no"
7241 fi
7242 rm -f conftest*
7243 fi
7244
7245 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7246   echo "$ac_t""yes" 1>&6
7247     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7248   cat >> confdefs.h <<EOF
7249 #define $ac_tr_func 1
7250 EOF
7251
7252 else
7253   echo "$ac_t""no" 1>&6
7254 fi
7255 done
7256
7257   fi
7258
7259
7260   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
7261 echo "configure:7262: checking for cosf declaration" >&5
7262   if test x${glibcpp_cv_func_cosf_use+set} != xset; then
7263     if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
7264   echo $ac_n "(cached) $ac_c" 1>&6
7265 else
7266
7267
7268       ac_ext=C
7269 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7270 ac_cpp='$CXXCPP $CPPFLAGS'
7271 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7272 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7273 cross_compiling=$ac_cv_prog_cxx_cross
7274
7275       cat > conftest.$ac_ext <<EOF
7276 #line 7277 "configure"
7277 #include "confdefs.h"
7278 #include <math.h>
7279 int main() {
7280  cosf(0);
7281 ; return 0; }
7282 EOF
7283 if { (eval echo configure:7284: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7284   rm -rf conftest*
7285   glibcpp_cv_func_cosf_use=yes
7286 else
7287   echo "configure: failed program was:" >&5
7288   cat conftest.$ac_ext >&5
7289   rm -rf conftest*
7290   glibcpp_cv_func_cosf_use=no
7291 fi
7292 rm -f conftest*
7293       ac_ext=c
7294 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7295 ac_cpp='$CPP $CPPFLAGS'
7296 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7297 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7298 cross_compiling=$ac_cv_prog_cc_cross
7299
7300
7301 fi
7302
7303   fi
7304   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
7305   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
7306     for ac_func in cosf
7307 do
7308 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7309 echo "configure:7310: checking for $ac_func" >&5
7310 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7311   echo $ac_n "(cached) $ac_c" 1>&6
7312 else
7313   cat > conftest.$ac_ext <<EOF
7314 #line 7315 "configure"
7315 #include "confdefs.h"
7316 /* System header to define __stub macros and hopefully few prototypes,
7317     which can conflict with char $ac_func(); below.  */
7318 #include <assert.h>
7319 /* Override any gcc2 internal prototype to avoid an error.  */
7320 /* We use char because int might match the return type of a gcc2
7321     builtin and then its argument prototype would still apply.  */
7322 char $ac_func();
7323
7324 int main() {
7325
7326 /* The GNU C library defines this for functions which it implements
7327     to always fail with ENOSYS.  Some functions are actually named
7328     something starting with __ and the normal name is an alias.  */
7329 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7330 choke me
7331 #else
7332 $ac_func();
7333 #endif
7334
7335 ; return 0; }
7336 EOF
7337 if { (eval echo configure:7338: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7338   rm -rf conftest*
7339   eval "ac_cv_func_$ac_func=yes"
7340 else
7341   echo "configure: failed program was:" >&5
7342   cat conftest.$ac_ext >&5
7343   rm -rf conftest*
7344   eval "ac_cv_func_$ac_func=no"
7345 fi
7346 rm -f conftest*
7347 fi
7348
7349 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7350   echo "$ac_t""yes" 1>&6
7351     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7352   cat >> confdefs.h <<EOF
7353 #define $ac_tr_func 1
7354 EOF
7355
7356 else
7357   echo "$ac_t""no" 1>&6
7358 fi
7359 done
7360
7361   fi
7362
7363
7364   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
7365 echo "configure:7366: checking for coshf declaration" >&5
7366   if test x${glibcpp_cv_func_coshf_use+set} != xset; then
7367     if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
7368   echo $ac_n "(cached) $ac_c" 1>&6
7369 else
7370
7371
7372       ac_ext=C
7373 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7374 ac_cpp='$CXXCPP $CPPFLAGS'
7375 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7376 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7377 cross_compiling=$ac_cv_prog_cxx_cross
7378
7379       cat > conftest.$ac_ext <<EOF
7380 #line 7381 "configure"
7381 #include "confdefs.h"
7382 #include <math.h>
7383 int main() {
7384  coshf(0);
7385 ; return 0; }
7386 EOF
7387 if { (eval echo configure:7388: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7388   rm -rf conftest*
7389   glibcpp_cv_func_coshf_use=yes
7390 else
7391   echo "configure: failed program was:" >&5
7392   cat conftest.$ac_ext >&5
7393   rm -rf conftest*
7394   glibcpp_cv_func_coshf_use=no
7395 fi
7396 rm -f conftest*
7397       ac_ext=c
7398 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7399 ac_cpp='$CPP $CPPFLAGS'
7400 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7401 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7402 cross_compiling=$ac_cv_prog_cc_cross
7403
7404
7405 fi
7406
7407   fi
7408   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
7409   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
7410     for ac_func in coshf
7411 do
7412 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7413 echo "configure:7414: checking for $ac_func" >&5
7414 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7415   echo $ac_n "(cached) $ac_c" 1>&6
7416 else
7417   cat > conftest.$ac_ext <<EOF
7418 #line 7419 "configure"
7419 #include "confdefs.h"
7420 /* System header to define __stub macros and hopefully few prototypes,
7421     which can conflict with char $ac_func(); below.  */
7422 #include <assert.h>
7423 /* Override any gcc2 internal prototype to avoid an error.  */
7424 /* We use char because int might match the return type of a gcc2
7425     builtin and then its argument prototype would still apply.  */
7426 char $ac_func();
7427
7428 int main() {
7429
7430 /* The GNU C library defines this for functions which it implements
7431     to always fail with ENOSYS.  Some functions are actually named
7432     something starting with __ and the normal name is an alias.  */
7433 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7434 choke me
7435 #else
7436 $ac_func();
7437 #endif
7438
7439 ; return 0; }
7440 EOF
7441 if { (eval echo configure:7442: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7442   rm -rf conftest*
7443   eval "ac_cv_func_$ac_func=yes"
7444 else
7445   echo "configure: failed program was:" >&5
7446   cat conftest.$ac_ext >&5
7447   rm -rf conftest*
7448   eval "ac_cv_func_$ac_func=no"
7449 fi
7450 rm -f conftest*
7451 fi
7452
7453 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7454   echo "$ac_t""yes" 1>&6
7455     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7456   cat >> confdefs.h <<EOF
7457 #define $ac_tr_func 1
7458 EOF
7459
7460 else
7461   echo "$ac_t""no" 1>&6
7462 fi
7463 done
7464
7465   fi
7466
7467
7468   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
7469 echo "configure:7470: checking for fabsf declaration" >&5
7470   if test x${glibcpp_cv_func_fabsf_use+set} != xset; then
7471     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
7472   echo $ac_n "(cached) $ac_c" 1>&6
7473 else
7474
7475
7476       ac_ext=C
7477 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7478 ac_cpp='$CXXCPP $CPPFLAGS'
7479 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7480 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7481 cross_compiling=$ac_cv_prog_cxx_cross
7482
7483       cat > conftest.$ac_ext <<EOF
7484 #line 7485 "configure"
7485 #include "confdefs.h"
7486 #include <math.h>
7487 int main() {
7488  fabsf(0);
7489 ; return 0; }
7490 EOF
7491 if { (eval echo configure:7492: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7492   rm -rf conftest*
7493   glibcpp_cv_func_fabsf_use=yes
7494 else
7495   echo "configure: failed program was:" >&5
7496   cat conftest.$ac_ext >&5
7497   rm -rf conftest*
7498   glibcpp_cv_func_fabsf_use=no
7499 fi
7500 rm -f conftest*
7501       ac_ext=c
7502 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7503 ac_cpp='$CPP $CPPFLAGS'
7504 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7505 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7506 cross_compiling=$ac_cv_prog_cc_cross
7507
7508
7509 fi
7510
7511   fi
7512   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
7513   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
7514     for ac_func in fabsf
7515 do
7516 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7517 echo "configure:7518: checking for $ac_func" >&5
7518 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7519   echo $ac_n "(cached) $ac_c" 1>&6
7520 else
7521   cat > conftest.$ac_ext <<EOF
7522 #line 7523 "configure"
7523 #include "confdefs.h"
7524 /* System header to define __stub macros and hopefully few prototypes,
7525     which can conflict with char $ac_func(); below.  */
7526 #include <assert.h>
7527 /* Override any gcc2 internal prototype to avoid an error.  */
7528 /* We use char because int might match the return type of a gcc2
7529     builtin and then its argument prototype would still apply.  */
7530 char $ac_func();
7531
7532 int main() {
7533
7534 /* The GNU C library defines this for functions which it implements
7535     to always fail with ENOSYS.  Some functions are actually named
7536     something starting with __ and the normal name is an alias.  */
7537 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7538 choke me
7539 #else
7540 $ac_func();
7541 #endif
7542
7543 ; return 0; }
7544 EOF
7545 if { (eval echo configure:7546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7546   rm -rf conftest*
7547   eval "ac_cv_func_$ac_func=yes"
7548 else
7549   echo "configure: failed program was:" >&5
7550   cat conftest.$ac_ext >&5
7551   rm -rf conftest*
7552   eval "ac_cv_func_$ac_func=no"
7553 fi
7554 rm -f conftest*
7555 fi
7556
7557 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7558   echo "$ac_t""yes" 1>&6
7559     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7560   cat >> confdefs.h <<EOF
7561 #define $ac_tr_func 1
7562 EOF
7563
7564 else
7565   echo "$ac_t""no" 1>&6
7566 fi
7567 done
7568
7569   fi
7570
7571
7572   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
7573 echo "configure:7574: checking for floorf declaration" >&5
7574   if test x${glibcpp_cv_func_floorf_use+set} != xset; then
7575     if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
7576   echo $ac_n "(cached) $ac_c" 1>&6
7577 else
7578
7579
7580       ac_ext=C
7581 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7582 ac_cpp='$CXXCPP $CPPFLAGS'
7583 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7584 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7585 cross_compiling=$ac_cv_prog_cxx_cross
7586
7587       cat > conftest.$ac_ext <<EOF
7588 #line 7589 "configure"
7589 #include "confdefs.h"
7590 #include <math.h>
7591 int main() {
7592  floorf(0);
7593 ; return 0; }
7594 EOF
7595 if { (eval echo configure:7596: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7596   rm -rf conftest*
7597   glibcpp_cv_func_floorf_use=yes
7598 else
7599   echo "configure: failed program was:" >&5
7600   cat conftest.$ac_ext >&5
7601   rm -rf conftest*
7602   glibcpp_cv_func_floorf_use=no
7603 fi
7604 rm -f conftest*
7605       ac_ext=c
7606 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7607 ac_cpp='$CPP $CPPFLAGS'
7608 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7609 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7610 cross_compiling=$ac_cv_prog_cc_cross
7611
7612
7613 fi
7614
7615   fi
7616   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
7617   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
7618     for ac_func in floorf
7619 do
7620 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7621 echo "configure:7622: checking for $ac_func" >&5
7622 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7623   echo $ac_n "(cached) $ac_c" 1>&6
7624 else
7625   cat > conftest.$ac_ext <<EOF
7626 #line 7627 "configure"
7627 #include "confdefs.h"
7628 /* System header to define __stub macros and hopefully few prototypes,
7629     which can conflict with char $ac_func(); below.  */
7630 #include <assert.h>
7631 /* Override any gcc2 internal prototype to avoid an error.  */
7632 /* We use char because int might match the return type of a gcc2
7633     builtin and then its argument prototype would still apply.  */
7634 char $ac_func();
7635
7636 int main() {
7637
7638 /* The GNU C library defines this for functions which it implements
7639     to always fail with ENOSYS.  Some functions are actually named
7640     something starting with __ and the normal name is an alias.  */
7641 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7642 choke me
7643 #else
7644 $ac_func();
7645 #endif
7646
7647 ; return 0; }
7648 EOF
7649 if { (eval echo configure:7650: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7650   rm -rf conftest*
7651   eval "ac_cv_func_$ac_func=yes"
7652 else
7653   echo "configure: failed program was:" >&5
7654   cat conftest.$ac_ext >&5
7655   rm -rf conftest*
7656   eval "ac_cv_func_$ac_func=no"
7657 fi
7658 rm -f conftest*
7659 fi
7660
7661 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7662   echo "$ac_t""yes" 1>&6
7663     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7664   cat >> confdefs.h <<EOF
7665 #define $ac_tr_func 1
7666 EOF
7667
7668 else
7669   echo "$ac_t""no" 1>&6
7670 fi
7671 done
7672
7673   fi
7674
7675
7676   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
7677 echo "configure:7678: checking for fmodf declaration" >&5
7678   if test x${glibcpp_cv_func_fmodf_use+set} != xset; then
7679     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
7680   echo $ac_n "(cached) $ac_c" 1>&6
7681 else
7682
7683
7684       ac_ext=C
7685 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7686 ac_cpp='$CXXCPP $CPPFLAGS'
7687 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7688 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7689 cross_compiling=$ac_cv_prog_cxx_cross
7690
7691       cat > conftest.$ac_ext <<EOF
7692 #line 7693 "configure"
7693 #include "confdefs.h"
7694 #include <math.h>
7695 int main() {
7696  fmodf(0, 0);
7697 ; return 0; }
7698 EOF
7699 if { (eval echo configure:7700: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7700   rm -rf conftest*
7701   glibcpp_cv_func_fmodf_use=yes
7702 else
7703   echo "configure: failed program was:" >&5
7704   cat conftest.$ac_ext >&5
7705   rm -rf conftest*
7706   glibcpp_cv_func_fmodf_use=no
7707 fi
7708 rm -f conftest*
7709       ac_ext=c
7710 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7711 ac_cpp='$CPP $CPPFLAGS'
7712 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7713 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7714 cross_compiling=$ac_cv_prog_cc_cross
7715
7716
7717 fi
7718
7719   fi
7720   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
7721   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
7722     for ac_func in fmodf
7723 do
7724 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7725 echo "configure:7726: checking for $ac_func" >&5
7726 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7727   echo $ac_n "(cached) $ac_c" 1>&6
7728 else
7729   cat > conftest.$ac_ext <<EOF
7730 #line 7731 "configure"
7731 #include "confdefs.h"
7732 /* System header to define __stub macros and hopefully few prototypes,
7733     which can conflict with char $ac_func(); below.  */
7734 #include <assert.h>
7735 /* Override any gcc2 internal prototype to avoid an error.  */
7736 /* We use char because int might match the return type of a gcc2
7737     builtin and then its argument prototype would still apply.  */
7738 char $ac_func();
7739
7740 int main() {
7741
7742 /* The GNU C library defines this for functions which it implements
7743     to always fail with ENOSYS.  Some functions are actually named
7744     something starting with __ and the normal name is an alias.  */
7745 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7746 choke me
7747 #else
7748 $ac_func();
7749 #endif
7750
7751 ; return 0; }
7752 EOF
7753 if { (eval echo configure:7754: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7754   rm -rf conftest*
7755   eval "ac_cv_func_$ac_func=yes"
7756 else
7757   echo "configure: failed program was:" >&5
7758   cat conftest.$ac_ext >&5
7759   rm -rf conftest*
7760   eval "ac_cv_func_$ac_func=no"
7761 fi
7762 rm -f conftest*
7763 fi
7764
7765 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7766   echo "$ac_t""yes" 1>&6
7767     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7768   cat >> confdefs.h <<EOF
7769 #define $ac_tr_func 1
7770 EOF
7771
7772 else
7773   echo "$ac_t""no" 1>&6
7774 fi
7775 done
7776
7777   fi
7778
7779
7780   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
7781 echo "configure:7782: checking for frexpf declaration" >&5
7782   if test x${glibcpp_cv_func_frexpf_use+set} != xset; then
7783     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
7784   echo $ac_n "(cached) $ac_c" 1>&6
7785 else
7786
7787
7788       ac_ext=C
7789 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7790 ac_cpp='$CXXCPP $CPPFLAGS'
7791 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7792 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7793 cross_compiling=$ac_cv_prog_cxx_cross
7794
7795       cat > conftest.$ac_ext <<EOF
7796 #line 7797 "configure"
7797 #include "confdefs.h"
7798 #include <math.h>
7799 int main() {
7800  frexpf(0, 0);
7801 ; return 0; }
7802 EOF
7803 if { (eval echo configure:7804: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7804   rm -rf conftest*
7805   glibcpp_cv_func_frexpf_use=yes
7806 else
7807   echo "configure: failed program was:" >&5
7808   cat conftest.$ac_ext >&5
7809   rm -rf conftest*
7810   glibcpp_cv_func_frexpf_use=no
7811 fi
7812 rm -f conftest*
7813       ac_ext=c
7814 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7815 ac_cpp='$CPP $CPPFLAGS'
7816 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7817 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7818 cross_compiling=$ac_cv_prog_cc_cross
7819
7820
7821 fi
7822
7823   fi
7824   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
7825   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
7826     for ac_func in frexpf
7827 do
7828 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7829 echo "configure:7830: checking for $ac_func" >&5
7830 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7831   echo $ac_n "(cached) $ac_c" 1>&6
7832 else
7833   cat > conftest.$ac_ext <<EOF
7834 #line 7835 "configure"
7835 #include "confdefs.h"
7836 /* System header to define __stub macros and hopefully few prototypes,
7837     which can conflict with char $ac_func(); below.  */
7838 #include <assert.h>
7839 /* Override any gcc2 internal prototype to avoid an error.  */
7840 /* We use char because int might match the return type of a gcc2
7841     builtin and then its argument prototype would still apply.  */
7842 char $ac_func();
7843
7844 int main() {
7845
7846 /* The GNU C library defines this for functions which it implements
7847     to always fail with ENOSYS.  Some functions are actually named
7848     something starting with __ and the normal name is an alias.  */
7849 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7850 choke me
7851 #else
7852 $ac_func();
7853 #endif
7854
7855 ; return 0; }
7856 EOF
7857 if { (eval echo configure:7858: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7858   rm -rf conftest*
7859   eval "ac_cv_func_$ac_func=yes"
7860 else
7861   echo "configure: failed program was:" >&5
7862   cat conftest.$ac_ext >&5
7863   rm -rf conftest*
7864   eval "ac_cv_func_$ac_func=no"
7865 fi
7866 rm -f conftest*
7867 fi
7868
7869 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7870   echo "$ac_t""yes" 1>&6
7871     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7872   cat >> confdefs.h <<EOF
7873 #define $ac_tr_func 1
7874 EOF
7875
7876 else
7877   echo "$ac_t""no" 1>&6
7878 fi
7879 done
7880
7881   fi
7882
7883
7884   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
7885 echo "configure:7886: checking for ldexpf declaration" >&5
7886   if test x${glibcpp_cv_func_ldexpf_use+set} != xset; then
7887     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
7888   echo $ac_n "(cached) $ac_c" 1>&6
7889 else
7890
7891
7892       ac_ext=C
7893 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7894 ac_cpp='$CXXCPP $CPPFLAGS'
7895 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7896 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7897 cross_compiling=$ac_cv_prog_cxx_cross
7898
7899       cat > conftest.$ac_ext <<EOF
7900 #line 7901 "configure"
7901 #include "confdefs.h"
7902 #include <math.h>
7903 int main() {
7904  ldexpf(0, 0);
7905 ; return 0; }
7906 EOF
7907 if { (eval echo configure:7908: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7908   rm -rf conftest*
7909   glibcpp_cv_func_ldexpf_use=yes
7910 else
7911   echo "configure: failed program was:" >&5
7912   cat conftest.$ac_ext >&5
7913   rm -rf conftest*
7914   glibcpp_cv_func_ldexpf_use=no
7915 fi
7916 rm -f conftest*
7917       ac_ext=c
7918 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7919 ac_cpp='$CPP $CPPFLAGS'
7920 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7921 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7922 cross_compiling=$ac_cv_prog_cc_cross
7923
7924
7925 fi
7926
7927   fi
7928   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
7929   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
7930     for ac_func in ldexpf
7931 do
7932 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7933 echo "configure:7934: checking for $ac_func" >&5
7934 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7935   echo $ac_n "(cached) $ac_c" 1>&6
7936 else
7937   cat > conftest.$ac_ext <<EOF
7938 #line 7939 "configure"
7939 #include "confdefs.h"
7940 /* System header to define __stub macros and hopefully few prototypes,
7941     which can conflict with char $ac_func(); below.  */
7942 #include <assert.h>
7943 /* Override any gcc2 internal prototype to avoid an error.  */
7944 /* We use char because int might match the return type of a gcc2
7945     builtin and then its argument prototype would still apply.  */
7946 char $ac_func();
7947
7948 int main() {
7949
7950 /* The GNU C library defines this for functions which it implements
7951     to always fail with ENOSYS.  Some functions are actually named
7952     something starting with __ and the normal name is an alias.  */
7953 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7954 choke me
7955 #else
7956 $ac_func();
7957 #endif
7958
7959 ; return 0; }
7960 EOF
7961 if { (eval echo configure:7962: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7962   rm -rf conftest*
7963   eval "ac_cv_func_$ac_func=yes"
7964 else
7965   echo "configure: failed program was:" >&5
7966   cat conftest.$ac_ext >&5
7967   rm -rf conftest*
7968   eval "ac_cv_func_$ac_func=no"
7969 fi
7970 rm -f conftest*
7971 fi
7972
7973 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7974   echo "$ac_t""yes" 1>&6
7975     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7976   cat >> confdefs.h <<EOF
7977 #define $ac_tr_func 1
7978 EOF
7979
7980 else
7981   echo "$ac_t""no" 1>&6
7982 fi
7983 done
7984
7985   fi
7986
7987
7988   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
7989 echo "configure:7990: checking for logf declaration" >&5
7990   if test x${glibcpp_cv_func_logf_use+set} != xset; then
7991     if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
7992   echo $ac_n "(cached) $ac_c" 1>&6
7993 else
7994
7995
7996       ac_ext=C
7997 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7998 ac_cpp='$CXXCPP $CPPFLAGS'
7999 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8000 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8001 cross_compiling=$ac_cv_prog_cxx_cross
8002
8003       cat > conftest.$ac_ext <<EOF
8004 #line 8005 "configure"
8005 #include "confdefs.h"
8006 #include <math.h>
8007 int main() {
8008  logf(0);
8009 ; return 0; }
8010 EOF
8011 if { (eval echo configure:8012: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8012   rm -rf conftest*
8013   glibcpp_cv_func_logf_use=yes
8014 else
8015   echo "configure: failed program was:" >&5
8016   cat conftest.$ac_ext >&5
8017   rm -rf conftest*
8018   glibcpp_cv_func_logf_use=no
8019 fi
8020 rm -f conftest*
8021       ac_ext=c
8022 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8023 ac_cpp='$CPP $CPPFLAGS'
8024 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8025 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8026 cross_compiling=$ac_cv_prog_cc_cross
8027
8028
8029 fi
8030
8031   fi
8032   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
8033   if test x$glibcpp_cv_func_logf_use = x"yes"; then
8034     for ac_func in logf
8035 do
8036 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8037 echo "configure:8038: checking for $ac_func" >&5
8038 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8039   echo $ac_n "(cached) $ac_c" 1>&6
8040 else
8041   cat > conftest.$ac_ext <<EOF
8042 #line 8043 "configure"
8043 #include "confdefs.h"
8044 /* System header to define __stub macros and hopefully few prototypes,
8045     which can conflict with char $ac_func(); below.  */
8046 #include <assert.h>
8047 /* Override any gcc2 internal prototype to avoid an error.  */
8048 /* We use char because int might match the return type of a gcc2
8049     builtin and then its argument prototype would still apply.  */
8050 char $ac_func();
8051
8052 int main() {
8053
8054 /* The GNU C library defines this for functions which it implements
8055     to always fail with ENOSYS.  Some functions are actually named
8056     something starting with __ and the normal name is an alias.  */
8057 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8058 choke me
8059 #else
8060 $ac_func();
8061 #endif
8062
8063 ; return 0; }
8064 EOF
8065 if { (eval echo configure:8066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8066   rm -rf conftest*
8067   eval "ac_cv_func_$ac_func=yes"
8068 else
8069   echo "configure: failed program was:" >&5
8070   cat conftest.$ac_ext >&5
8071   rm -rf conftest*
8072   eval "ac_cv_func_$ac_func=no"
8073 fi
8074 rm -f conftest*
8075 fi
8076
8077 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8078   echo "$ac_t""yes" 1>&6
8079     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8080   cat >> confdefs.h <<EOF
8081 #define $ac_tr_func 1
8082 EOF
8083
8084 else
8085   echo "$ac_t""no" 1>&6
8086 fi
8087 done
8088
8089   fi
8090
8091
8092   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
8093 echo "configure:8094: checking for log10f declaration" >&5
8094   if test x${glibcpp_cv_func_log10f_use+set} != xset; then
8095     if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
8096   echo $ac_n "(cached) $ac_c" 1>&6
8097 else
8098
8099
8100       ac_ext=C
8101 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8102 ac_cpp='$CXXCPP $CPPFLAGS'
8103 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8104 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8105 cross_compiling=$ac_cv_prog_cxx_cross
8106
8107       cat > conftest.$ac_ext <<EOF
8108 #line 8109 "configure"
8109 #include "confdefs.h"
8110 #include <math.h>
8111 int main() {
8112  log10f(0);
8113 ; return 0; }
8114 EOF
8115 if { (eval echo configure:8116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8116   rm -rf conftest*
8117   glibcpp_cv_func_log10f_use=yes
8118 else
8119   echo "configure: failed program was:" >&5
8120   cat conftest.$ac_ext >&5
8121   rm -rf conftest*
8122   glibcpp_cv_func_log10f_use=no
8123 fi
8124 rm -f conftest*
8125       ac_ext=c
8126 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8127 ac_cpp='$CPP $CPPFLAGS'
8128 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8129 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8130 cross_compiling=$ac_cv_prog_cc_cross
8131
8132
8133 fi
8134
8135   fi
8136   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
8137   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
8138     for ac_func in log10f
8139 do
8140 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8141 echo "configure:8142: checking for $ac_func" >&5
8142 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8143   echo $ac_n "(cached) $ac_c" 1>&6
8144 else
8145   cat > conftest.$ac_ext <<EOF
8146 #line 8147 "configure"
8147 #include "confdefs.h"
8148 /* System header to define __stub macros and hopefully few prototypes,
8149     which can conflict with char $ac_func(); below.  */
8150 #include <assert.h>
8151 /* Override any gcc2 internal prototype to avoid an error.  */
8152 /* We use char because int might match the return type of a gcc2
8153     builtin and then its argument prototype would still apply.  */
8154 char $ac_func();
8155
8156 int main() {
8157
8158 /* The GNU C library defines this for functions which it implements
8159     to always fail with ENOSYS.  Some functions are actually named
8160     something starting with __ and the normal name is an alias.  */
8161 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8162 choke me
8163 #else
8164 $ac_func();
8165 #endif
8166
8167 ; return 0; }
8168 EOF
8169 if { (eval echo configure:8170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8170   rm -rf conftest*
8171   eval "ac_cv_func_$ac_func=yes"
8172 else
8173   echo "configure: failed program was:" >&5
8174   cat conftest.$ac_ext >&5
8175   rm -rf conftest*
8176   eval "ac_cv_func_$ac_func=no"
8177 fi
8178 rm -f conftest*
8179 fi
8180
8181 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8182   echo "$ac_t""yes" 1>&6
8183     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8184   cat >> confdefs.h <<EOF
8185 #define $ac_tr_func 1
8186 EOF
8187
8188 else
8189   echo "$ac_t""no" 1>&6
8190 fi
8191 done
8192
8193   fi
8194
8195
8196   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
8197 echo "configure:8198: checking for modff declaration" >&5
8198   if test x${glibcpp_cv_func_modff_use+set} != xset; then
8199     if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
8200   echo $ac_n "(cached) $ac_c" 1>&6
8201 else
8202
8203
8204       ac_ext=C
8205 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8206 ac_cpp='$CXXCPP $CPPFLAGS'
8207 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8208 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8209 cross_compiling=$ac_cv_prog_cxx_cross
8210
8211       cat > conftest.$ac_ext <<EOF
8212 #line 8213 "configure"
8213 #include "confdefs.h"
8214 #include <math.h>
8215 int main() {
8216  modff(0, 0);
8217 ; return 0; }
8218 EOF
8219 if { (eval echo configure:8220: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8220   rm -rf conftest*
8221   glibcpp_cv_func_modff_use=yes
8222 else
8223   echo "configure: failed program was:" >&5
8224   cat conftest.$ac_ext >&5
8225   rm -rf conftest*
8226   glibcpp_cv_func_modff_use=no
8227 fi
8228 rm -f conftest*
8229       ac_ext=c
8230 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8231 ac_cpp='$CPP $CPPFLAGS'
8232 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8233 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8234 cross_compiling=$ac_cv_prog_cc_cross
8235
8236
8237 fi
8238
8239   fi
8240   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
8241   if test x$glibcpp_cv_func_modff_use = x"yes"; then
8242     for ac_func in modff
8243 do
8244 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8245 echo "configure:8246: checking for $ac_func" >&5
8246 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8247   echo $ac_n "(cached) $ac_c" 1>&6
8248 else
8249   cat > conftest.$ac_ext <<EOF
8250 #line 8251 "configure"
8251 #include "confdefs.h"
8252 /* System header to define __stub macros and hopefully few prototypes,
8253     which can conflict with char $ac_func(); below.  */
8254 #include <assert.h>
8255 /* Override any gcc2 internal prototype to avoid an error.  */
8256 /* We use char because int might match the return type of a gcc2
8257     builtin and then its argument prototype would still apply.  */
8258 char $ac_func();
8259
8260 int main() {
8261
8262 /* The GNU C library defines this for functions which it implements
8263     to always fail with ENOSYS.  Some functions are actually named
8264     something starting with __ and the normal name is an alias.  */
8265 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8266 choke me
8267 #else
8268 $ac_func();
8269 #endif
8270
8271 ; return 0; }
8272 EOF
8273 if { (eval echo configure:8274: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8274   rm -rf conftest*
8275   eval "ac_cv_func_$ac_func=yes"
8276 else
8277   echo "configure: failed program was:" >&5
8278   cat conftest.$ac_ext >&5
8279   rm -rf conftest*
8280   eval "ac_cv_func_$ac_func=no"
8281 fi
8282 rm -f conftest*
8283 fi
8284
8285 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8286   echo "$ac_t""yes" 1>&6
8287     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8288   cat >> confdefs.h <<EOF
8289 #define $ac_tr_func 1
8290 EOF
8291
8292 else
8293   echo "$ac_t""no" 1>&6
8294 fi
8295 done
8296
8297   fi
8298
8299
8300   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
8301 echo "configure:8302: checking for powf declaration" >&5
8302   if test x${glibcpp_cv_func_powf_use+set} != xset; then
8303     if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
8304   echo $ac_n "(cached) $ac_c" 1>&6
8305 else
8306
8307
8308       ac_ext=C
8309 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8310 ac_cpp='$CXXCPP $CPPFLAGS'
8311 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8312 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8313 cross_compiling=$ac_cv_prog_cxx_cross
8314
8315       cat > conftest.$ac_ext <<EOF
8316 #line 8317 "configure"
8317 #include "confdefs.h"
8318 #include <math.h>
8319 int main() {
8320  powf(0, 0);
8321 ; return 0; }
8322 EOF
8323 if { (eval echo configure:8324: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8324   rm -rf conftest*
8325   glibcpp_cv_func_powf_use=yes
8326 else
8327   echo "configure: failed program was:" >&5
8328   cat conftest.$ac_ext >&5
8329   rm -rf conftest*
8330   glibcpp_cv_func_powf_use=no
8331 fi
8332 rm -f conftest*
8333       ac_ext=c
8334 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8335 ac_cpp='$CPP $CPPFLAGS'
8336 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8337 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8338 cross_compiling=$ac_cv_prog_cc_cross
8339
8340
8341 fi
8342
8343   fi
8344   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
8345   if test x$glibcpp_cv_func_powf_use = x"yes"; then
8346     for ac_func in powf
8347 do
8348 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8349 echo "configure:8350: checking for $ac_func" >&5
8350 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8351   echo $ac_n "(cached) $ac_c" 1>&6
8352 else
8353   cat > conftest.$ac_ext <<EOF
8354 #line 8355 "configure"
8355 #include "confdefs.h"
8356 /* System header to define __stub macros and hopefully few prototypes,
8357     which can conflict with char $ac_func(); below.  */
8358 #include <assert.h>
8359 /* Override any gcc2 internal prototype to avoid an error.  */
8360 /* We use char because int might match the return type of a gcc2
8361     builtin and then its argument prototype would still apply.  */
8362 char $ac_func();
8363
8364 int main() {
8365
8366 /* The GNU C library defines this for functions which it implements
8367     to always fail with ENOSYS.  Some functions are actually named
8368     something starting with __ and the normal name is an alias.  */
8369 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8370 choke me
8371 #else
8372 $ac_func();
8373 #endif
8374
8375 ; return 0; }
8376 EOF
8377 if { (eval echo configure:8378: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8378   rm -rf conftest*
8379   eval "ac_cv_func_$ac_func=yes"
8380 else
8381   echo "configure: failed program was:" >&5
8382   cat conftest.$ac_ext >&5
8383   rm -rf conftest*
8384   eval "ac_cv_func_$ac_func=no"
8385 fi
8386 rm -f conftest*
8387 fi
8388
8389 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8390   echo "$ac_t""yes" 1>&6
8391     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8392   cat >> confdefs.h <<EOF
8393 #define $ac_tr_func 1
8394 EOF
8395
8396 else
8397   echo "$ac_t""no" 1>&6
8398 fi
8399 done
8400
8401   fi
8402
8403
8404   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
8405 echo "configure:8406: checking for sinf declaration" >&5
8406   if test x${glibcpp_cv_func_sinf_use+set} != xset; then
8407     if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
8408   echo $ac_n "(cached) $ac_c" 1>&6
8409 else
8410
8411
8412       ac_ext=C
8413 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8414 ac_cpp='$CXXCPP $CPPFLAGS'
8415 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8416 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8417 cross_compiling=$ac_cv_prog_cxx_cross
8418
8419       cat > conftest.$ac_ext <<EOF
8420 #line 8421 "configure"
8421 #include "confdefs.h"
8422 #include <math.h>
8423 int main() {
8424  sinf(0);
8425 ; return 0; }
8426 EOF
8427 if { (eval echo configure:8428: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8428   rm -rf conftest*
8429   glibcpp_cv_func_sinf_use=yes
8430 else
8431   echo "configure: failed program was:" >&5
8432   cat conftest.$ac_ext >&5
8433   rm -rf conftest*
8434   glibcpp_cv_func_sinf_use=no
8435 fi
8436 rm -f conftest*
8437       ac_ext=c
8438 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8439 ac_cpp='$CPP $CPPFLAGS'
8440 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8441 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8442 cross_compiling=$ac_cv_prog_cc_cross
8443
8444
8445 fi
8446
8447   fi
8448   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
8449   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
8450     for ac_func in sinf
8451 do
8452 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8453 echo "configure:8454: checking for $ac_func" >&5
8454 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8455   echo $ac_n "(cached) $ac_c" 1>&6
8456 else
8457   cat > conftest.$ac_ext <<EOF
8458 #line 8459 "configure"
8459 #include "confdefs.h"
8460 /* System header to define __stub macros and hopefully few prototypes,
8461     which can conflict with char $ac_func(); below.  */
8462 #include <assert.h>
8463 /* Override any gcc2 internal prototype to avoid an error.  */
8464 /* We use char because int might match the return type of a gcc2
8465     builtin and then its argument prototype would still apply.  */
8466 char $ac_func();
8467
8468 int main() {
8469
8470 /* The GNU C library defines this for functions which it implements
8471     to always fail with ENOSYS.  Some functions are actually named
8472     something starting with __ and the normal name is an alias.  */
8473 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8474 choke me
8475 #else
8476 $ac_func();
8477 #endif
8478
8479 ; return 0; }
8480 EOF
8481 if { (eval echo configure:8482: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8482   rm -rf conftest*
8483   eval "ac_cv_func_$ac_func=yes"
8484 else
8485   echo "configure: failed program was:" >&5
8486   cat conftest.$ac_ext >&5
8487   rm -rf conftest*
8488   eval "ac_cv_func_$ac_func=no"
8489 fi
8490 rm -f conftest*
8491 fi
8492
8493 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8494   echo "$ac_t""yes" 1>&6
8495     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8496   cat >> confdefs.h <<EOF
8497 #define $ac_tr_func 1
8498 EOF
8499
8500 else
8501   echo "$ac_t""no" 1>&6
8502 fi
8503 done
8504
8505   fi
8506
8507
8508   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
8509 echo "configure:8510: checking for sinhf declaration" >&5
8510   if test x${glibcpp_cv_func_sinhf_use+set} != xset; then
8511     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
8512   echo $ac_n "(cached) $ac_c" 1>&6
8513 else
8514
8515
8516       ac_ext=C
8517 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8518 ac_cpp='$CXXCPP $CPPFLAGS'
8519 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8520 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8521 cross_compiling=$ac_cv_prog_cxx_cross
8522
8523       cat > conftest.$ac_ext <<EOF
8524 #line 8525 "configure"
8525 #include "confdefs.h"
8526 #include <math.h>
8527 int main() {
8528  sinhf(0);
8529 ; return 0; }
8530 EOF
8531 if { (eval echo configure:8532: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8532   rm -rf conftest*
8533   glibcpp_cv_func_sinhf_use=yes
8534 else
8535   echo "configure: failed program was:" >&5
8536   cat conftest.$ac_ext >&5
8537   rm -rf conftest*
8538   glibcpp_cv_func_sinhf_use=no
8539 fi
8540 rm -f conftest*
8541       ac_ext=c
8542 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8543 ac_cpp='$CPP $CPPFLAGS'
8544 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8545 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8546 cross_compiling=$ac_cv_prog_cc_cross
8547
8548
8549 fi
8550
8551   fi
8552   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
8553   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
8554     for ac_func in sinhf
8555 do
8556 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8557 echo "configure:8558: checking for $ac_func" >&5
8558 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8559   echo $ac_n "(cached) $ac_c" 1>&6
8560 else
8561   cat > conftest.$ac_ext <<EOF
8562 #line 8563 "configure"
8563 #include "confdefs.h"
8564 /* System header to define __stub macros and hopefully few prototypes,
8565     which can conflict with char $ac_func(); below.  */
8566 #include <assert.h>
8567 /* Override any gcc2 internal prototype to avoid an error.  */
8568 /* We use char because int might match the return type of a gcc2
8569     builtin and then its argument prototype would still apply.  */
8570 char $ac_func();
8571
8572 int main() {
8573
8574 /* The GNU C library defines this for functions which it implements
8575     to always fail with ENOSYS.  Some functions are actually named
8576     something starting with __ and the normal name is an alias.  */
8577 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8578 choke me
8579 #else
8580 $ac_func();
8581 #endif
8582
8583 ; return 0; }
8584 EOF
8585 if { (eval echo configure:8586: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8586   rm -rf conftest*
8587   eval "ac_cv_func_$ac_func=yes"
8588 else
8589   echo "configure: failed program was:" >&5
8590   cat conftest.$ac_ext >&5
8591   rm -rf conftest*
8592   eval "ac_cv_func_$ac_func=no"
8593 fi
8594 rm -f conftest*
8595 fi
8596
8597 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8598   echo "$ac_t""yes" 1>&6
8599     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8600   cat >> confdefs.h <<EOF
8601 #define $ac_tr_func 1
8602 EOF
8603
8604 else
8605   echo "$ac_t""no" 1>&6
8606 fi
8607 done
8608
8609   fi
8610
8611
8612   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
8613 echo "configure:8614: checking for sqrtf declaration" >&5
8614   if test x${glibcpp_cv_func_sqrtf_use+set} != xset; then
8615     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
8616   echo $ac_n "(cached) $ac_c" 1>&6
8617 else
8618
8619
8620       ac_ext=C
8621 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8622 ac_cpp='$CXXCPP $CPPFLAGS'
8623 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8624 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8625 cross_compiling=$ac_cv_prog_cxx_cross
8626
8627       cat > conftest.$ac_ext <<EOF
8628 #line 8629 "configure"
8629 #include "confdefs.h"
8630 #include <math.h>
8631 int main() {
8632  sqrtf(0);
8633 ; return 0; }
8634 EOF
8635 if { (eval echo configure:8636: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8636   rm -rf conftest*
8637   glibcpp_cv_func_sqrtf_use=yes
8638 else
8639   echo "configure: failed program was:" >&5
8640   cat conftest.$ac_ext >&5
8641   rm -rf conftest*
8642   glibcpp_cv_func_sqrtf_use=no
8643 fi
8644 rm -f conftest*
8645       ac_ext=c
8646 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8647 ac_cpp='$CPP $CPPFLAGS'
8648 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8649 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8650 cross_compiling=$ac_cv_prog_cc_cross
8651
8652
8653 fi
8654
8655   fi
8656   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
8657   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
8658     for ac_func in sqrtf
8659 do
8660 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8661 echo "configure:8662: checking for $ac_func" >&5
8662 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8663   echo $ac_n "(cached) $ac_c" 1>&6
8664 else
8665   cat > conftest.$ac_ext <<EOF
8666 #line 8667 "configure"
8667 #include "confdefs.h"
8668 /* System header to define __stub macros and hopefully few prototypes,
8669     which can conflict with char $ac_func(); below.  */
8670 #include <assert.h>
8671 /* Override any gcc2 internal prototype to avoid an error.  */
8672 /* We use char because int might match the return type of a gcc2
8673     builtin and then its argument prototype would still apply.  */
8674 char $ac_func();
8675
8676 int main() {
8677
8678 /* The GNU C library defines this for functions which it implements
8679     to always fail with ENOSYS.  Some functions are actually named
8680     something starting with __ and the normal name is an alias.  */
8681 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8682 choke me
8683 #else
8684 $ac_func();
8685 #endif
8686
8687 ; return 0; }
8688 EOF
8689 if { (eval echo configure:8690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8690   rm -rf conftest*
8691   eval "ac_cv_func_$ac_func=yes"
8692 else
8693   echo "configure: failed program was:" >&5
8694   cat conftest.$ac_ext >&5
8695   rm -rf conftest*
8696   eval "ac_cv_func_$ac_func=no"
8697 fi
8698 rm -f conftest*
8699 fi
8700
8701 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8702   echo "$ac_t""yes" 1>&6
8703     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8704   cat >> confdefs.h <<EOF
8705 #define $ac_tr_func 1
8706 EOF
8707
8708 else
8709   echo "$ac_t""no" 1>&6
8710 fi
8711 done
8712
8713   fi
8714
8715
8716   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
8717 echo "configure:8718: checking for tanf declaration" >&5
8718   if test x${glibcpp_cv_func_tanf_use+set} != xset; then
8719     if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
8720   echo $ac_n "(cached) $ac_c" 1>&6
8721 else
8722
8723
8724       ac_ext=C
8725 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8726 ac_cpp='$CXXCPP $CPPFLAGS'
8727 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8728 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8729 cross_compiling=$ac_cv_prog_cxx_cross
8730
8731       cat > conftest.$ac_ext <<EOF
8732 #line 8733 "configure"
8733 #include "confdefs.h"
8734 #include <math.h>
8735 int main() {
8736  tanf(0);
8737 ; return 0; }
8738 EOF
8739 if { (eval echo configure:8740: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8740   rm -rf conftest*
8741   glibcpp_cv_func_tanf_use=yes
8742 else
8743   echo "configure: failed program was:" >&5
8744   cat conftest.$ac_ext >&5
8745   rm -rf conftest*
8746   glibcpp_cv_func_tanf_use=no
8747 fi
8748 rm -f conftest*
8749       ac_ext=c
8750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8751 ac_cpp='$CPP $CPPFLAGS'
8752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8754 cross_compiling=$ac_cv_prog_cc_cross
8755
8756
8757 fi
8758
8759   fi
8760   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
8761   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
8762     for ac_func in tanf
8763 do
8764 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8765 echo "configure:8766: checking for $ac_func" >&5
8766 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8767   echo $ac_n "(cached) $ac_c" 1>&6
8768 else
8769   cat > conftest.$ac_ext <<EOF
8770 #line 8771 "configure"
8771 #include "confdefs.h"
8772 /* System header to define __stub macros and hopefully few prototypes,
8773     which can conflict with char $ac_func(); below.  */
8774 #include <assert.h>
8775 /* Override any gcc2 internal prototype to avoid an error.  */
8776 /* We use char because int might match the return type of a gcc2
8777     builtin and then its argument prototype would still apply.  */
8778 char $ac_func();
8779
8780 int main() {
8781
8782 /* The GNU C library defines this for functions which it implements
8783     to always fail with ENOSYS.  Some functions are actually named
8784     something starting with __ and the normal name is an alias.  */
8785 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8786 choke me
8787 #else
8788 $ac_func();
8789 #endif
8790
8791 ; return 0; }
8792 EOF
8793 if { (eval echo configure:8794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8794   rm -rf conftest*
8795   eval "ac_cv_func_$ac_func=yes"
8796 else
8797   echo "configure: failed program was:" >&5
8798   cat conftest.$ac_ext >&5
8799   rm -rf conftest*
8800   eval "ac_cv_func_$ac_func=no"
8801 fi
8802 rm -f conftest*
8803 fi
8804
8805 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8806   echo "$ac_t""yes" 1>&6
8807     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8808   cat >> confdefs.h <<EOF
8809 #define $ac_tr_func 1
8810 EOF
8811
8812 else
8813   echo "$ac_t""no" 1>&6
8814 fi
8815 done
8816
8817   fi
8818
8819
8820   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
8821 echo "configure:8822: checking for tanhf declaration" >&5
8822   if test x${glibcpp_cv_func_tanhf_use+set} != xset; then
8823     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
8824   echo $ac_n "(cached) $ac_c" 1>&6
8825 else
8826
8827
8828       ac_ext=C
8829 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8830 ac_cpp='$CXXCPP $CPPFLAGS'
8831 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8832 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8833 cross_compiling=$ac_cv_prog_cxx_cross
8834
8835       cat > conftest.$ac_ext <<EOF
8836 #line 8837 "configure"
8837 #include "confdefs.h"
8838 #include <math.h>
8839 int main() {
8840  tanhf(0);
8841 ; return 0; }
8842 EOF
8843 if { (eval echo configure:8844: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8844   rm -rf conftest*
8845   glibcpp_cv_func_tanhf_use=yes
8846 else
8847   echo "configure: failed program was:" >&5
8848   cat conftest.$ac_ext >&5
8849   rm -rf conftest*
8850   glibcpp_cv_func_tanhf_use=no
8851 fi
8852 rm -f conftest*
8853       ac_ext=c
8854 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8855 ac_cpp='$CPP $CPPFLAGS'
8856 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8857 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8858 cross_compiling=$ac_cv_prog_cc_cross
8859
8860
8861 fi
8862
8863   fi
8864   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
8865   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
8866     for ac_func in tanhf
8867 do
8868 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8869 echo "configure:8870: checking for $ac_func" >&5
8870 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8871   echo $ac_n "(cached) $ac_c" 1>&6
8872 else
8873   cat > conftest.$ac_ext <<EOF
8874 #line 8875 "configure"
8875 #include "confdefs.h"
8876 /* System header to define __stub macros and hopefully few prototypes,
8877     which can conflict with char $ac_func(); below.  */
8878 #include <assert.h>
8879 /* Override any gcc2 internal prototype to avoid an error.  */
8880 /* We use char because int might match the return type of a gcc2
8881     builtin and then its argument prototype would still apply.  */
8882 char $ac_func();
8883
8884 int main() {
8885
8886 /* The GNU C library defines this for functions which it implements
8887     to always fail with ENOSYS.  Some functions are actually named
8888     something starting with __ and the normal name is an alias.  */
8889 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8890 choke me
8891 #else
8892 $ac_func();
8893 #endif
8894
8895 ; return 0; }
8896 EOF
8897 if { (eval echo configure:8898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8898   rm -rf conftest*
8899   eval "ac_cv_func_$ac_func=yes"
8900 else
8901   echo "configure: failed program was:" >&5
8902   cat conftest.$ac_ext >&5
8903   rm -rf conftest*
8904   eval "ac_cv_func_$ac_func=no"
8905 fi
8906 rm -f conftest*
8907 fi
8908
8909 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8910   echo "$ac_t""yes" 1>&6
8911     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8912   cat >> confdefs.h <<EOF
8913 #define $ac_tr_func 1
8914 EOF
8915
8916 else
8917   echo "$ac_t""no" 1>&6
8918 fi
8919 done
8920
8921   fi
8922
8923
8924   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
8925 echo "configure:8926: checking for sincosf declaration" >&5
8926   if test x${glibcpp_cv_func_sincosf_use+set} != xset; then
8927     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
8928   echo $ac_n "(cached) $ac_c" 1>&6
8929 else
8930
8931
8932       ac_ext=C
8933 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8934 ac_cpp='$CXXCPP $CPPFLAGS'
8935 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8936 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8937 cross_compiling=$ac_cv_prog_cxx_cross
8938
8939       cat > conftest.$ac_ext <<EOF
8940 #line 8941 "configure"
8941 #include "confdefs.h"
8942 #include <math.h>
8943 int main() {
8944  sincosf(0, 0, 0);
8945 ; return 0; }
8946 EOF
8947 if { (eval echo configure:8948: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8948   rm -rf conftest*
8949   glibcpp_cv_func_sincosf_use=yes
8950 else
8951   echo "configure: failed program was:" >&5
8952   cat conftest.$ac_ext >&5
8953   rm -rf conftest*
8954   glibcpp_cv_func_sincosf_use=no
8955 fi
8956 rm -f conftest*
8957       ac_ext=c
8958 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8959 ac_cpp='$CPP $CPPFLAGS'
8960 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8961 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8962 cross_compiling=$ac_cv_prog_cc_cross
8963
8964
8965 fi
8966
8967   fi
8968   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
8969   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
8970     for ac_func in sincosf
8971 do
8972 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8973 echo "configure:8974: checking for $ac_func" >&5
8974 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8975   echo $ac_n "(cached) $ac_c" 1>&6
8976 else
8977   cat > conftest.$ac_ext <<EOF
8978 #line 8979 "configure"
8979 #include "confdefs.h"
8980 /* System header to define __stub macros and hopefully few prototypes,
8981     which can conflict with char $ac_func(); below.  */
8982 #include <assert.h>
8983 /* Override any gcc2 internal prototype to avoid an error.  */
8984 /* We use char because int might match the return type of a gcc2
8985     builtin and then its argument prototype would still apply.  */
8986 char $ac_func();
8987
8988 int main() {
8989
8990 /* The GNU C library defines this for functions which it implements
8991     to always fail with ENOSYS.  Some functions are actually named
8992     something starting with __ and the normal name is an alias.  */
8993 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8994 choke me
8995 #else
8996 $ac_func();
8997 #endif
8998
8999 ; return 0; }
9000 EOF
9001 if { (eval echo configure:9002: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9002   rm -rf conftest*
9003   eval "ac_cv_func_$ac_func=yes"
9004 else
9005   echo "configure: failed program was:" >&5
9006   cat conftest.$ac_ext >&5
9007   rm -rf conftest*
9008   eval "ac_cv_func_$ac_func=no"
9009 fi
9010 rm -f conftest*
9011 fi
9012
9013 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9014   echo "$ac_t""yes" 1>&6
9015     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9016   cat >> confdefs.h <<EOF
9017 #define $ac_tr_func 1
9018 EOF
9019
9020 else
9021   echo "$ac_t""no" 1>&6
9022 fi
9023 done
9024
9025   fi
9026
9027
9028   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
9029 echo "configure:9030: checking for finitef declaration" >&5
9030   if test x${glibcpp_cv_func_finitef_use+set} != xset; then
9031     if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
9032   echo $ac_n "(cached) $ac_c" 1>&6
9033 else
9034
9035
9036       ac_ext=C
9037 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9038 ac_cpp='$CXXCPP $CPPFLAGS'
9039 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9040 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9041 cross_compiling=$ac_cv_prog_cxx_cross
9042
9043       cat > conftest.$ac_ext <<EOF
9044 #line 9045 "configure"
9045 #include "confdefs.h"
9046 #include <math.h>
9047 int main() {
9048  finitef(0);
9049 ; return 0; }
9050 EOF
9051 if { (eval echo configure:9052: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9052   rm -rf conftest*
9053   glibcpp_cv_func_finitef_use=yes
9054 else
9055   echo "configure: failed program was:" >&5
9056   cat conftest.$ac_ext >&5
9057   rm -rf conftest*
9058   glibcpp_cv_func_finitef_use=no
9059 fi
9060 rm -f conftest*
9061       ac_ext=c
9062 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9063 ac_cpp='$CPP $CPPFLAGS'
9064 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9065 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9066 cross_compiling=$ac_cv_prog_cc_cross
9067
9068
9069 fi
9070
9071   fi
9072   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
9073   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
9074     for ac_func in finitef
9075 do
9076 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9077 echo "configure:9078: checking for $ac_func" >&5
9078 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9079   echo $ac_n "(cached) $ac_c" 1>&6
9080 else
9081   cat > conftest.$ac_ext <<EOF
9082 #line 9083 "configure"
9083 #include "confdefs.h"
9084 /* System header to define __stub macros and hopefully few prototypes,
9085     which can conflict with char $ac_func(); below.  */
9086 #include <assert.h>
9087 /* Override any gcc2 internal prototype to avoid an error.  */
9088 /* We use char because int might match the return type of a gcc2
9089     builtin and then its argument prototype would still apply.  */
9090 char $ac_func();
9091
9092 int main() {
9093
9094 /* The GNU C library defines this for functions which it implements
9095     to always fail with ENOSYS.  Some functions are actually named
9096     something starting with __ and the normal name is an alias.  */
9097 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9098 choke me
9099 #else
9100 $ac_func();
9101 #endif
9102
9103 ; return 0; }
9104 EOF
9105 if { (eval echo configure:9106: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9106   rm -rf conftest*
9107   eval "ac_cv_func_$ac_func=yes"
9108 else
9109   echo "configure: failed program was:" >&5
9110   cat conftest.$ac_ext >&5
9111   rm -rf conftest*
9112   eval "ac_cv_func_$ac_func=no"
9113 fi
9114 rm -f conftest*
9115 fi
9116
9117 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9118   echo "$ac_t""yes" 1>&6
9119     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9120   cat >> confdefs.h <<EOF
9121 #define $ac_tr_func 1
9122 EOF
9123
9124 else
9125   echo "$ac_t""no" 1>&6
9126 fi
9127 done
9128
9129   fi
9130
9131
9132
9133   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
9134 echo "configure:9135: checking for isnanl declaration" >&5
9135   if test x${glibcpp_cv_func_isnanl_use+set} != xset; then
9136     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
9137   echo $ac_n "(cached) $ac_c" 1>&6
9138 else
9139
9140
9141       ac_ext=C
9142 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9143 ac_cpp='$CXXCPP $CPPFLAGS'
9144 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9145 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9146 cross_compiling=$ac_cv_prog_cxx_cross
9147
9148       cat > conftest.$ac_ext <<EOF
9149 #line 9150 "configure"
9150 #include "confdefs.h"
9151 #include <math.h>
9152 int main() {
9153  isnanl(0);
9154 ; return 0; }
9155 EOF
9156 if { (eval echo configure:9157: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9157   rm -rf conftest*
9158   glibcpp_cv_func_isnanl_use=yes
9159 else
9160   echo "configure: failed program was:" >&5
9161   cat conftest.$ac_ext >&5
9162   rm -rf conftest*
9163   glibcpp_cv_func_isnanl_use=no
9164 fi
9165 rm -f conftest*
9166       ac_ext=c
9167 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9168 ac_cpp='$CPP $CPPFLAGS'
9169 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9170 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9171 cross_compiling=$ac_cv_prog_cc_cross
9172
9173
9174 fi
9175
9176   fi
9177   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
9178   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
9179     for ac_func in isnanl
9180 do
9181 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9182 echo "configure:9183: checking for $ac_func" >&5
9183 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9184   echo $ac_n "(cached) $ac_c" 1>&6
9185 else
9186   cat > conftest.$ac_ext <<EOF
9187 #line 9188 "configure"
9188 #include "confdefs.h"
9189 /* System header to define __stub macros and hopefully few prototypes,
9190     which can conflict with char $ac_func(); below.  */
9191 #include <assert.h>
9192 /* Override any gcc2 internal prototype to avoid an error.  */
9193 /* We use char because int might match the return type of a gcc2
9194     builtin and then its argument prototype would still apply.  */
9195 char $ac_func();
9196
9197 int main() {
9198
9199 /* The GNU C library defines this for functions which it implements
9200     to always fail with ENOSYS.  Some functions are actually named
9201     something starting with __ and the normal name is an alias.  */
9202 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9203 choke me
9204 #else
9205 $ac_func();
9206 #endif
9207
9208 ; return 0; }
9209 EOF
9210 if { (eval echo configure:9211: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9211   rm -rf conftest*
9212   eval "ac_cv_func_$ac_func=yes"
9213 else
9214   echo "configure: failed program was:" >&5
9215   cat conftest.$ac_ext >&5
9216   rm -rf conftest*
9217   eval "ac_cv_func_$ac_func=no"
9218 fi
9219 rm -f conftest*
9220 fi
9221
9222 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9223   echo "$ac_t""yes" 1>&6
9224     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9225   cat >> confdefs.h <<EOF
9226 #define $ac_tr_func 1
9227 EOF
9228
9229 else
9230   echo "$ac_t""no" 1>&6
9231 fi
9232 done
9233
9234   fi
9235
9236
9237   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
9238 echo "configure:9239: checking for isinfl declaration" >&5
9239   if test x${glibcpp_cv_func_isinfl_use+set} != xset; then
9240     if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
9241   echo $ac_n "(cached) $ac_c" 1>&6
9242 else
9243
9244
9245       ac_ext=C
9246 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9247 ac_cpp='$CXXCPP $CPPFLAGS'
9248 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9249 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9250 cross_compiling=$ac_cv_prog_cxx_cross
9251
9252       cat > conftest.$ac_ext <<EOF
9253 #line 9254 "configure"
9254 #include "confdefs.h"
9255 #include <math.h>
9256 int main() {
9257  isinfl(0);
9258 ; return 0; }
9259 EOF
9260 if { (eval echo configure:9261: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9261   rm -rf conftest*
9262   glibcpp_cv_func_isinfl_use=yes
9263 else
9264   echo "configure: failed program was:" >&5
9265   cat conftest.$ac_ext >&5
9266   rm -rf conftest*
9267   glibcpp_cv_func_isinfl_use=no
9268 fi
9269 rm -f conftest*
9270       ac_ext=c
9271 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9272 ac_cpp='$CPP $CPPFLAGS'
9273 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9274 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9275 cross_compiling=$ac_cv_prog_cc_cross
9276
9277
9278 fi
9279
9280   fi
9281   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
9282   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
9283     for ac_func in isinfl
9284 do
9285 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9286 echo "configure:9287: checking for $ac_func" >&5
9287 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9288   echo $ac_n "(cached) $ac_c" 1>&6
9289 else
9290   cat > conftest.$ac_ext <<EOF
9291 #line 9292 "configure"
9292 #include "confdefs.h"
9293 /* System header to define __stub macros and hopefully few prototypes,
9294     which can conflict with char $ac_func(); below.  */
9295 #include <assert.h>
9296 /* Override any gcc2 internal prototype to avoid an error.  */
9297 /* We use char because int might match the return type of a gcc2
9298     builtin and then its argument prototype would still apply.  */
9299 char $ac_func();
9300
9301 int main() {
9302
9303 /* The GNU C library defines this for functions which it implements
9304     to always fail with ENOSYS.  Some functions are actually named
9305     something starting with __ and the normal name is an alias.  */
9306 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9307 choke me
9308 #else
9309 $ac_func();
9310 #endif
9311
9312 ; return 0; }
9313 EOF
9314 if { (eval echo configure:9315: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9315   rm -rf conftest*
9316   eval "ac_cv_func_$ac_func=yes"
9317 else
9318   echo "configure: failed program was:" >&5
9319   cat conftest.$ac_ext >&5
9320   rm -rf conftest*
9321   eval "ac_cv_func_$ac_func=no"
9322 fi
9323 rm -f conftest*
9324 fi
9325
9326 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9327   echo "$ac_t""yes" 1>&6
9328     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9329   cat >> confdefs.h <<EOF
9330 #define $ac_tr_func 1
9331 EOF
9332
9333 else
9334   echo "$ac_t""no" 1>&6
9335 fi
9336 done
9337
9338   fi
9339
9340
9341   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
9342 echo "configure:9343: checking for copysignl declaration" >&5
9343   if test x${glibcpp_cv_func_copysignl_use+set} != xset; then
9344     if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
9345   echo $ac_n "(cached) $ac_c" 1>&6
9346 else
9347
9348
9349       ac_ext=C
9350 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9351 ac_cpp='$CXXCPP $CPPFLAGS'
9352 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9353 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9354 cross_compiling=$ac_cv_prog_cxx_cross
9355
9356       cat > conftest.$ac_ext <<EOF
9357 #line 9358 "configure"
9358 #include "confdefs.h"
9359 #include <math.h>
9360 int main() {
9361  copysignl(0, 0);
9362 ; return 0; }
9363 EOF
9364 if { (eval echo configure:9365: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9365   rm -rf conftest*
9366   glibcpp_cv_func_copysignl_use=yes
9367 else
9368   echo "configure: failed program was:" >&5
9369   cat conftest.$ac_ext >&5
9370   rm -rf conftest*
9371   glibcpp_cv_func_copysignl_use=no
9372 fi
9373 rm -f conftest*
9374       ac_ext=c
9375 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9376 ac_cpp='$CPP $CPPFLAGS'
9377 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9378 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9379 cross_compiling=$ac_cv_prog_cc_cross
9380
9381
9382 fi
9383
9384   fi
9385   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
9386   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
9387     for ac_func in copysignl
9388 do
9389 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9390 echo "configure:9391: checking for $ac_func" >&5
9391 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9392   echo $ac_n "(cached) $ac_c" 1>&6
9393 else
9394   cat > conftest.$ac_ext <<EOF
9395 #line 9396 "configure"
9396 #include "confdefs.h"
9397 /* System header to define __stub macros and hopefully few prototypes,
9398     which can conflict with char $ac_func(); below.  */
9399 #include <assert.h>
9400 /* Override any gcc2 internal prototype to avoid an error.  */
9401 /* We use char because int might match the return type of a gcc2
9402     builtin and then its argument prototype would still apply.  */
9403 char $ac_func();
9404
9405 int main() {
9406
9407 /* The GNU C library defines this for functions which it implements
9408     to always fail with ENOSYS.  Some functions are actually named
9409     something starting with __ and the normal name is an alias.  */
9410 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9411 choke me
9412 #else
9413 $ac_func();
9414 #endif
9415
9416 ; return 0; }
9417 EOF
9418 if { (eval echo configure:9419: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9419   rm -rf conftest*
9420   eval "ac_cv_func_$ac_func=yes"
9421 else
9422   echo "configure: failed program was:" >&5
9423   cat conftest.$ac_ext >&5
9424   rm -rf conftest*
9425   eval "ac_cv_func_$ac_func=no"
9426 fi
9427 rm -f conftest*
9428 fi
9429
9430 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9431   echo "$ac_t""yes" 1>&6
9432     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9433   cat >> confdefs.h <<EOF
9434 #define $ac_tr_func 1
9435 EOF
9436
9437 else
9438   echo "$ac_t""no" 1>&6
9439 fi
9440 done
9441
9442   fi
9443
9444
9445   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
9446 echo "configure:9447: checking for acosl declaration" >&5
9447   if test x${glibcpp_cv_func_acosl_use+set} != xset; then
9448     if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
9449   echo $ac_n "(cached) $ac_c" 1>&6
9450 else
9451
9452
9453       ac_ext=C
9454 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9455 ac_cpp='$CXXCPP $CPPFLAGS'
9456 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9457 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9458 cross_compiling=$ac_cv_prog_cxx_cross
9459
9460       cat > conftest.$ac_ext <<EOF
9461 #line 9462 "configure"
9462 #include "confdefs.h"
9463 #include <math.h>
9464 int main() {
9465  acosl(0);
9466 ; return 0; }
9467 EOF
9468 if { (eval echo configure:9469: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9469   rm -rf conftest*
9470   glibcpp_cv_func_acosl_use=yes
9471 else
9472   echo "configure: failed program was:" >&5
9473   cat conftest.$ac_ext >&5
9474   rm -rf conftest*
9475   glibcpp_cv_func_acosl_use=no
9476 fi
9477 rm -f conftest*
9478       ac_ext=c
9479 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9480 ac_cpp='$CPP $CPPFLAGS'
9481 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9482 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9483 cross_compiling=$ac_cv_prog_cc_cross
9484
9485
9486 fi
9487
9488   fi
9489   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
9490   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
9491     for ac_func in acosl
9492 do
9493 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9494 echo "configure:9495: checking for $ac_func" >&5
9495 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9496   echo $ac_n "(cached) $ac_c" 1>&6
9497 else
9498   cat > conftest.$ac_ext <<EOF
9499 #line 9500 "configure"
9500 #include "confdefs.h"
9501 /* System header to define __stub macros and hopefully few prototypes,
9502     which can conflict with char $ac_func(); below.  */
9503 #include <assert.h>
9504 /* Override any gcc2 internal prototype to avoid an error.  */
9505 /* We use char because int might match the return type of a gcc2
9506     builtin and then its argument prototype would still apply.  */
9507 char $ac_func();
9508
9509 int main() {
9510
9511 /* The GNU C library defines this for functions which it implements
9512     to always fail with ENOSYS.  Some functions are actually named
9513     something starting with __ and the normal name is an alias.  */
9514 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9515 choke me
9516 #else
9517 $ac_func();
9518 #endif
9519
9520 ; return 0; }
9521 EOF
9522 if { (eval echo configure:9523: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9523   rm -rf conftest*
9524   eval "ac_cv_func_$ac_func=yes"
9525 else
9526   echo "configure: failed program was:" >&5
9527   cat conftest.$ac_ext >&5
9528   rm -rf conftest*
9529   eval "ac_cv_func_$ac_func=no"
9530 fi
9531 rm -f conftest*
9532 fi
9533
9534 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9535   echo "$ac_t""yes" 1>&6
9536     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9537   cat >> confdefs.h <<EOF
9538 #define $ac_tr_func 1
9539 EOF
9540
9541 else
9542   echo "$ac_t""no" 1>&6
9543 fi
9544 done
9545
9546   fi
9547
9548
9549   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
9550 echo "configure:9551: checking for asinl declaration" >&5
9551   if test x${glibcpp_cv_func_asinl_use+set} != xset; then
9552     if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
9553   echo $ac_n "(cached) $ac_c" 1>&6
9554 else
9555
9556
9557       ac_ext=C
9558 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9559 ac_cpp='$CXXCPP $CPPFLAGS'
9560 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9561 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9562 cross_compiling=$ac_cv_prog_cxx_cross
9563
9564       cat > conftest.$ac_ext <<EOF
9565 #line 9566 "configure"
9566 #include "confdefs.h"
9567 #include <math.h>
9568 int main() {
9569  asinl(0);
9570 ; return 0; }
9571 EOF
9572 if { (eval echo configure:9573: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9573   rm -rf conftest*
9574   glibcpp_cv_func_asinl_use=yes
9575 else
9576   echo "configure: failed program was:" >&5
9577   cat conftest.$ac_ext >&5
9578   rm -rf conftest*
9579   glibcpp_cv_func_asinl_use=no
9580 fi
9581 rm -f conftest*
9582       ac_ext=c
9583 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9584 ac_cpp='$CPP $CPPFLAGS'
9585 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9586 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9587 cross_compiling=$ac_cv_prog_cc_cross
9588
9589
9590 fi
9591
9592   fi
9593   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
9594   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
9595     for ac_func in asinl
9596 do
9597 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9598 echo "configure:9599: checking for $ac_func" >&5
9599 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9600   echo $ac_n "(cached) $ac_c" 1>&6
9601 else
9602   cat > conftest.$ac_ext <<EOF
9603 #line 9604 "configure"
9604 #include "confdefs.h"
9605 /* System header to define __stub macros and hopefully few prototypes,
9606     which can conflict with char $ac_func(); below.  */
9607 #include <assert.h>
9608 /* Override any gcc2 internal prototype to avoid an error.  */
9609 /* We use char because int might match the return type of a gcc2
9610     builtin and then its argument prototype would still apply.  */
9611 char $ac_func();
9612
9613 int main() {
9614
9615 /* The GNU C library defines this for functions which it implements
9616     to always fail with ENOSYS.  Some functions are actually named
9617     something starting with __ and the normal name is an alias.  */
9618 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9619 choke me
9620 #else
9621 $ac_func();
9622 #endif
9623
9624 ; return 0; }
9625 EOF
9626 if { (eval echo configure:9627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9627   rm -rf conftest*
9628   eval "ac_cv_func_$ac_func=yes"
9629 else
9630   echo "configure: failed program was:" >&5
9631   cat conftest.$ac_ext >&5
9632   rm -rf conftest*
9633   eval "ac_cv_func_$ac_func=no"
9634 fi
9635 rm -f conftest*
9636 fi
9637
9638 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9639   echo "$ac_t""yes" 1>&6
9640     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9641   cat >> confdefs.h <<EOF
9642 #define $ac_tr_func 1
9643 EOF
9644
9645 else
9646   echo "$ac_t""no" 1>&6
9647 fi
9648 done
9649
9650   fi
9651
9652
9653   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
9654 echo "configure:9655: checking for atanl declaration" >&5
9655   if test x${glibcpp_cv_func_atanl_use+set} != xset; then
9656     if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
9657   echo $ac_n "(cached) $ac_c" 1>&6
9658 else
9659
9660
9661       ac_ext=C
9662 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9663 ac_cpp='$CXXCPP $CPPFLAGS'
9664 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9665 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9666 cross_compiling=$ac_cv_prog_cxx_cross
9667
9668       cat > conftest.$ac_ext <<EOF
9669 #line 9670 "configure"
9670 #include "confdefs.h"
9671 #include <math.h>
9672 int main() {
9673  atanl(0);
9674 ; return 0; }
9675 EOF
9676 if { (eval echo configure:9677: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9677   rm -rf conftest*
9678   glibcpp_cv_func_atanl_use=yes
9679 else
9680   echo "configure: failed program was:" >&5
9681   cat conftest.$ac_ext >&5
9682   rm -rf conftest*
9683   glibcpp_cv_func_atanl_use=no
9684 fi
9685 rm -f conftest*
9686       ac_ext=c
9687 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9688 ac_cpp='$CPP $CPPFLAGS'
9689 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9690 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9691 cross_compiling=$ac_cv_prog_cc_cross
9692
9693
9694 fi
9695
9696   fi
9697   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
9698   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
9699     for ac_func in atanl
9700 do
9701 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9702 echo "configure:9703: checking for $ac_func" >&5
9703 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9704   echo $ac_n "(cached) $ac_c" 1>&6
9705 else
9706   cat > conftest.$ac_ext <<EOF
9707 #line 9708 "configure"
9708 #include "confdefs.h"
9709 /* System header to define __stub macros and hopefully few prototypes,
9710     which can conflict with char $ac_func(); below.  */
9711 #include <assert.h>
9712 /* Override any gcc2 internal prototype to avoid an error.  */
9713 /* We use char because int might match the return type of a gcc2
9714     builtin and then its argument prototype would still apply.  */
9715 char $ac_func();
9716
9717 int main() {
9718
9719 /* The GNU C library defines this for functions which it implements
9720     to always fail with ENOSYS.  Some functions are actually named
9721     something starting with __ and the normal name is an alias.  */
9722 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9723 choke me
9724 #else
9725 $ac_func();
9726 #endif
9727
9728 ; return 0; }
9729 EOF
9730 if { (eval echo configure:9731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9731   rm -rf conftest*
9732   eval "ac_cv_func_$ac_func=yes"
9733 else
9734   echo "configure: failed program was:" >&5
9735   cat conftest.$ac_ext >&5
9736   rm -rf conftest*
9737   eval "ac_cv_func_$ac_func=no"
9738 fi
9739 rm -f conftest*
9740 fi
9741
9742 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9743   echo "$ac_t""yes" 1>&6
9744     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9745   cat >> confdefs.h <<EOF
9746 #define $ac_tr_func 1
9747 EOF
9748
9749 else
9750   echo "$ac_t""no" 1>&6
9751 fi
9752 done
9753
9754   fi
9755
9756
9757   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
9758 echo "configure:9759: checking for atan2l declaration" >&5
9759   if test x${glibcpp_cv_func_atan2l_use+set} != xset; then
9760     if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
9761   echo $ac_n "(cached) $ac_c" 1>&6
9762 else
9763
9764
9765       ac_ext=C
9766 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9767 ac_cpp='$CXXCPP $CPPFLAGS'
9768 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9769 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9770 cross_compiling=$ac_cv_prog_cxx_cross
9771
9772       cat > conftest.$ac_ext <<EOF
9773 #line 9774 "configure"
9774 #include "confdefs.h"
9775 #include <math.h>
9776 int main() {
9777  atan2l(0, 0);
9778 ; return 0; }
9779 EOF
9780 if { (eval echo configure:9781: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9781   rm -rf conftest*
9782   glibcpp_cv_func_atan2l_use=yes
9783 else
9784   echo "configure: failed program was:" >&5
9785   cat conftest.$ac_ext >&5
9786   rm -rf conftest*
9787   glibcpp_cv_func_atan2l_use=no
9788 fi
9789 rm -f conftest*
9790       ac_ext=c
9791 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9792 ac_cpp='$CPP $CPPFLAGS'
9793 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9794 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9795 cross_compiling=$ac_cv_prog_cc_cross
9796
9797
9798 fi
9799
9800   fi
9801   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
9802   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
9803     for ac_func in atan2l
9804 do
9805 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9806 echo "configure:9807: checking for $ac_func" >&5
9807 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9808   echo $ac_n "(cached) $ac_c" 1>&6
9809 else
9810   cat > conftest.$ac_ext <<EOF
9811 #line 9812 "configure"
9812 #include "confdefs.h"
9813 /* System header to define __stub macros and hopefully few prototypes,
9814     which can conflict with char $ac_func(); below.  */
9815 #include <assert.h>
9816 /* Override any gcc2 internal prototype to avoid an error.  */
9817 /* We use char because int might match the return type of a gcc2
9818     builtin and then its argument prototype would still apply.  */
9819 char $ac_func();
9820
9821 int main() {
9822
9823 /* The GNU C library defines this for functions which it implements
9824     to always fail with ENOSYS.  Some functions are actually named
9825     something starting with __ and the normal name is an alias.  */
9826 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9827 choke me
9828 #else
9829 $ac_func();
9830 #endif
9831
9832 ; return 0; }
9833 EOF
9834 if { (eval echo configure:9835: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9835   rm -rf conftest*
9836   eval "ac_cv_func_$ac_func=yes"
9837 else
9838   echo "configure: failed program was:" >&5
9839   cat conftest.$ac_ext >&5
9840   rm -rf conftest*
9841   eval "ac_cv_func_$ac_func=no"
9842 fi
9843 rm -f conftest*
9844 fi
9845
9846 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9847   echo "$ac_t""yes" 1>&6
9848     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9849   cat >> confdefs.h <<EOF
9850 #define $ac_tr_func 1
9851 EOF
9852
9853 else
9854   echo "$ac_t""no" 1>&6
9855 fi
9856 done
9857
9858   fi
9859
9860
9861   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
9862 echo "configure:9863: checking for ceill declaration" >&5
9863   if test x${glibcpp_cv_func_ceill_use+set} != xset; then
9864     if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
9865   echo $ac_n "(cached) $ac_c" 1>&6
9866 else
9867
9868
9869       ac_ext=C
9870 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9871 ac_cpp='$CXXCPP $CPPFLAGS'
9872 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9873 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9874 cross_compiling=$ac_cv_prog_cxx_cross
9875
9876       cat > conftest.$ac_ext <<EOF
9877 #line 9878 "configure"
9878 #include "confdefs.h"
9879 #include <math.h>
9880 int main() {
9881  ceill(0);
9882 ; return 0; }
9883 EOF
9884 if { (eval echo configure:9885: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9885   rm -rf conftest*
9886   glibcpp_cv_func_ceill_use=yes
9887 else
9888   echo "configure: failed program was:" >&5
9889   cat conftest.$ac_ext >&5
9890   rm -rf conftest*
9891   glibcpp_cv_func_ceill_use=no
9892 fi
9893 rm -f conftest*
9894       ac_ext=c
9895 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9896 ac_cpp='$CPP $CPPFLAGS'
9897 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9898 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9899 cross_compiling=$ac_cv_prog_cc_cross
9900
9901
9902 fi
9903
9904   fi
9905   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
9906   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
9907     for ac_func in ceill
9908 do
9909 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9910 echo "configure:9911: checking for $ac_func" >&5
9911 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9912   echo $ac_n "(cached) $ac_c" 1>&6
9913 else
9914   cat > conftest.$ac_ext <<EOF
9915 #line 9916 "configure"
9916 #include "confdefs.h"
9917 /* System header to define __stub macros and hopefully few prototypes,
9918     which can conflict with char $ac_func(); below.  */
9919 #include <assert.h>
9920 /* Override any gcc2 internal prototype to avoid an error.  */
9921 /* We use char because int might match the return type of a gcc2
9922     builtin and then its argument prototype would still apply.  */
9923 char $ac_func();
9924
9925 int main() {
9926
9927 /* The GNU C library defines this for functions which it implements
9928     to always fail with ENOSYS.  Some functions are actually named
9929     something starting with __ and the normal name is an alias.  */
9930 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9931 choke me
9932 #else
9933 $ac_func();
9934 #endif
9935
9936 ; return 0; }
9937 EOF
9938 if { (eval echo configure:9939: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9939   rm -rf conftest*
9940   eval "ac_cv_func_$ac_func=yes"
9941 else
9942   echo "configure: failed program was:" >&5
9943   cat conftest.$ac_ext >&5
9944   rm -rf conftest*
9945   eval "ac_cv_func_$ac_func=no"
9946 fi
9947 rm -f conftest*
9948 fi
9949
9950 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9951   echo "$ac_t""yes" 1>&6
9952     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9953   cat >> confdefs.h <<EOF
9954 #define $ac_tr_func 1
9955 EOF
9956
9957 else
9958   echo "$ac_t""no" 1>&6
9959 fi
9960 done
9961
9962   fi
9963
9964
9965   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
9966 echo "configure:9967: checking for cosl declaration" >&5
9967   if test x${glibcpp_cv_func_cosl_use+set} != xset; then
9968     if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
9969   echo $ac_n "(cached) $ac_c" 1>&6
9970 else
9971
9972
9973       ac_ext=C
9974 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9975 ac_cpp='$CXXCPP $CPPFLAGS'
9976 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9977 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9978 cross_compiling=$ac_cv_prog_cxx_cross
9979
9980       cat > conftest.$ac_ext <<EOF
9981 #line 9982 "configure"
9982 #include "confdefs.h"
9983 #include <math.h>
9984 int main() {
9985  cosl(0);
9986 ; return 0; }
9987 EOF
9988 if { (eval echo configure:9989: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9989   rm -rf conftest*
9990   glibcpp_cv_func_cosl_use=yes
9991 else
9992   echo "configure: failed program was:" >&5
9993   cat conftest.$ac_ext >&5
9994   rm -rf conftest*
9995   glibcpp_cv_func_cosl_use=no
9996 fi
9997 rm -f conftest*
9998       ac_ext=c
9999 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10000 ac_cpp='$CPP $CPPFLAGS'
10001 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10002 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10003 cross_compiling=$ac_cv_prog_cc_cross
10004
10005
10006 fi
10007
10008   fi
10009   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
10010   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
10011     for ac_func in cosl
10012 do
10013 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10014 echo "configure:10015: checking for $ac_func" >&5
10015 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10016   echo $ac_n "(cached) $ac_c" 1>&6
10017 else
10018   cat > conftest.$ac_ext <<EOF
10019 #line 10020 "configure"
10020 #include "confdefs.h"
10021 /* System header to define __stub macros and hopefully few prototypes,
10022     which can conflict with char $ac_func(); below.  */
10023 #include <assert.h>
10024 /* Override any gcc2 internal prototype to avoid an error.  */
10025 /* We use char because int might match the return type of a gcc2
10026     builtin and then its argument prototype would still apply.  */
10027 char $ac_func();
10028
10029 int main() {
10030
10031 /* The GNU C library defines this for functions which it implements
10032     to always fail with ENOSYS.  Some functions are actually named
10033     something starting with __ and the normal name is an alias.  */
10034 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10035 choke me
10036 #else
10037 $ac_func();
10038 #endif
10039
10040 ; return 0; }
10041 EOF
10042 if { (eval echo configure:10043: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10043   rm -rf conftest*
10044   eval "ac_cv_func_$ac_func=yes"
10045 else
10046   echo "configure: failed program was:" >&5
10047   cat conftest.$ac_ext >&5
10048   rm -rf conftest*
10049   eval "ac_cv_func_$ac_func=no"
10050 fi
10051 rm -f conftest*
10052 fi
10053
10054 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10055   echo "$ac_t""yes" 1>&6
10056     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10057   cat >> confdefs.h <<EOF
10058 #define $ac_tr_func 1
10059 EOF
10060
10061 else
10062   echo "$ac_t""no" 1>&6
10063 fi
10064 done
10065
10066   fi
10067
10068
10069   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
10070 echo "configure:10071: checking for coshl declaration" >&5
10071   if test x${glibcpp_cv_func_coshl_use+set} != xset; then
10072     if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
10073   echo $ac_n "(cached) $ac_c" 1>&6
10074 else
10075
10076
10077       ac_ext=C
10078 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10079 ac_cpp='$CXXCPP $CPPFLAGS'
10080 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10081 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10082 cross_compiling=$ac_cv_prog_cxx_cross
10083
10084       cat > conftest.$ac_ext <<EOF
10085 #line 10086 "configure"
10086 #include "confdefs.h"
10087 #include <math.h>
10088 int main() {
10089  coshl(0);
10090 ; return 0; }
10091 EOF
10092 if { (eval echo configure:10093: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10093   rm -rf conftest*
10094   glibcpp_cv_func_coshl_use=yes
10095 else
10096   echo "configure: failed program was:" >&5
10097   cat conftest.$ac_ext >&5
10098   rm -rf conftest*
10099   glibcpp_cv_func_coshl_use=no
10100 fi
10101 rm -f conftest*
10102       ac_ext=c
10103 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10104 ac_cpp='$CPP $CPPFLAGS'
10105 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10106 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10107 cross_compiling=$ac_cv_prog_cc_cross
10108
10109
10110 fi
10111
10112   fi
10113   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
10114   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
10115     for ac_func in coshl
10116 do
10117 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10118 echo "configure:10119: checking for $ac_func" >&5
10119 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10120   echo $ac_n "(cached) $ac_c" 1>&6
10121 else
10122   cat > conftest.$ac_ext <<EOF
10123 #line 10124 "configure"
10124 #include "confdefs.h"
10125 /* System header to define __stub macros and hopefully few prototypes,
10126     which can conflict with char $ac_func(); below.  */
10127 #include <assert.h>
10128 /* Override any gcc2 internal prototype to avoid an error.  */
10129 /* We use char because int might match the return type of a gcc2
10130     builtin and then its argument prototype would still apply.  */
10131 char $ac_func();
10132
10133 int main() {
10134
10135 /* The GNU C library defines this for functions which it implements
10136     to always fail with ENOSYS.  Some functions are actually named
10137     something starting with __ and the normal name is an alias.  */
10138 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10139 choke me
10140 #else
10141 $ac_func();
10142 #endif
10143
10144 ; return 0; }
10145 EOF
10146 if { (eval echo configure:10147: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10147   rm -rf conftest*
10148   eval "ac_cv_func_$ac_func=yes"
10149 else
10150   echo "configure: failed program was:" >&5
10151   cat conftest.$ac_ext >&5
10152   rm -rf conftest*
10153   eval "ac_cv_func_$ac_func=no"
10154 fi
10155 rm -f conftest*
10156 fi
10157
10158 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10159   echo "$ac_t""yes" 1>&6
10160     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10161   cat >> confdefs.h <<EOF
10162 #define $ac_tr_func 1
10163 EOF
10164
10165 else
10166   echo "$ac_t""no" 1>&6
10167 fi
10168 done
10169
10170   fi
10171
10172
10173   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
10174 echo "configure:10175: checking for expl declaration" >&5
10175   if test x${glibcpp_cv_func_expl_use+set} != xset; then
10176     if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
10177   echo $ac_n "(cached) $ac_c" 1>&6
10178 else
10179
10180
10181       ac_ext=C
10182 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10183 ac_cpp='$CXXCPP $CPPFLAGS'
10184 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10185 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10186 cross_compiling=$ac_cv_prog_cxx_cross
10187
10188       cat > conftest.$ac_ext <<EOF
10189 #line 10190 "configure"
10190 #include "confdefs.h"
10191 #include <math.h>
10192 int main() {
10193  expl(0);
10194 ; return 0; }
10195 EOF
10196 if { (eval echo configure:10197: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10197   rm -rf conftest*
10198   glibcpp_cv_func_expl_use=yes
10199 else
10200   echo "configure: failed program was:" >&5
10201   cat conftest.$ac_ext >&5
10202   rm -rf conftest*
10203   glibcpp_cv_func_expl_use=no
10204 fi
10205 rm -f conftest*
10206       ac_ext=c
10207 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10208 ac_cpp='$CPP $CPPFLAGS'
10209 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10210 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10211 cross_compiling=$ac_cv_prog_cc_cross
10212
10213
10214 fi
10215
10216   fi
10217   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
10218   if test x$glibcpp_cv_func_expl_use = x"yes"; then
10219     for ac_func in expl
10220 do
10221 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10222 echo "configure:10223: checking for $ac_func" >&5
10223 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10224   echo $ac_n "(cached) $ac_c" 1>&6
10225 else
10226   cat > conftest.$ac_ext <<EOF
10227 #line 10228 "configure"
10228 #include "confdefs.h"
10229 /* System header to define __stub macros and hopefully few prototypes,
10230     which can conflict with char $ac_func(); below.  */
10231 #include <assert.h>
10232 /* Override any gcc2 internal prototype to avoid an error.  */
10233 /* We use char because int might match the return type of a gcc2
10234     builtin and then its argument prototype would still apply.  */
10235 char $ac_func();
10236
10237 int main() {
10238
10239 /* The GNU C library defines this for functions which it implements
10240     to always fail with ENOSYS.  Some functions are actually named
10241     something starting with __ and the normal name is an alias.  */
10242 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10243 choke me
10244 #else
10245 $ac_func();
10246 #endif
10247
10248 ; return 0; }
10249 EOF
10250 if { (eval echo configure:10251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10251   rm -rf conftest*
10252   eval "ac_cv_func_$ac_func=yes"
10253 else
10254   echo "configure: failed program was:" >&5
10255   cat conftest.$ac_ext >&5
10256   rm -rf conftest*
10257   eval "ac_cv_func_$ac_func=no"
10258 fi
10259 rm -f conftest*
10260 fi
10261
10262 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10263   echo "$ac_t""yes" 1>&6
10264     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10265   cat >> confdefs.h <<EOF
10266 #define $ac_tr_func 1
10267 EOF
10268
10269 else
10270   echo "$ac_t""no" 1>&6
10271 fi
10272 done
10273
10274   fi
10275
10276
10277   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
10278 echo "configure:10279: checking for fabsl declaration" >&5
10279   if test x${glibcpp_cv_func_fabsl_use+set} != xset; then
10280     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
10281   echo $ac_n "(cached) $ac_c" 1>&6
10282 else
10283
10284
10285       ac_ext=C
10286 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10287 ac_cpp='$CXXCPP $CPPFLAGS'
10288 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10289 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10290 cross_compiling=$ac_cv_prog_cxx_cross
10291
10292       cat > conftest.$ac_ext <<EOF
10293 #line 10294 "configure"
10294 #include "confdefs.h"
10295 #include <math.h>
10296 int main() {
10297  fabsl(0);
10298 ; return 0; }
10299 EOF
10300 if { (eval echo configure:10301: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10301   rm -rf conftest*
10302   glibcpp_cv_func_fabsl_use=yes
10303 else
10304   echo "configure: failed program was:" >&5
10305   cat conftest.$ac_ext >&5
10306   rm -rf conftest*
10307   glibcpp_cv_func_fabsl_use=no
10308 fi
10309 rm -f conftest*
10310       ac_ext=c
10311 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10312 ac_cpp='$CPP $CPPFLAGS'
10313 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10314 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10315 cross_compiling=$ac_cv_prog_cc_cross
10316
10317
10318 fi
10319
10320   fi
10321   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
10322   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
10323     for ac_func in fabsl
10324 do
10325 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10326 echo "configure:10327: checking for $ac_func" >&5
10327 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10328   echo $ac_n "(cached) $ac_c" 1>&6
10329 else
10330   cat > conftest.$ac_ext <<EOF
10331 #line 10332 "configure"
10332 #include "confdefs.h"
10333 /* System header to define __stub macros and hopefully few prototypes,
10334     which can conflict with char $ac_func(); below.  */
10335 #include <assert.h>
10336 /* Override any gcc2 internal prototype to avoid an error.  */
10337 /* We use char because int might match the return type of a gcc2
10338     builtin and then its argument prototype would still apply.  */
10339 char $ac_func();
10340
10341 int main() {
10342
10343 /* The GNU C library defines this for functions which it implements
10344     to always fail with ENOSYS.  Some functions are actually named
10345     something starting with __ and the normal name is an alias.  */
10346 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10347 choke me
10348 #else
10349 $ac_func();
10350 #endif
10351
10352 ; return 0; }
10353 EOF
10354 if { (eval echo configure:10355: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10355   rm -rf conftest*
10356   eval "ac_cv_func_$ac_func=yes"
10357 else
10358   echo "configure: failed program was:" >&5
10359   cat conftest.$ac_ext >&5
10360   rm -rf conftest*
10361   eval "ac_cv_func_$ac_func=no"
10362 fi
10363 rm -f conftest*
10364 fi
10365
10366 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10367   echo "$ac_t""yes" 1>&6
10368     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10369   cat >> confdefs.h <<EOF
10370 #define $ac_tr_func 1
10371 EOF
10372
10373 else
10374   echo "$ac_t""no" 1>&6
10375 fi
10376 done
10377
10378   fi
10379
10380
10381   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
10382 echo "configure:10383: checking for floorl declaration" >&5
10383   if test x${glibcpp_cv_func_floorl_use+set} != xset; then
10384     if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
10385   echo $ac_n "(cached) $ac_c" 1>&6
10386 else
10387
10388
10389       ac_ext=C
10390 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10391 ac_cpp='$CXXCPP $CPPFLAGS'
10392 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10393 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10394 cross_compiling=$ac_cv_prog_cxx_cross
10395
10396       cat > conftest.$ac_ext <<EOF
10397 #line 10398 "configure"
10398 #include "confdefs.h"
10399 #include <math.h>
10400 int main() {
10401  floorl(0);
10402 ; return 0; }
10403 EOF
10404 if { (eval echo configure:10405: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10405   rm -rf conftest*
10406   glibcpp_cv_func_floorl_use=yes
10407 else
10408   echo "configure: failed program was:" >&5
10409   cat conftest.$ac_ext >&5
10410   rm -rf conftest*
10411   glibcpp_cv_func_floorl_use=no
10412 fi
10413 rm -f conftest*
10414       ac_ext=c
10415 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10416 ac_cpp='$CPP $CPPFLAGS'
10417 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10418 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10419 cross_compiling=$ac_cv_prog_cc_cross
10420
10421
10422 fi
10423
10424   fi
10425   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
10426   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
10427     for ac_func in floorl
10428 do
10429 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10430 echo "configure:10431: checking for $ac_func" >&5
10431 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10432   echo $ac_n "(cached) $ac_c" 1>&6
10433 else
10434   cat > conftest.$ac_ext <<EOF
10435 #line 10436 "configure"
10436 #include "confdefs.h"
10437 /* System header to define __stub macros and hopefully few prototypes,
10438     which can conflict with char $ac_func(); below.  */
10439 #include <assert.h>
10440 /* Override any gcc2 internal prototype to avoid an error.  */
10441 /* We use char because int might match the return type of a gcc2
10442     builtin and then its argument prototype would still apply.  */
10443 char $ac_func();
10444
10445 int main() {
10446
10447 /* The GNU C library defines this for functions which it implements
10448     to always fail with ENOSYS.  Some functions are actually named
10449     something starting with __ and the normal name is an alias.  */
10450 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10451 choke me
10452 #else
10453 $ac_func();
10454 #endif
10455
10456 ; return 0; }
10457 EOF
10458 if { (eval echo configure:10459: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10459   rm -rf conftest*
10460   eval "ac_cv_func_$ac_func=yes"
10461 else
10462   echo "configure: failed program was:" >&5
10463   cat conftest.$ac_ext >&5
10464   rm -rf conftest*
10465   eval "ac_cv_func_$ac_func=no"
10466 fi
10467 rm -f conftest*
10468 fi
10469
10470 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10471   echo "$ac_t""yes" 1>&6
10472     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10473   cat >> confdefs.h <<EOF
10474 #define $ac_tr_func 1
10475 EOF
10476
10477 else
10478   echo "$ac_t""no" 1>&6
10479 fi
10480 done
10481
10482   fi
10483
10484
10485   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
10486 echo "configure:10487: checking for fmodl declaration" >&5
10487   if test x${glibcpp_cv_func_fmodl_use+set} != xset; then
10488     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
10489   echo $ac_n "(cached) $ac_c" 1>&6
10490 else
10491
10492
10493       ac_ext=C
10494 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10495 ac_cpp='$CXXCPP $CPPFLAGS'
10496 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10497 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10498 cross_compiling=$ac_cv_prog_cxx_cross
10499
10500       cat > conftest.$ac_ext <<EOF
10501 #line 10502 "configure"
10502 #include "confdefs.h"
10503 #include <math.h>
10504 int main() {
10505  fmodl(0, 0);
10506 ; return 0; }
10507 EOF
10508 if { (eval echo configure:10509: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10509   rm -rf conftest*
10510   glibcpp_cv_func_fmodl_use=yes
10511 else
10512   echo "configure: failed program was:" >&5
10513   cat conftest.$ac_ext >&5
10514   rm -rf conftest*
10515   glibcpp_cv_func_fmodl_use=no
10516 fi
10517 rm -f conftest*
10518       ac_ext=c
10519 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10520 ac_cpp='$CPP $CPPFLAGS'
10521 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10522 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10523 cross_compiling=$ac_cv_prog_cc_cross
10524
10525
10526 fi
10527
10528   fi
10529   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
10530   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
10531     for ac_func in fmodl
10532 do
10533 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10534 echo "configure:10535: checking for $ac_func" >&5
10535 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10536   echo $ac_n "(cached) $ac_c" 1>&6
10537 else
10538   cat > conftest.$ac_ext <<EOF
10539 #line 10540 "configure"
10540 #include "confdefs.h"
10541 /* System header to define __stub macros and hopefully few prototypes,
10542     which can conflict with char $ac_func(); below.  */
10543 #include <assert.h>
10544 /* Override any gcc2 internal prototype to avoid an error.  */
10545 /* We use char because int might match the return type of a gcc2
10546     builtin and then its argument prototype would still apply.  */
10547 char $ac_func();
10548
10549 int main() {
10550
10551 /* The GNU C library defines this for functions which it implements
10552     to always fail with ENOSYS.  Some functions are actually named
10553     something starting with __ and the normal name is an alias.  */
10554 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10555 choke me
10556 #else
10557 $ac_func();
10558 #endif
10559
10560 ; return 0; }
10561 EOF
10562 if { (eval echo configure:10563: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10563   rm -rf conftest*
10564   eval "ac_cv_func_$ac_func=yes"
10565 else
10566   echo "configure: failed program was:" >&5
10567   cat conftest.$ac_ext >&5
10568   rm -rf conftest*
10569   eval "ac_cv_func_$ac_func=no"
10570 fi
10571 rm -f conftest*
10572 fi
10573
10574 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10575   echo "$ac_t""yes" 1>&6
10576     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10577   cat >> confdefs.h <<EOF
10578 #define $ac_tr_func 1
10579 EOF
10580
10581 else
10582   echo "$ac_t""no" 1>&6
10583 fi
10584 done
10585
10586   fi
10587
10588
10589   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
10590 echo "configure:10591: checking for frexpl declaration" >&5
10591   if test x${glibcpp_cv_func_frexpl_use+set} != xset; then
10592     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
10593   echo $ac_n "(cached) $ac_c" 1>&6
10594 else
10595
10596
10597       ac_ext=C
10598 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10599 ac_cpp='$CXXCPP $CPPFLAGS'
10600 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10601 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10602 cross_compiling=$ac_cv_prog_cxx_cross
10603
10604       cat > conftest.$ac_ext <<EOF
10605 #line 10606 "configure"
10606 #include "confdefs.h"
10607 #include <math.h>
10608 int main() {
10609  frexpl(0, 0);
10610 ; return 0; }
10611 EOF
10612 if { (eval echo configure:10613: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10613   rm -rf conftest*
10614   glibcpp_cv_func_frexpl_use=yes
10615 else
10616   echo "configure: failed program was:" >&5
10617   cat conftest.$ac_ext >&5
10618   rm -rf conftest*
10619   glibcpp_cv_func_frexpl_use=no
10620 fi
10621 rm -f conftest*
10622       ac_ext=c
10623 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10624 ac_cpp='$CPP $CPPFLAGS'
10625 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10626 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10627 cross_compiling=$ac_cv_prog_cc_cross
10628
10629
10630 fi
10631
10632   fi
10633   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
10634   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
10635     for ac_func in frexpl
10636 do
10637 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10638 echo "configure:10639: checking for $ac_func" >&5
10639 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10640   echo $ac_n "(cached) $ac_c" 1>&6
10641 else
10642   cat > conftest.$ac_ext <<EOF
10643 #line 10644 "configure"
10644 #include "confdefs.h"
10645 /* System header to define __stub macros and hopefully few prototypes,
10646     which can conflict with char $ac_func(); below.  */
10647 #include <assert.h>
10648 /* Override any gcc2 internal prototype to avoid an error.  */
10649 /* We use char because int might match the return type of a gcc2
10650     builtin and then its argument prototype would still apply.  */
10651 char $ac_func();
10652
10653 int main() {
10654
10655 /* The GNU C library defines this for functions which it implements
10656     to always fail with ENOSYS.  Some functions are actually named
10657     something starting with __ and the normal name is an alias.  */
10658 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10659 choke me
10660 #else
10661 $ac_func();
10662 #endif
10663
10664 ; return 0; }
10665 EOF
10666 if { (eval echo configure:10667: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10667   rm -rf conftest*
10668   eval "ac_cv_func_$ac_func=yes"
10669 else
10670   echo "configure: failed program was:" >&5
10671   cat conftest.$ac_ext >&5
10672   rm -rf conftest*
10673   eval "ac_cv_func_$ac_func=no"
10674 fi
10675 rm -f conftest*
10676 fi
10677
10678 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10679   echo "$ac_t""yes" 1>&6
10680     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10681   cat >> confdefs.h <<EOF
10682 #define $ac_tr_func 1
10683 EOF
10684
10685 else
10686   echo "$ac_t""no" 1>&6
10687 fi
10688 done
10689
10690   fi
10691
10692
10693   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
10694 echo "configure:10695: checking for ldexpl declaration" >&5
10695   if test x${glibcpp_cv_func_ldexpl_use+set} != xset; then
10696     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
10697   echo $ac_n "(cached) $ac_c" 1>&6
10698 else
10699
10700
10701       ac_ext=C
10702 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10703 ac_cpp='$CXXCPP $CPPFLAGS'
10704 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10705 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10706 cross_compiling=$ac_cv_prog_cxx_cross
10707
10708       cat > conftest.$ac_ext <<EOF
10709 #line 10710 "configure"
10710 #include "confdefs.h"
10711 #include <math.h>
10712 int main() {
10713  ldexpl(0, 0);
10714 ; return 0; }
10715 EOF
10716 if { (eval echo configure:10717: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10717   rm -rf conftest*
10718   glibcpp_cv_func_ldexpl_use=yes
10719 else
10720   echo "configure: failed program was:" >&5
10721   cat conftest.$ac_ext >&5
10722   rm -rf conftest*
10723   glibcpp_cv_func_ldexpl_use=no
10724 fi
10725 rm -f conftest*
10726       ac_ext=c
10727 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10728 ac_cpp='$CPP $CPPFLAGS'
10729 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10730 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10731 cross_compiling=$ac_cv_prog_cc_cross
10732
10733
10734 fi
10735
10736   fi
10737   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
10738   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
10739     for ac_func in ldexpl
10740 do
10741 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10742 echo "configure:10743: checking for $ac_func" >&5
10743 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10744   echo $ac_n "(cached) $ac_c" 1>&6
10745 else
10746   cat > conftest.$ac_ext <<EOF
10747 #line 10748 "configure"
10748 #include "confdefs.h"
10749 /* System header to define __stub macros and hopefully few prototypes,
10750     which can conflict with char $ac_func(); below.  */
10751 #include <assert.h>
10752 /* Override any gcc2 internal prototype to avoid an error.  */
10753 /* We use char because int might match the return type of a gcc2
10754     builtin and then its argument prototype would still apply.  */
10755 char $ac_func();
10756
10757 int main() {
10758
10759 /* The GNU C library defines this for functions which it implements
10760     to always fail with ENOSYS.  Some functions are actually named
10761     something starting with __ and the normal name is an alias.  */
10762 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10763 choke me
10764 #else
10765 $ac_func();
10766 #endif
10767
10768 ; return 0; }
10769 EOF
10770 if { (eval echo configure:10771: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10771   rm -rf conftest*
10772   eval "ac_cv_func_$ac_func=yes"
10773 else
10774   echo "configure: failed program was:" >&5
10775   cat conftest.$ac_ext >&5
10776   rm -rf conftest*
10777   eval "ac_cv_func_$ac_func=no"
10778 fi
10779 rm -f conftest*
10780 fi
10781
10782 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10783   echo "$ac_t""yes" 1>&6
10784     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10785   cat >> confdefs.h <<EOF
10786 #define $ac_tr_func 1
10787 EOF
10788
10789 else
10790   echo "$ac_t""no" 1>&6
10791 fi
10792 done
10793
10794   fi
10795
10796
10797   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
10798 echo "configure:10799: checking for logl declaration" >&5
10799   if test x${glibcpp_cv_func_logl_use+set} != xset; then
10800     if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
10801   echo $ac_n "(cached) $ac_c" 1>&6
10802 else
10803
10804
10805       ac_ext=C
10806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10807 ac_cpp='$CXXCPP $CPPFLAGS'
10808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10810 cross_compiling=$ac_cv_prog_cxx_cross
10811
10812       cat > conftest.$ac_ext <<EOF
10813 #line 10814 "configure"
10814 #include "confdefs.h"
10815 #include <math.h>
10816 int main() {
10817  logl(0);
10818 ; return 0; }
10819 EOF
10820 if { (eval echo configure:10821: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10821   rm -rf conftest*
10822   glibcpp_cv_func_logl_use=yes
10823 else
10824   echo "configure: failed program was:" >&5
10825   cat conftest.$ac_ext >&5
10826   rm -rf conftest*
10827   glibcpp_cv_func_logl_use=no
10828 fi
10829 rm -f conftest*
10830       ac_ext=c
10831 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10832 ac_cpp='$CPP $CPPFLAGS'
10833 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10834 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10835 cross_compiling=$ac_cv_prog_cc_cross
10836
10837
10838 fi
10839
10840   fi
10841   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
10842   if test x$glibcpp_cv_func_logl_use = x"yes"; then
10843     for ac_func in logl
10844 do
10845 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10846 echo "configure:10847: checking for $ac_func" >&5
10847 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10848   echo $ac_n "(cached) $ac_c" 1>&6
10849 else
10850   cat > conftest.$ac_ext <<EOF
10851 #line 10852 "configure"
10852 #include "confdefs.h"
10853 /* System header to define __stub macros and hopefully few prototypes,
10854     which can conflict with char $ac_func(); below.  */
10855 #include <assert.h>
10856 /* Override any gcc2 internal prototype to avoid an error.  */
10857 /* We use char because int might match the return type of a gcc2
10858     builtin and then its argument prototype would still apply.  */
10859 char $ac_func();
10860
10861 int main() {
10862
10863 /* The GNU C library defines this for functions which it implements
10864     to always fail with ENOSYS.  Some functions are actually named
10865     something starting with __ and the normal name is an alias.  */
10866 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10867 choke me
10868 #else
10869 $ac_func();
10870 #endif
10871
10872 ; return 0; }
10873 EOF
10874 if { (eval echo configure:10875: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10875   rm -rf conftest*
10876   eval "ac_cv_func_$ac_func=yes"
10877 else
10878   echo "configure: failed program was:" >&5
10879   cat conftest.$ac_ext >&5
10880   rm -rf conftest*
10881   eval "ac_cv_func_$ac_func=no"
10882 fi
10883 rm -f conftest*
10884 fi
10885
10886 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10887   echo "$ac_t""yes" 1>&6
10888     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10889   cat >> confdefs.h <<EOF
10890 #define $ac_tr_func 1
10891 EOF
10892
10893 else
10894   echo "$ac_t""no" 1>&6
10895 fi
10896 done
10897
10898   fi
10899
10900
10901   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
10902 echo "configure:10903: checking for log10l declaration" >&5
10903   if test x${glibcpp_cv_func_log10l_use+set} != xset; then
10904     if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
10905   echo $ac_n "(cached) $ac_c" 1>&6
10906 else
10907
10908
10909       ac_ext=C
10910 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10911 ac_cpp='$CXXCPP $CPPFLAGS'
10912 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10913 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10914 cross_compiling=$ac_cv_prog_cxx_cross
10915
10916       cat > conftest.$ac_ext <<EOF
10917 #line 10918 "configure"
10918 #include "confdefs.h"
10919 #include <math.h>
10920 int main() {
10921  log10l(0);
10922 ; return 0; }
10923 EOF
10924 if { (eval echo configure:10925: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10925   rm -rf conftest*
10926   glibcpp_cv_func_log10l_use=yes
10927 else
10928   echo "configure: failed program was:" >&5
10929   cat conftest.$ac_ext >&5
10930   rm -rf conftest*
10931   glibcpp_cv_func_log10l_use=no
10932 fi
10933 rm -f conftest*
10934       ac_ext=c
10935 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10936 ac_cpp='$CPP $CPPFLAGS'
10937 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10938 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10939 cross_compiling=$ac_cv_prog_cc_cross
10940
10941
10942 fi
10943
10944   fi
10945   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
10946   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
10947     for ac_func in log10l
10948 do
10949 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10950 echo "configure:10951: checking for $ac_func" >&5
10951 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10952   echo $ac_n "(cached) $ac_c" 1>&6
10953 else
10954   cat > conftest.$ac_ext <<EOF
10955 #line 10956 "configure"
10956 #include "confdefs.h"
10957 /* System header to define __stub macros and hopefully few prototypes,
10958     which can conflict with char $ac_func(); below.  */
10959 #include <assert.h>
10960 /* Override any gcc2 internal prototype to avoid an error.  */
10961 /* We use char because int might match the return type of a gcc2
10962     builtin and then its argument prototype would still apply.  */
10963 char $ac_func();
10964
10965 int main() {
10966
10967 /* The GNU C library defines this for functions which it implements
10968     to always fail with ENOSYS.  Some functions are actually named
10969     something starting with __ and the normal name is an alias.  */
10970 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10971 choke me
10972 #else
10973 $ac_func();
10974 #endif
10975
10976 ; return 0; }
10977 EOF
10978 if { (eval echo configure:10979: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10979   rm -rf conftest*
10980   eval "ac_cv_func_$ac_func=yes"
10981 else
10982   echo "configure: failed program was:" >&5
10983   cat conftest.$ac_ext >&5
10984   rm -rf conftest*
10985   eval "ac_cv_func_$ac_func=no"
10986 fi
10987 rm -f conftest*
10988 fi
10989
10990 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10991   echo "$ac_t""yes" 1>&6
10992     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10993   cat >> confdefs.h <<EOF
10994 #define $ac_tr_func 1
10995 EOF
10996
10997 else
10998   echo "$ac_t""no" 1>&6
10999 fi
11000 done
11001
11002   fi
11003
11004
11005   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
11006 echo "configure:11007: checking for modfl declaration" >&5
11007   if test x${glibcpp_cv_func_modfl_use+set} != xset; then
11008     if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
11009   echo $ac_n "(cached) $ac_c" 1>&6
11010 else
11011
11012
11013       ac_ext=C
11014 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11015 ac_cpp='$CXXCPP $CPPFLAGS'
11016 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11017 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11018 cross_compiling=$ac_cv_prog_cxx_cross
11019
11020       cat > conftest.$ac_ext <<EOF
11021 #line 11022 "configure"
11022 #include "confdefs.h"
11023 #include <math.h>
11024 int main() {
11025  modfl(0, 0);
11026 ; return 0; }
11027 EOF
11028 if { (eval echo configure:11029: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11029   rm -rf conftest*
11030   glibcpp_cv_func_modfl_use=yes
11031 else
11032   echo "configure: failed program was:" >&5
11033   cat conftest.$ac_ext >&5
11034   rm -rf conftest*
11035   glibcpp_cv_func_modfl_use=no
11036 fi
11037 rm -f conftest*
11038       ac_ext=c
11039 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11040 ac_cpp='$CPP $CPPFLAGS'
11041 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11042 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11043 cross_compiling=$ac_cv_prog_cc_cross
11044
11045
11046 fi
11047
11048   fi
11049   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
11050   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
11051     for ac_func in modfl
11052 do
11053 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11054 echo "configure:11055: checking for $ac_func" >&5
11055 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11056   echo $ac_n "(cached) $ac_c" 1>&6
11057 else
11058   cat > conftest.$ac_ext <<EOF
11059 #line 11060 "configure"
11060 #include "confdefs.h"
11061 /* System header to define __stub macros and hopefully few prototypes,
11062     which can conflict with char $ac_func(); below.  */
11063 #include <assert.h>
11064 /* Override any gcc2 internal prototype to avoid an error.  */
11065 /* We use char because int might match the return type of a gcc2
11066     builtin and then its argument prototype would still apply.  */
11067 char $ac_func();
11068
11069 int main() {
11070
11071 /* The GNU C library defines this for functions which it implements
11072     to always fail with ENOSYS.  Some functions are actually named
11073     something starting with __ and the normal name is an alias.  */
11074 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11075 choke me
11076 #else
11077 $ac_func();
11078 #endif
11079
11080 ; return 0; }
11081 EOF
11082 if { (eval echo configure:11083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11083   rm -rf conftest*
11084   eval "ac_cv_func_$ac_func=yes"
11085 else
11086   echo "configure: failed program was:" >&5
11087   cat conftest.$ac_ext >&5
11088   rm -rf conftest*
11089   eval "ac_cv_func_$ac_func=no"
11090 fi
11091 rm -f conftest*
11092 fi
11093
11094 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11095   echo "$ac_t""yes" 1>&6
11096     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11097   cat >> confdefs.h <<EOF
11098 #define $ac_tr_func 1
11099 EOF
11100
11101 else
11102   echo "$ac_t""no" 1>&6
11103 fi
11104 done
11105
11106   fi
11107
11108
11109   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
11110 echo "configure:11111: checking for powl declaration" >&5
11111   if test x${glibcpp_cv_func_powl_use+set} != xset; then
11112     if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
11113   echo $ac_n "(cached) $ac_c" 1>&6
11114 else
11115
11116
11117       ac_ext=C
11118 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11119 ac_cpp='$CXXCPP $CPPFLAGS'
11120 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11121 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11122 cross_compiling=$ac_cv_prog_cxx_cross
11123
11124       cat > conftest.$ac_ext <<EOF
11125 #line 11126 "configure"
11126 #include "confdefs.h"
11127 #include <math.h>
11128 int main() {
11129  powl(0, 0);
11130 ; return 0; }
11131 EOF
11132 if { (eval echo configure:11133: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11133   rm -rf conftest*
11134   glibcpp_cv_func_powl_use=yes
11135 else
11136   echo "configure: failed program was:" >&5
11137   cat conftest.$ac_ext >&5
11138   rm -rf conftest*
11139   glibcpp_cv_func_powl_use=no
11140 fi
11141 rm -f conftest*
11142       ac_ext=c
11143 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11144 ac_cpp='$CPP $CPPFLAGS'
11145 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11146 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11147 cross_compiling=$ac_cv_prog_cc_cross
11148
11149
11150 fi
11151
11152   fi
11153   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
11154   if test x$glibcpp_cv_func_powl_use = x"yes"; then
11155     for ac_func in powl
11156 do
11157 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11158 echo "configure:11159: checking for $ac_func" >&5
11159 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11160   echo $ac_n "(cached) $ac_c" 1>&6
11161 else
11162   cat > conftest.$ac_ext <<EOF
11163 #line 11164 "configure"
11164 #include "confdefs.h"
11165 /* System header to define __stub macros and hopefully few prototypes,
11166     which can conflict with char $ac_func(); below.  */
11167 #include <assert.h>
11168 /* Override any gcc2 internal prototype to avoid an error.  */
11169 /* We use char because int might match the return type of a gcc2
11170     builtin and then its argument prototype would still apply.  */
11171 char $ac_func();
11172
11173 int main() {
11174
11175 /* The GNU C library defines this for functions which it implements
11176     to always fail with ENOSYS.  Some functions are actually named
11177     something starting with __ and the normal name is an alias.  */
11178 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11179 choke me
11180 #else
11181 $ac_func();
11182 #endif
11183
11184 ; return 0; }
11185 EOF
11186 if { (eval echo configure:11187: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11187   rm -rf conftest*
11188   eval "ac_cv_func_$ac_func=yes"
11189 else
11190   echo "configure: failed program was:" >&5
11191   cat conftest.$ac_ext >&5
11192   rm -rf conftest*
11193   eval "ac_cv_func_$ac_func=no"
11194 fi
11195 rm -f conftest*
11196 fi
11197
11198 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11199   echo "$ac_t""yes" 1>&6
11200     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11201   cat >> confdefs.h <<EOF
11202 #define $ac_tr_func 1
11203 EOF
11204
11205 else
11206   echo "$ac_t""no" 1>&6
11207 fi
11208 done
11209
11210   fi
11211
11212
11213   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
11214 echo "configure:11215: checking for sinl declaration" >&5
11215   if test x${glibcpp_cv_func_sinl_use+set} != xset; then
11216     if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
11217   echo $ac_n "(cached) $ac_c" 1>&6
11218 else
11219
11220
11221       ac_ext=C
11222 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11223 ac_cpp='$CXXCPP $CPPFLAGS'
11224 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11225 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11226 cross_compiling=$ac_cv_prog_cxx_cross
11227
11228       cat > conftest.$ac_ext <<EOF
11229 #line 11230 "configure"
11230 #include "confdefs.h"
11231 #include <math.h>
11232 int main() {
11233  sinl(0);
11234 ; return 0; }
11235 EOF
11236 if { (eval echo configure:11237: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11237   rm -rf conftest*
11238   glibcpp_cv_func_sinl_use=yes
11239 else
11240   echo "configure: failed program was:" >&5
11241   cat conftest.$ac_ext >&5
11242   rm -rf conftest*
11243   glibcpp_cv_func_sinl_use=no
11244 fi
11245 rm -f conftest*
11246       ac_ext=c
11247 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11248 ac_cpp='$CPP $CPPFLAGS'
11249 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11250 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11251 cross_compiling=$ac_cv_prog_cc_cross
11252
11253
11254 fi
11255
11256   fi
11257   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
11258   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
11259     for ac_func in sinl
11260 do
11261 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11262 echo "configure:11263: checking for $ac_func" >&5
11263 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11264   echo $ac_n "(cached) $ac_c" 1>&6
11265 else
11266   cat > conftest.$ac_ext <<EOF
11267 #line 11268 "configure"
11268 #include "confdefs.h"
11269 /* System header to define __stub macros and hopefully few prototypes,
11270     which can conflict with char $ac_func(); below.  */
11271 #include <assert.h>
11272 /* Override any gcc2 internal prototype to avoid an error.  */
11273 /* We use char because int might match the return type of a gcc2
11274     builtin and then its argument prototype would still apply.  */
11275 char $ac_func();
11276
11277 int main() {
11278
11279 /* The GNU C library defines this for functions which it implements
11280     to always fail with ENOSYS.  Some functions are actually named
11281     something starting with __ and the normal name is an alias.  */
11282 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11283 choke me
11284 #else
11285 $ac_func();
11286 #endif
11287
11288 ; return 0; }
11289 EOF
11290 if { (eval echo configure:11291: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11291   rm -rf conftest*
11292   eval "ac_cv_func_$ac_func=yes"
11293 else
11294   echo "configure: failed program was:" >&5
11295   cat conftest.$ac_ext >&5
11296   rm -rf conftest*
11297   eval "ac_cv_func_$ac_func=no"
11298 fi
11299 rm -f conftest*
11300 fi
11301
11302 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11303   echo "$ac_t""yes" 1>&6
11304     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11305   cat >> confdefs.h <<EOF
11306 #define $ac_tr_func 1
11307 EOF
11308
11309 else
11310   echo "$ac_t""no" 1>&6
11311 fi
11312 done
11313
11314   fi
11315
11316
11317   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
11318 echo "configure:11319: checking for sinhl declaration" >&5
11319   if test x${glibcpp_cv_func_sinhl_use+set} != xset; then
11320     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
11321   echo $ac_n "(cached) $ac_c" 1>&6
11322 else
11323
11324
11325       ac_ext=C
11326 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11327 ac_cpp='$CXXCPP $CPPFLAGS'
11328 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11329 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11330 cross_compiling=$ac_cv_prog_cxx_cross
11331
11332       cat > conftest.$ac_ext <<EOF
11333 #line 11334 "configure"
11334 #include "confdefs.h"
11335 #include <math.h>
11336 int main() {
11337  sinhl(0);
11338 ; return 0; }
11339 EOF
11340 if { (eval echo configure:11341: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11341   rm -rf conftest*
11342   glibcpp_cv_func_sinhl_use=yes
11343 else
11344   echo "configure: failed program was:" >&5
11345   cat conftest.$ac_ext >&5
11346   rm -rf conftest*
11347   glibcpp_cv_func_sinhl_use=no
11348 fi
11349 rm -f conftest*
11350       ac_ext=c
11351 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11352 ac_cpp='$CPP $CPPFLAGS'
11353 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11354 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11355 cross_compiling=$ac_cv_prog_cc_cross
11356
11357
11358 fi
11359
11360   fi
11361   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
11362   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
11363     for ac_func in sinhl
11364 do
11365 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11366 echo "configure:11367: checking for $ac_func" >&5
11367 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11368   echo $ac_n "(cached) $ac_c" 1>&6
11369 else
11370   cat > conftest.$ac_ext <<EOF
11371 #line 11372 "configure"
11372 #include "confdefs.h"
11373 /* System header to define __stub macros and hopefully few prototypes,
11374     which can conflict with char $ac_func(); below.  */
11375 #include <assert.h>
11376 /* Override any gcc2 internal prototype to avoid an error.  */
11377 /* We use char because int might match the return type of a gcc2
11378     builtin and then its argument prototype would still apply.  */
11379 char $ac_func();
11380
11381 int main() {
11382
11383 /* The GNU C library defines this for functions which it implements
11384     to always fail with ENOSYS.  Some functions are actually named
11385     something starting with __ and the normal name is an alias.  */
11386 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11387 choke me
11388 #else
11389 $ac_func();
11390 #endif
11391
11392 ; return 0; }
11393 EOF
11394 if { (eval echo configure:11395: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11395   rm -rf conftest*
11396   eval "ac_cv_func_$ac_func=yes"
11397 else
11398   echo "configure: failed program was:" >&5
11399   cat conftest.$ac_ext >&5
11400   rm -rf conftest*
11401   eval "ac_cv_func_$ac_func=no"
11402 fi
11403 rm -f conftest*
11404 fi
11405
11406 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11407   echo "$ac_t""yes" 1>&6
11408     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11409   cat >> confdefs.h <<EOF
11410 #define $ac_tr_func 1
11411 EOF
11412
11413 else
11414   echo "$ac_t""no" 1>&6
11415 fi
11416 done
11417
11418   fi
11419
11420
11421   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
11422 echo "configure:11423: checking for sqrtl declaration" >&5
11423   if test x${glibcpp_cv_func_sqrtl_use+set} != xset; then
11424     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
11425   echo $ac_n "(cached) $ac_c" 1>&6
11426 else
11427
11428
11429       ac_ext=C
11430 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11431 ac_cpp='$CXXCPP $CPPFLAGS'
11432 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11433 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11434 cross_compiling=$ac_cv_prog_cxx_cross
11435
11436       cat > conftest.$ac_ext <<EOF
11437 #line 11438 "configure"
11438 #include "confdefs.h"
11439 #include <math.h>
11440 int main() {
11441  sqrtl(0);
11442 ; return 0; }
11443 EOF
11444 if { (eval echo configure:11445: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11445   rm -rf conftest*
11446   glibcpp_cv_func_sqrtl_use=yes
11447 else
11448   echo "configure: failed program was:" >&5
11449   cat conftest.$ac_ext >&5
11450   rm -rf conftest*
11451   glibcpp_cv_func_sqrtl_use=no
11452 fi
11453 rm -f conftest*
11454       ac_ext=c
11455 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11456 ac_cpp='$CPP $CPPFLAGS'
11457 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11458 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11459 cross_compiling=$ac_cv_prog_cc_cross
11460
11461
11462 fi
11463
11464   fi
11465   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
11466   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
11467     for ac_func in sqrtl
11468 do
11469 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11470 echo "configure:11471: checking for $ac_func" >&5
11471 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11472   echo $ac_n "(cached) $ac_c" 1>&6
11473 else
11474   cat > conftest.$ac_ext <<EOF
11475 #line 11476 "configure"
11476 #include "confdefs.h"
11477 /* System header to define __stub macros and hopefully few prototypes,
11478     which can conflict with char $ac_func(); below.  */
11479 #include <assert.h>
11480 /* Override any gcc2 internal prototype to avoid an error.  */
11481 /* We use char because int might match the return type of a gcc2
11482     builtin and then its argument prototype would still apply.  */
11483 char $ac_func();
11484
11485 int main() {
11486
11487 /* The GNU C library defines this for functions which it implements
11488     to always fail with ENOSYS.  Some functions are actually named
11489     something starting with __ and the normal name is an alias.  */
11490 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11491 choke me
11492 #else
11493 $ac_func();
11494 #endif
11495
11496 ; return 0; }
11497 EOF
11498 if { (eval echo configure:11499: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11499   rm -rf conftest*
11500   eval "ac_cv_func_$ac_func=yes"
11501 else
11502   echo "configure: failed program was:" >&5
11503   cat conftest.$ac_ext >&5
11504   rm -rf conftest*
11505   eval "ac_cv_func_$ac_func=no"
11506 fi
11507 rm -f conftest*
11508 fi
11509
11510 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11511   echo "$ac_t""yes" 1>&6
11512     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11513   cat >> confdefs.h <<EOF
11514 #define $ac_tr_func 1
11515 EOF
11516
11517 else
11518   echo "$ac_t""no" 1>&6
11519 fi
11520 done
11521
11522   fi
11523
11524
11525   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
11526 echo "configure:11527: checking for tanl declaration" >&5
11527   if test x${glibcpp_cv_func_tanl_use+set} != xset; then
11528     if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
11529   echo $ac_n "(cached) $ac_c" 1>&6
11530 else
11531
11532
11533       ac_ext=C
11534 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11535 ac_cpp='$CXXCPP $CPPFLAGS'
11536 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11537 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11538 cross_compiling=$ac_cv_prog_cxx_cross
11539
11540       cat > conftest.$ac_ext <<EOF
11541 #line 11542 "configure"
11542 #include "confdefs.h"
11543 #include <math.h>
11544 int main() {
11545  tanl(0);
11546 ; return 0; }
11547 EOF
11548 if { (eval echo configure:11549: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11549   rm -rf conftest*
11550   glibcpp_cv_func_tanl_use=yes
11551 else
11552   echo "configure: failed program was:" >&5
11553   cat conftest.$ac_ext >&5
11554   rm -rf conftest*
11555   glibcpp_cv_func_tanl_use=no
11556 fi
11557 rm -f conftest*
11558       ac_ext=c
11559 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11560 ac_cpp='$CPP $CPPFLAGS'
11561 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11562 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11563 cross_compiling=$ac_cv_prog_cc_cross
11564
11565
11566 fi
11567
11568   fi
11569   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
11570   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
11571     for ac_func in tanl
11572 do
11573 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11574 echo "configure:11575: checking for $ac_func" >&5
11575 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11576   echo $ac_n "(cached) $ac_c" 1>&6
11577 else
11578   cat > conftest.$ac_ext <<EOF
11579 #line 11580 "configure"
11580 #include "confdefs.h"
11581 /* System header to define __stub macros and hopefully few prototypes,
11582     which can conflict with char $ac_func(); below.  */
11583 #include <assert.h>
11584 /* Override any gcc2 internal prototype to avoid an error.  */
11585 /* We use char because int might match the return type of a gcc2
11586     builtin and then its argument prototype would still apply.  */
11587 char $ac_func();
11588
11589 int main() {
11590
11591 /* The GNU C library defines this for functions which it implements
11592     to always fail with ENOSYS.  Some functions are actually named
11593     something starting with __ and the normal name is an alias.  */
11594 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11595 choke me
11596 #else
11597 $ac_func();
11598 #endif
11599
11600 ; return 0; }
11601 EOF
11602 if { (eval echo configure:11603: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11603   rm -rf conftest*
11604   eval "ac_cv_func_$ac_func=yes"
11605 else
11606   echo "configure: failed program was:" >&5
11607   cat conftest.$ac_ext >&5
11608   rm -rf conftest*
11609   eval "ac_cv_func_$ac_func=no"
11610 fi
11611 rm -f conftest*
11612 fi
11613
11614 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11615   echo "$ac_t""yes" 1>&6
11616     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11617   cat >> confdefs.h <<EOF
11618 #define $ac_tr_func 1
11619 EOF
11620
11621 else
11622   echo "$ac_t""no" 1>&6
11623 fi
11624 done
11625
11626   fi
11627
11628
11629   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
11630 echo "configure:11631: checking for tanhl declaration" >&5
11631   if test x${glibcpp_cv_func_tanhl_use+set} != xset; then
11632     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
11633   echo $ac_n "(cached) $ac_c" 1>&6
11634 else
11635
11636
11637       ac_ext=C
11638 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11639 ac_cpp='$CXXCPP $CPPFLAGS'
11640 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11641 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11642 cross_compiling=$ac_cv_prog_cxx_cross
11643
11644       cat > conftest.$ac_ext <<EOF
11645 #line 11646 "configure"
11646 #include "confdefs.h"
11647 #include <math.h>
11648 int main() {
11649  tanhl(0);
11650 ; return 0; }
11651 EOF
11652 if { (eval echo configure:11653: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11653   rm -rf conftest*
11654   glibcpp_cv_func_tanhl_use=yes
11655 else
11656   echo "configure: failed program was:" >&5
11657   cat conftest.$ac_ext >&5
11658   rm -rf conftest*
11659   glibcpp_cv_func_tanhl_use=no
11660 fi
11661 rm -f conftest*
11662       ac_ext=c
11663 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11664 ac_cpp='$CPP $CPPFLAGS'
11665 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11666 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11667 cross_compiling=$ac_cv_prog_cc_cross
11668
11669
11670 fi
11671
11672   fi
11673   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
11674   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
11675     for ac_func in tanhl
11676 do
11677 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11678 echo "configure:11679: checking for $ac_func" >&5
11679 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11680   echo $ac_n "(cached) $ac_c" 1>&6
11681 else
11682   cat > conftest.$ac_ext <<EOF
11683 #line 11684 "configure"
11684 #include "confdefs.h"
11685 /* System header to define __stub macros and hopefully few prototypes,
11686     which can conflict with char $ac_func(); below.  */
11687 #include <assert.h>
11688 /* Override any gcc2 internal prototype to avoid an error.  */
11689 /* We use char because int might match the return type of a gcc2
11690     builtin and then its argument prototype would still apply.  */
11691 char $ac_func();
11692
11693 int main() {
11694
11695 /* The GNU C library defines this for functions which it implements
11696     to always fail with ENOSYS.  Some functions are actually named
11697     something starting with __ and the normal name is an alias.  */
11698 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11699 choke me
11700 #else
11701 $ac_func();
11702 #endif
11703
11704 ; return 0; }
11705 EOF
11706 if { (eval echo configure:11707: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11707   rm -rf conftest*
11708   eval "ac_cv_func_$ac_func=yes"
11709 else
11710   echo "configure: failed program was:" >&5
11711   cat conftest.$ac_ext >&5
11712   rm -rf conftest*
11713   eval "ac_cv_func_$ac_func=no"
11714 fi
11715 rm -f conftest*
11716 fi
11717
11718 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11719   echo "$ac_t""yes" 1>&6
11720     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11721   cat >> confdefs.h <<EOF
11722 #define $ac_tr_func 1
11723 EOF
11724
11725 else
11726   echo "$ac_t""no" 1>&6
11727 fi
11728 done
11729
11730   fi
11731
11732
11733   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
11734 echo "configure:11735: checking for sincosl declaration" >&5
11735   if test x${glibcpp_cv_func_sincosl_use+set} != xset; then
11736     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
11737   echo $ac_n "(cached) $ac_c" 1>&6
11738 else
11739
11740
11741       ac_ext=C
11742 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11743 ac_cpp='$CXXCPP $CPPFLAGS'
11744 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11745 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11746 cross_compiling=$ac_cv_prog_cxx_cross
11747
11748       cat > conftest.$ac_ext <<EOF
11749 #line 11750 "configure"
11750 #include "confdefs.h"
11751 #include <math.h>
11752 int main() {
11753  sincosl(0, 0, 0);
11754 ; return 0; }
11755 EOF
11756 if { (eval echo configure:11757: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11757   rm -rf conftest*
11758   glibcpp_cv_func_sincosl_use=yes
11759 else
11760   echo "configure: failed program was:" >&5
11761   cat conftest.$ac_ext >&5
11762   rm -rf conftest*
11763   glibcpp_cv_func_sincosl_use=no
11764 fi
11765 rm -f conftest*
11766       ac_ext=c
11767 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11768 ac_cpp='$CPP $CPPFLAGS'
11769 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11770 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11771 cross_compiling=$ac_cv_prog_cc_cross
11772
11773
11774 fi
11775
11776   fi
11777   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
11778   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
11779     for ac_func in sincosl
11780 do
11781 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11782 echo "configure:11783: checking for $ac_func" >&5
11783 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11784   echo $ac_n "(cached) $ac_c" 1>&6
11785 else
11786   cat > conftest.$ac_ext <<EOF
11787 #line 11788 "configure"
11788 #include "confdefs.h"
11789 /* System header to define __stub macros and hopefully few prototypes,
11790     which can conflict with char $ac_func(); below.  */
11791 #include <assert.h>
11792 /* Override any gcc2 internal prototype to avoid an error.  */
11793 /* We use char because int might match the return type of a gcc2
11794     builtin and then its argument prototype would still apply.  */
11795 char $ac_func();
11796
11797 int main() {
11798
11799 /* The GNU C library defines this for functions which it implements
11800     to always fail with ENOSYS.  Some functions are actually named
11801     something starting with __ and the normal name is an alias.  */
11802 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11803 choke me
11804 #else
11805 $ac_func();
11806 #endif
11807
11808 ; return 0; }
11809 EOF
11810 if { (eval echo configure:11811: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11811   rm -rf conftest*
11812   eval "ac_cv_func_$ac_func=yes"
11813 else
11814   echo "configure: failed program was:" >&5
11815   cat conftest.$ac_ext >&5
11816   rm -rf conftest*
11817   eval "ac_cv_func_$ac_func=no"
11818 fi
11819 rm -f conftest*
11820 fi
11821
11822 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11823   echo "$ac_t""yes" 1>&6
11824     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11825   cat >> confdefs.h <<EOF
11826 #define $ac_tr_func 1
11827 EOF
11828
11829 else
11830   echo "$ac_t""no" 1>&6
11831 fi
11832 done
11833
11834   fi
11835
11836
11837   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
11838 echo "configure:11839: checking for finitel declaration" >&5
11839   if test x${glibcpp_cv_func_finitel_use+set} != xset; then
11840     if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
11841   echo $ac_n "(cached) $ac_c" 1>&6
11842 else
11843
11844
11845       ac_ext=C
11846 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11847 ac_cpp='$CXXCPP $CPPFLAGS'
11848 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11849 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11850 cross_compiling=$ac_cv_prog_cxx_cross
11851
11852       cat > conftest.$ac_ext <<EOF
11853 #line 11854 "configure"
11854 #include "confdefs.h"
11855 #include <math.h>
11856 int main() {
11857  finitel(0);
11858 ; return 0; }
11859 EOF
11860 if { (eval echo configure:11861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11861   rm -rf conftest*
11862   glibcpp_cv_func_finitel_use=yes
11863 else
11864   echo "configure: failed program was:" >&5
11865   cat conftest.$ac_ext >&5
11866   rm -rf conftest*
11867   glibcpp_cv_func_finitel_use=no
11868 fi
11869 rm -f conftest*
11870       ac_ext=c
11871 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11872 ac_cpp='$CPP $CPPFLAGS'
11873 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11874 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11875 cross_compiling=$ac_cv_prog_cc_cross
11876
11877
11878 fi
11879
11880   fi
11881   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
11882   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
11883     for ac_func in finitel
11884 do
11885 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11886 echo "configure:11887: checking for $ac_func" >&5
11887 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11888   echo $ac_n "(cached) $ac_c" 1>&6
11889 else
11890   cat > conftest.$ac_ext <<EOF
11891 #line 11892 "configure"
11892 #include "confdefs.h"
11893 /* System header to define __stub macros and hopefully few prototypes,
11894     which can conflict with char $ac_func(); below.  */
11895 #include <assert.h>
11896 /* Override any gcc2 internal prototype to avoid an error.  */
11897 /* We use char because int might match the return type of a gcc2
11898     builtin and then its argument prototype would still apply.  */
11899 char $ac_func();
11900
11901 int main() {
11902
11903 /* The GNU C library defines this for functions which it implements
11904     to always fail with ENOSYS.  Some functions are actually named
11905     something starting with __ and the normal name is an alias.  */
11906 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11907 choke me
11908 #else
11909 $ac_func();
11910 #endif
11911
11912 ; return 0; }
11913 EOF
11914 if { (eval echo configure:11915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11915   rm -rf conftest*
11916   eval "ac_cv_func_$ac_func=yes"
11917 else
11918   echo "configure: failed program was:" >&5
11919   cat conftest.$ac_ext >&5
11920   rm -rf conftest*
11921   eval "ac_cv_func_$ac_func=no"
11922 fi
11923 rm -f conftest*
11924 fi
11925
11926 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11927   echo "$ac_t""yes" 1>&6
11928     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11929   cat >> confdefs.h <<EOF
11930 #define $ac_tr_func 1
11931 EOF
11932
11933 else
11934   echo "$ac_t""no" 1>&6
11935 fi
11936 done
11937
11938   fi
11939
11940
11941
11942   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
11943 echo "configure:11944: checking for _isinf declaration" >&5
11944   if test x${glibcpp_cv_func__isinf_use+set} != xset; then
11945     if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
11946   echo $ac_n "(cached) $ac_c" 1>&6
11947 else
11948
11949
11950       ac_ext=C
11951 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11952 ac_cpp='$CXXCPP $CPPFLAGS'
11953 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11954 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11955 cross_compiling=$ac_cv_prog_cxx_cross
11956
11957       cat > conftest.$ac_ext <<EOF
11958 #line 11959 "configure"
11959 #include "confdefs.h"
11960 #include <math.h>
11961 int main() {
11962  _isinf(0);
11963 ; return 0; }
11964 EOF
11965 if { (eval echo configure:11966: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11966   rm -rf conftest*
11967   glibcpp_cv_func__isinf_use=yes
11968 else
11969   echo "configure: failed program was:" >&5
11970   cat conftest.$ac_ext >&5
11971   rm -rf conftest*
11972   glibcpp_cv_func__isinf_use=no
11973 fi
11974 rm -f conftest*
11975       ac_ext=c
11976 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11977 ac_cpp='$CPP $CPPFLAGS'
11978 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11979 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11980 cross_compiling=$ac_cv_prog_cc_cross
11981
11982
11983 fi
11984
11985   fi
11986   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
11987   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
11988     for ac_func in _isinf
11989 do
11990 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11991 echo "configure:11992: checking for $ac_func" >&5
11992 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11993   echo $ac_n "(cached) $ac_c" 1>&6
11994 else
11995   cat > conftest.$ac_ext <<EOF
11996 #line 11997 "configure"
11997 #include "confdefs.h"
11998 /* System header to define __stub macros and hopefully few prototypes,
11999     which can conflict with char $ac_func(); below.  */
12000 #include <assert.h>
12001 /* Override any gcc2 internal prototype to avoid an error.  */
12002 /* We use char because int might match the return type of a gcc2
12003     builtin and then its argument prototype would still apply.  */
12004 char $ac_func();
12005
12006 int main() {
12007
12008 /* The GNU C library defines this for functions which it implements
12009     to always fail with ENOSYS.  Some functions are actually named
12010     something starting with __ and the normal name is an alias.  */
12011 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12012 choke me
12013 #else
12014 $ac_func();
12015 #endif
12016
12017 ; return 0; }
12018 EOF
12019 if { (eval echo configure:12020: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12020   rm -rf conftest*
12021   eval "ac_cv_func_$ac_func=yes"
12022 else
12023   echo "configure: failed program was:" >&5
12024   cat conftest.$ac_ext >&5
12025   rm -rf conftest*
12026   eval "ac_cv_func_$ac_func=no"
12027 fi
12028 rm -f conftest*
12029 fi
12030
12031 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12032   echo "$ac_t""yes" 1>&6
12033     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12034   cat >> confdefs.h <<EOF
12035 #define $ac_tr_func 1
12036 EOF
12037
12038 else
12039   echo "$ac_t""no" 1>&6
12040 fi
12041 done
12042
12043   fi
12044
12045
12046   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
12047 echo "configure:12048: checking for _isnan declaration" >&5
12048   if test x${glibcpp_cv_func__isnan_use+set} != xset; then
12049     if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
12050   echo $ac_n "(cached) $ac_c" 1>&6
12051 else
12052
12053
12054       ac_ext=C
12055 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12056 ac_cpp='$CXXCPP $CPPFLAGS'
12057 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12058 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12059 cross_compiling=$ac_cv_prog_cxx_cross
12060
12061       cat > conftest.$ac_ext <<EOF
12062 #line 12063 "configure"
12063 #include "confdefs.h"
12064 #include <math.h>
12065 int main() {
12066  _isnan(0);
12067 ; return 0; }
12068 EOF
12069 if { (eval echo configure:12070: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12070   rm -rf conftest*
12071   glibcpp_cv_func__isnan_use=yes
12072 else
12073   echo "configure: failed program was:" >&5
12074   cat conftest.$ac_ext >&5
12075   rm -rf conftest*
12076   glibcpp_cv_func__isnan_use=no
12077 fi
12078 rm -f conftest*
12079       ac_ext=c
12080 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12081 ac_cpp='$CPP $CPPFLAGS'
12082 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12083 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12084 cross_compiling=$ac_cv_prog_cc_cross
12085
12086
12087 fi
12088
12089   fi
12090   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
12091   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
12092     for ac_func in _isnan
12093 do
12094 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12095 echo "configure:12096: checking for $ac_func" >&5
12096 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12097   echo $ac_n "(cached) $ac_c" 1>&6
12098 else
12099   cat > conftest.$ac_ext <<EOF
12100 #line 12101 "configure"
12101 #include "confdefs.h"
12102 /* System header to define __stub macros and hopefully few prototypes,
12103     which can conflict with char $ac_func(); below.  */
12104 #include <assert.h>
12105 /* Override any gcc2 internal prototype to avoid an error.  */
12106 /* We use char because int might match the return type of a gcc2
12107     builtin and then its argument prototype would still apply.  */
12108 char $ac_func();
12109
12110 int main() {
12111
12112 /* The GNU C library defines this for functions which it implements
12113     to always fail with ENOSYS.  Some functions are actually named
12114     something starting with __ and the normal name is an alias.  */
12115 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12116 choke me
12117 #else
12118 $ac_func();
12119 #endif
12120
12121 ; return 0; }
12122 EOF
12123 if { (eval echo configure:12124: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12124   rm -rf conftest*
12125   eval "ac_cv_func_$ac_func=yes"
12126 else
12127   echo "configure: failed program was:" >&5
12128   cat conftest.$ac_ext >&5
12129   rm -rf conftest*
12130   eval "ac_cv_func_$ac_func=no"
12131 fi
12132 rm -f conftest*
12133 fi
12134
12135 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12136   echo "$ac_t""yes" 1>&6
12137     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12138   cat >> confdefs.h <<EOF
12139 #define $ac_tr_func 1
12140 EOF
12141
12142 else
12143   echo "$ac_t""no" 1>&6
12144 fi
12145 done
12146
12147   fi
12148
12149
12150   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
12151 echo "configure:12152: checking for _finite declaration" >&5
12152   if test x${glibcpp_cv_func__finite_use+set} != xset; then
12153     if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
12154   echo $ac_n "(cached) $ac_c" 1>&6
12155 else
12156
12157
12158       ac_ext=C
12159 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12160 ac_cpp='$CXXCPP $CPPFLAGS'
12161 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12162 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12163 cross_compiling=$ac_cv_prog_cxx_cross
12164
12165       cat > conftest.$ac_ext <<EOF
12166 #line 12167 "configure"
12167 #include "confdefs.h"
12168 #include <math.h>
12169 int main() {
12170  _finite(0);
12171 ; return 0; }
12172 EOF
12173 if { (eval echo configure:12174: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12174   rm -rf conftest*
12175   glibcpp_cv_func__finite_use=yes
12176 else
12177   echo "configure: failed program was:" >&5
12178   cat conftest.$ac_ext >&5
12179   rm -rf conftest*
12180   glibcpp_cv_func__finite_use=no
12181 fi
12182 rm -f conftest*
12183       ac_ext=c
12184 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12185 ac_cpp='$CPP $CPPFLAGS'
12186 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12187 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12188 cross_compiling=$ac_cv_prog_cc_cross
12189
12190
12191 fi
12192
12193   fi
12194   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
12195   if test x$glibcpp_cv_func__finite_use = x"yes"; then
12196     for ac_func in _finite
12197 do
12198 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12199 echo "configure:12200: checking for $ac_func" >&5
12200 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12201   echo $ac_n "(cached) $ac_c" 1>&6
12202 else
12203   cat > conftest.$ac_ext <<EOF
12204 #line 12205 "configure"
12205 #include "confdefs.h"
12206 /* System header to define __stub macros and hopefully few prototypes,
12207     which can conflict with char $ac_func(); below.  */
12208 #include <assert.h>
12209 /* Override any gcc2 internal prototype to avoid an error.  */
12210 /* We use char because int might match the return type of a gcc2
12211     builtin and then its argument prototype would still apply.  */
12212 char $ac_func();
12213
12214 int main() {
12215
12216 /* The GNU C library defines this for functions which it implements
12217     to always fail with ENOSYS.  Some functions are actually named
12218     something starting with __ and the normal name is an alias.  */
12219 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12220 choke me
12221 #else
12222 $ac_func();
12223 #endif
12224
12225 ; return 0; }
12226 EOF
12227 if { (eval echo configure:12228: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12228   rm -rf conftest*
12229   eval "ac_cv_func_$ac_func=yes"
12230 else
12231   echo "configure: failed program was:" >&5
12232   cat conftest.$ac_ext >&5
12233   rm -rf conftest*
12234   eval "ac_cv_func_$ac_func=no"
12235 fi
12236 rm -f conftest*
12237 fi
12238
12239 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12240   echo "$ac_t""yes" 1>&6
12241     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12242   cat >> confdefs.h <<EOF
12243 #define $ac_tr_func 1
12244 EOF
12245
12246 else
12247   echo "$ac_t""no" 1>&6
12248 fi
12249 done
12250
12251   fi
12252
12253
12254   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
12255 echo "configure:12256: checking for _copysign declaration" >&5
12256   if test x${glibcpp_cv_func__copysign_use+set} != xset; then
12257     if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
12258   echo $ac_n "(cached) $ac_c" 1>&6
12259 else
12260
12261
12262       ac_ext=C
12263 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12264 ac_cpp='$CXXCPP $CPPFLAGS'
12265 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12266 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12267 cross_compiling=$ac_cv_prog_cxx_cross
12268
12269       cat > conftest.$ac_ext <<EOF
12270 #line 12271 "configure"
12271 #include "confdefs.h"
12272 #include <math.h>
12273 int main() {
12274  _copysign(0, 0);
12275 ; return 0; }
12276 EOF
12277 if { (eval echo configure:12278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12278   rm -rf conftest*
12279   glibcpp_cv_func__copysign_use=yes
12280 else
12281   echo "configure: failed program was:" >&5
12282   cat conftest.$ac_ext >&5
12283   rm -rf conftest*
12284   glibcpp_cv_func__copysign_use=no
12285 fi
12286 rm -f conftest*
12287       ac_ext=c
12288 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12289 ac_cpp='$CPP $CPPFLAGS'
12290 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12291 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12292 cross_compiling=$ac_cv_prog_cc_cross
12293
12294
12295 fi
12296
12297   fi
12298   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
12299   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
12300     for ac_func in _copysign
12301 do
12302 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12303 echo "configure:12304: checking for $ac_func" >&5
12304 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12305   echo $ac_n "(cached) $ac_c" 1>&6
12306 else
12307   cat > conftest.$ac_ext <<EOF
12308 #line 12309 "configure"
12309 #include "confdefs.h"
12310 /* System header to define __stub macros and hopefully few prototypes,
12311     which can conflict with char $ac_func(); below.  */
12312 #include <assert.h>
12313 /* Override any gcc2 internal prototype to avoid an error.  */
12314 /* We use char because int might match the return type of a gcc2
12315     builtin and then its argument prototype would still apply.  */
12316 char $ac_func();
12317
12318 int main() {
12319
12320 /* The GNU C library defines this for functions which it implements
12321     to always fail with ENOSYS.  Some functions are actually named
12322     something starting with __ and the normal name is an alias.  */
12323 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12324 choke me
12325 #else
12326 $ac_func();
12327 #endif
12328
12329 ; return 0; }
12330 EOF
12331 if { (eval echo configure:12332: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12332   rm -rf conftest*
12333   eval "ac_cv_func_$ac_func=yes"
12334 else
12335   echo "configure: failed program was:" >&5
12336   cat conftest.$ac_ext >&5
12337   rm -rf conftest*
12338   eval "ac_cv_func_$ac_func=no"
12339 fi
12340 rm -f conftest*
12341 fi
12342
12343 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12344   echo "$ac_t""yes" 1>&6
12345     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12346   cat >> confdefs.h <<EOF
12347 #define $ac_tr_func 1
12348 EOF
12349
12350 else
12351   echo "$ac_t""no" 1>&6
12352 fi
12353 done
12354
12355   fi
12356
12357
12358   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
12359 echo "configure:12360: checking for _sincos declaration" >&5
12360   if test x${glibcpp_cv_func__sincos_use+set} != xset; then
12361     if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
12362   echo $ac_n "(cached) $ac_c" 1>&6
12363 else
12364
12365
12366       ac_ext=C
12367 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12368 ac_cpp='$CXXCPP $CPPFLAGS'
12369 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12370 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12371 cross_compiling=$ac_cv_prog_cxx_cross
12372
12373       cat > conftest.$ac_ext <<EOF
12374 #line 12375 "configure"
12375 #include "confdefs.h"
12376 #include <math.h>
12377 int main() {
12378  _sincos(0, 0, 0);
12379 ; return 0; }
12380 EOF
12381 if { (eval echo configure:12382: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12382   rm -rf conftest*
12383   glibcpp_cv_func__sincos_use=yes
12384 else
12385   echo "configure: failed program was:" >&5
12386   cat conftest.$ac_ext >&5
12387   rm -rf conftest*
12388   glibcpp_cv_func__sincos_use=no
12389 fi
12390 rm -f conftest*
12391       ac_ext=c
12392 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12393 ac_cpp='$CPP $CPPFLAGS'
12394 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12395 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12396 cross_compiling=$ac_cv_prog_cc_cross
12397
12398
12399 fi
12400
12401   fi
12402   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
12403   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
12404     for ac_func in _sincos
12405 do
12406 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12407 echo "configure:12408: checking for $ac_func" >&5
12408 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12409   echo $ac_n "(cached) $ac_c" 1>&6
12410 else
12411   cat > conftest.$ac_ext <<EOF
12412 #line 12413 "configure"
12413 #include "confdefs.h"
12414 /* System header to define __stub macros and hopefully few prototypes,
12415     which can conflict with char $ac_func(); below.  */
12416 #include <assert.h>
12417 /* Override any gcc2 internal prototype to avoid an error.  */
12418 /* We use char because int might match the return type of a gcc2
12419     builtin and then its argument prototype would still apply.  */
12420 char $ac_func();
12421
12422 int main() {
12423
12424 /* The GNU C library defines this for functions which it implements
12425     to always fail with ENOSYS.  Some functions are actually named
12426     something starting with __ and the normal name is an alias.  */
12427 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12428 choke me
12429 #else
12430 $ac_func();
12431 #endif
12432
12433 ; return 0; }
12434 EOF
12435 if { (eval echo configure:12436: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12436   rm -rf conftest*
12437   eval "ac_cv_func_$ac_func=yes"
12438 else
12439   echo "configure: failed program was:" >&5
12440   cat conftest.$ac_ext >&5
12441   rm -rf conftest*
12442   eval "ac_cv_func_$ac_func=no"
12443 fi
12444 rm -f conftest*
12445 fi
12446
12447 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12448   echo "$ac_t""yes" 1>&6
12449     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12450   cat >> confdefs.h <<EOF
12451 #define $ac_tr_func 1
12452 EOF
12453
12454 else
12455   echo "$ac_t""no" 1>&6
12456 fi
12457 done
12458
12459   fi
12460
12461
12462   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
12463 echo "configure:12464: checking for _fpclass declaration" >&5
12464   if test x${glibcpp_cv_func__fpclass_use+set} != xset; then
12465     if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
12466   echo $ac_n "(cached) $ac_c" 1>&6
12467 else
12468
12469
12470       ac_ext=C
12471 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12472 ac_cpp='$CXXCPP $CPPFLAGS'
12473 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12474 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12475 cross_compiling=$ac_cv_prog_cxx_cross
12476
12477       cat > conftest.$ac_ext <<EOF
12478 #line 12479 "configure"
12479 #include "confdefs.h"
12480 #include <math.h>
12481 int main() {
12482  _fpclass(0);
12483 ; return 0; }
12484 EOF
12485 if { (eval echo configure:12486: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12486   rm -rf conftest*
12487   glibcpp_cv_func__fpclass_use=yes
12488 else
12489   echo "configure: failed program was:" >&5
12490   cat conftest.$ac_ext >&5
12491   rm -rf conftest*
12492   glibcpp_cv_func__fpclass_use=no
12493 fi
12494 rm -f conftest*
12495       ac_ext=c
12496 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12497 ac_cpp='$CPP $CPPFLAGS'
12498 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12499 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12500 cross_compiling=$ac_cv_prog_cc_cross
12501
12502
12503 fi
12504
12505   fi
12506   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
12507   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
12508     for ac_func in _fpclass
12509 do
12510 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12511 echo "configure:12512: checking for $ac_func" >&5
12512 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12513   echo $ac_n "(cached) $ac_c" 1>&6
12514 else
12515   cat > conftest.$ac_ext <<EOF
12516 #line 12517 "configure"
12517 #include "confdefs.h"
12518 /* System header to define __stub macros and hopefully few prototypes,
12519     which can conflict with char $ac_func(); below.  */
12520 #include <assert.h>
12521 /* Override any gcc2 internal prototype to avoid an error.  */
12522 /* We use char because int might match the return type of a gcc2
12523     builtin and then its argument prototype would still apply.  */
12524 char $ac_func();
12525
12526 int main() {
12527
12528 /* The GNU C library defines this for functions which it implements
12529     to always fail with ENOSYS.  Some functions are actually named
12530     something starting with __ and the normal name is an alias.  */
12531 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12532 choke me
12533 #else
12534 $ac_func();
12535 #endif
12536
12537 ; return 0; }
12538 EOF
12539 if { (eval echo configure:12540: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12540   rm -rf conftest*
12541   eval "ac_cv_func_$ac_func=yes"
12542 else
12543   echo "configure: failed program was:" >&5
12544   cat conftest.$ac_ext >&5
12545   rm -rf conftest*
12546   eval "ac_cv_func_$ac_func=no"
12547 fi
12548 rm -f conftest*
12549 fi
12550
12551 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12552   echo "$ac_t""yes" 1>&6
12553     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12554   cat >> confdefs.h <<EOF
12555 #define $ac_tr_func 1
12556 EOF
12557
12558 else
12559   echo "$ac_t""no" 1>&6
12560 fi
12561 done
12562
12563   fi
12564
12565
12566   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
12567 echo "configure:12568: checking for _qfpclass declaration" >&5
12568   if test x${glibcpp_cv_func__qfpclass_use+set} != xset; then
12569     if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
12570   echo $ac_n "(cached) $ac_c" 1>&6
12571 else
12572
12573
12574       ac_ext=C
12575 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12576 ac_cpp='$CXXCPP $CPPFLAGS'
12577 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12578 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12579 cross_compiling=$ac_cv_prog_cxx_cross
12580
12581       cat > conftest.$ac_ext <<EOF
12582 #line 12583 "configure"
12583 #include "confdefs.h"
12584 #include <math.h>
12585 int main() {
12586  _qfpclass(0);
12587 ; return 0; }
12588 EOF
12589 if { (eval echo configure:12590: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12590   rm -rf conftest*
12591   glibcpp_cv_func__qfpclass_use=yes
12592 else
12593   echo "configure: failed program was:" >&5
12594   cat conftest.$ac_ext >&5
12595   rm -rf conftest*
12596   glibcpp_cv_func__qfpclass_use=no
12597 fi
12598 rm -f conftest*
12599       ac_ext=c
12600 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12601 ac_cpp='$CPP $CPPFLAGS'
12602 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12603 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12604 cross_compiling=$ac_cv_prog_cc_cross
12605
12606
12607 fi
12608
12609   fi
12610   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
12611   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
12612     for ac_func in _qfpclass
12613 do
12614 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12615 echo "configure:12616: checking for $ac_func" >&5
12616 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12617   echo $ac_n "(cached) $ac_c" 1>&6
12618 else
12619   cat > conftest.$ac_ext <<EOF
12620 #line 12621 "configure"
12621 #include "confdefs.h"
12622 /* System header to define __stub macros and hopefully few prototypes,
12623     which can conflict with char $ac_func(); below.  */
12624 #include <assert.h>
12625 /* Override any gcc2 internal prototype to avoid an error.  */
12626 /* We use char because int might match the return type of a gcc2
12627     builtin and then its argument prototype would still apply.  */
12628 char $ac_func();
12629
12630 int main() {
12631
12632 /* The GNU C library defines this for functions which it implements
12633     to always fail with ENOSYS.  Some functions are actually named
12634     something starting with __ and the normal name is an alias.  */
12635 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12636 choke me
12637 #else
12638 $ac_func();
12639 #endif
12640
12641 ; return 0; }
12642 EOF
12643 if { (eval echo configure:12644: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12644   rm -rf conftest*
12645   eval "ac_cv_func_$ac_func=yes"
12646 else
12647   echo "configure: failed program was:" >&5
12648   cat conftest.$ac_ext >&5
12649   rm -rf conftest*
12650   eval "ac_cv_func_$ac_func=no"
12651 fi
12652 rm -f conftest*
12653 fi
12654
12655 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12656   echo "$ac_t""yes" 1>&6
12657     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12658   cat >> confdefs.h <<EOF
12659 #define $ac_tr_func 1
12660 EOF
12661
12662 else
12663   echo "$ac_t""no" 1>&6
12664 fi
12665 done
12666
12667   fi
12668
12669
12670
12671   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
12672 echo "configure:12673: checking for _isnanf declaration" >&5
12673   if test x${glibcpp_cv_func__isnanf_use+set} != xset; then
12674     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
12675   echo $ac_n "(cached) $ac_c" 1>&6
12676 else
12677
12678
12679       ac_ext=C
12680 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12681 ac_cpp='$CXXCPP $CPPFLAGS'
12682 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12683 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12684 cross_compiling=$ac_cv_prog_cxx_cross
12685
12686       cat > conftest.$ac_ext <<EOF
12687 #line 12688 "configure"
12688 #include "confdefs.h"
12689 #include <math.h>
12690 int main() {
12691  _isnanf(0);
12692 ; return 0; }
12693 EOF
12694 if { (eval echo configure:12695: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12695   rm -rf conftest*
12696   glibcpp_cv_func__isnanf_use=yes
12697 else
12698   echo "configure: failed program was:" >&5
12699   cat conftest.$ac_ext >&5
12700   rm -rf conftest*
12701   glibcpp_cv_func__isnanf_use=no
12702 fi
12703 rm -f conftest*
12704       ac_ext=c
12705 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12706 ac_cpp='$CPP $CPPFLAGS'
12707 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12708 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12709 cross_compiling=$ac_cv_prog_cc_cross
12710
12711
12712 fi
12713
12714   fi
12715   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
12716   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
12717     for ac_func in _isnanf
12718 do
12719 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12720 echo "configure:12721: checking for $ac_func" >&5
12721 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12722   echo $ac_n "(cached) $ac_c" 1>&6
12723 else
12724   cat > conftest.$ac_ext <<EOF
12725 #line 12726 "configure"
12726 #include "confdefs.h"
12727 /* System header to define __stub macros and hopefully few prototypes,
12728     which can conflict with char $ac_func(); below.  */
12729 #include <assert.h>
12730 /* Override any gcc2 internal prototype to avoid an error.  */
12731 /* We use char because int might match the return type of a gcc2
12732     builtin and then its argument prototype would still apply.  */
12733 char $ac_func();
12734
12735 int main() {
12736
12737 /* The GNU C library defines this for functions which it implements
12738     to always fail with ENOSYS.  Some functions are actually named
12739     something starting with __ and the normal name is an alias.  */
12740 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12741 choke me
12742 #else
12743 $ac_func();
12744 #endif
12745
12746 ; return 0; }
12747 EOF
12748 if { (eval echo configure:12749: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12749   rm -rf conftest*
12750   eval "ac_cv_func_$ac_func=yes"
12751 else
12752   echo "configure: failed program was:" >&5
12753   cat conftest.$ac_ext >&5
12754   rm -rf conftest*
12755   eval "ac_cv_func_$ac_func=no"
12756 fi
12757 rm -f conftest*
12758 fi
12759
12760 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12761   echo "$ac_t""yes" 1>&6
12762     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12763   cat >> confdefs.h <<EOF
12764 #define $ac_tr_func 1
12765 EOF
12766
12767 else
12768   echo "$ac_t""no" 1>&6
12769 fi
12770 done
12771
12772   fi
12773
12774
12775   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
12776 echo "configure:12777: checking for _isinff declaration" >&5
12777   if test x${glibcpp_cv_func__isinff_use+set} != xset; then
12778     if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
12779   echo $ac_n "(cached) $ac_c" 1>&6
12780 else
12781
12782
12783       ac_ext=C
12784 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12785 ac_cpp='$CXXCPP $CPPFLAGS'
12786 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12787 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12788 cross_compiling=$ac_cv_prog_cxx_cross
12789
12790       cat > conftest.$ac_ext <<EOF
12791 #line 12792 "configure"
12792 #include "confdefs.h"
12793 #include <math.h>
12794 int main() {
12795  _isinff(0);
12796 ; return 0; }
12797 EOF
12798 if { (eval echo configure:12799: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12799   rm -rf conftest*
12800   glibcpp_cv_func__isinff_use=yes
12801 else
12802   echo "configure: failed program was:" >&5
12803   cat conftest.$ac_ext >&5
12804   rm -rf conftest*
12805   glibcpp_cv_func__isinff_use=no
12806 fi
12807 rm -f conftest*
12808       ac_ext=c
12809 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12810 ac_cpp='$CPP $CPPFLAGS'
12811 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12812 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12813 cross_compiling=$ac_cv_prog_cc_cross
12814
12815
12816 fi
12817
12818   fi
12819   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
12820   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
12821     for ac_func in _isinff
12822 do
12823 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12824 echo "configure:12825: checking for $ac_func" >&5
12825 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12826   echo $ac_n "(cached) $ac_c" 1>&6
12827 else
12828   cat > conftest.$ac_ext <<EOF
12829 #line 12830 "configure"
12830 #include "confdefs.h"
12831 /* System header to define __stub macros and hopefully few prototypes,
12832     which can conflict with char $ac_func(); below.  */
12833 #include <assert.h>
12834 /* Override any gcc2 internal prototype to avoid an error.  */
12835 /* We use char because int might match the return type of a gcc2
12836     builtin and then its argument prototype would still apply.  */
12837 char $ac_func();
12838
12839 int main() {
12840
12841 /* The GNU C library defines this for functions which it implements
12842     to always fail with ENOSYS.  Some functions are actually named
12843     something starting with __ and the normal name is an alias.  */
12844 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12845 choke me
12846 #else
12847 $ac_func();
12848 #endif
12849
12850 ; return 0; }
12851 EOF
12852 if { (eval echo configure:12853: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12853   rm -rf conftest*
12854   eval "ac_cv_func_$ac_func=yes"
12855 else
12856   echo "configure: failed program was:" >&5
12857   cat conftest.$ac_ext >&5
12858   rm -rf conftest*
12859   eval "ac_cv_func_$ac_func=no"
12860 fi
12861 rm -f conftest*
12862 fi
12863
12864 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12865   echo "$ac_t""yes" 1>&6
12866     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12867   cat >> confdefs.h <<EOF
12868 #define $ac_tr_func 1
12869 EOF
12870
12871 else
12872   echo "$ac_t""no" 1>&6
12873 fi
12874 done
12875
12876   fi
12877
12878
12879   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
12880 echo "configure:12881: checking for _acosf declaration" >&5
12881   if test x${glibcpp_cv_func__acosf_use+set} != xset; then
12882     if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
12883   echo $ac_n "(cached) $ac_c" 1>&6
12884 else
12885
12886
12887       ac_ext=C
12888 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12889 ac_cpp='$CXXCPP $CPPFLAGS'
12890 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12891 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12892 cross_compiling=$ac_cv_prog_cxx_cross
12893
12894       cat > conftest.$ac_ext <<EOF
12895 #line 12896 "configure"
12896 #include "confdefs.h"
12897 #include <math.h>
12898 int main() {
12899  _acosf(0);
12900 ; return 0; }
12901 EOF
12902 if { (eval echo configure:12903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12903   rm -rf conftest*
12904   glibcpp_cv_func__acosf_use=yes
12905 else
12906   echo "configure: failed program was:" >&5
12907   cat conftest.$ac_ext >&5
12908   rm -rf conftest*
12909   glibcpp_cv_func__acosf_use=no
12910 fi
12911 rm -f conftest*
12912       ac_ext=c
12913 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12914 ac_cpp='$CPP $CPPFLAGS'
12915 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12916 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12917 cross_compiling=$ac_cv_prog_cc_cross
12918
12919
12920 fi
12921
12922   fi
12923   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
12924   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
12925     for ac_func in _acosf
12926 do
12927 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12928 echo "configure:12929: checking for $ac_func" >&5
12929 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12930   echo $ac_n "(cached) $ac_c" 1>&6
12931 else
12932   cat > conftest.$ac_ext <<EOF
12933 #line 12934 "configure"
12934 #include "confdefs.h"
12935 /* System header to define __stub macros and hopefully few prototypes,
12936     which can conflict with char $ac_func(); below.  */
12937 #include <assert.h>
12938 /* Override any gcc2 internal prototype to avoid an error.  */
12939 /* We use char because int might match the return type of a gcc2
12940     builtin and then its argument prototype would still apply.  */
12941 char $ac_func();
12942
12943 int main() {
12944
12945 /* The GNU C library defines this for functions which it implements
12946     to always fail with ENOSYS.  Some functions are actually named
12947     something starting with __ and the normal name is an alias.  */
12948 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12949 choke me
12950 #else
12951 $ac_func();
12952 #endif
12953
12954 ; return 0; }
12955 EOF
12956 if { (eval echo configure:12957: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12957   rm -rf conftest*
12958   eval "ac_cv_func_$ac_func=yes"
12959 else
12960   echo "configure: failed program was:" >&5
12961   cat conftest.$ac_ext >&5
12962   rm -rf conftest*
12963   eval "ac_cv_func_$ac_func=no"
12964 fi
12965 rm -f conftest*
12966 fi
12967
12968 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12969   echo "$ac_t""yes" 1>&6
12970     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12971   cat >> confdefs.h <<EOF
12972 #define $ac_tr_func 1
12973 EOF
12974
12975 else
12976   echo "$ac_t""no" 1>&6
12977 fi
12978 done
12979
12980   fi
12981
12982
12983   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
12984 echo "configure:12985: checking for _asinf declaration" >&5
12985   if test x${glibcpp_cv_func__asinf_use+set} != xset; then
12986     if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
12987   echo $ac_n "(cached) $ac_c" 1>&6
12988 else
12989
12990
12991       ac_ext=C
12992 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12993 ac_cpp='$CXXCPP $CPPFLAGS'
12994 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12995 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12996 cross_compiling=$ac_cv_prog_cxx_cross
12997
12998       cat > conftest.$ac_ext <<EOF
12999 #line 13000 "configure"
13000 #include "confdefs.h"
13001 #include <math.h>
13002 int main() {
13003  _asinf(0);
13004 ; return 0; }
13005 EOF
13006 if { (eval echo configure:13007: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13007   rm -rf conftest*
13008   glibcpp_cv_func__asinf_use=yes
13009 else
13010   echo "configure: failed program was:" >&5
13011   cat conftest.$ac_ext >&5
13012   rm -rf conftest*
13013   glibcpp_cv_func__asinf_use=no
13014 fi
13015 rm -f conftest*
13016       ac_ext=c
13017 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13018 ac_cpp='$CPP $CPPFLAGS'
13019 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13020 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13021 cross_compiling=$ac_cv_prog_cc_cross
13022
13023
13024 fi
13025
13026   fi
13027   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
13028   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
13029     for ac_func in _asinf
13030 do
13031 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13032 echo "configure:13033: checking for $ac_func" >&5
13033 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13034   echo $ac_n "(cached) $ac_c" 1>&6
13035 else
13036   cat > conftest.$ac_ext <<EOF
13037 #line 13038 "configure"
13038 #include "confdefs.h"
13039 /* System header to define __stub macros and hopefully few prototypes,
13040     which can conflict with char $ac_func(); below.  */
13041 #include <assert.h>
13042 /* Override any gcc2 internal prototype to avoid an error.  */
13043 /* We use char because int might match the return type of a gcc2
13044     builtin and then its argument prototype would still apply.  */
13045 char $ac_func();
13046
13047 int main() {
13048
13049 /* The GNU C library defines this for functions which it implements
13050     to always fail with ENOSYS.  Some functions are actually named
13051     something starting with __ and the normal name is an alias.  */
13052 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13053 choke me
13054 #else
13055 $ac_func();
13056 #endif
13057
13058 ; return 0; }
13059 EOF
13060 if { (eval echo configure:13061: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13061   rm -rf conftest*
13062   eval "ac_cv_func_$ac_func=yes"
13063 else
13064   echo "configure: failed program was:" >&5
13065   cat conftest.$ac_ext >&5
13066   rm -rf conftest*
13067   eval "ac_cv_func_$ac_func=no"
13068 fi
13069 rm -f conftest*
13070 fi
13071
13072 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13073   echo "$ac_t""yes" 1>&6
13074     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13075   cat >> confdefs.h <<EOF
13076 #define $ac_tr_func 1
13077 EOF
13078
13079 else
13080   echo "$ac_t""no" 1>&6
13081 fi
13082 done
13083
13084   fi
13085
13086
13087   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
13088 echo "configure:13089: checking for _atanf declaration" >&5
13089   if test x${glibcpp_cv_func__atanf_use+set} != xset; then
13090     if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
13091   echo $ac_n "(cached) $ac_c" 1>&6
13092 else
13093
13094
13095       ac_ext=C
13096 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13097 ac_cpp='$CXXCPP $CPPFLAGS'
13098 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13099 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13100 cross_compiling=$ac_cv_prog_cxx_cross
13101
13102       cat > conftest.$ac_ext <<EOF
13103 #line 13104 "configure"
13104 #include "confdefs.h"
13105 #include <math.h>
13106 int main() {
13107  _atanf(0);
13108 ; return 0; }
13109 EOF
13110 if { (eval echo configure:13111: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13111   rm -rf conftest*
13112   glibcpp_cv_func__atanf_use=yes
13113 else
13114   echo "configure: failed program was:" >&5
13115   cat conftest.$ac_ext >&5
13116   rm -rf conftest*
13117   glibcpp_cv_func__atanf_use=no
13118 fi
13119 rm -f conftest*
13120       ac_ext=c
13121 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13122 ac_cpp='$CPP $CPPFLAGS'
13123 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13124 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13125 cross_compiling=$ac_cv_prog_cc_cross
13126
13127
13128 fi
13129
13130   fi
13131   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
13132   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
13133     for ac_func in _atanf
13134 do
13135 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13136 echo "configure:13137: checking for $ac_func" >&5
13137 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13138   echo $ac_n "(cached) $ac_c" 1>&6
13139 else
13140   cat > conftest.$ac_ext <<EOF
13141 #line 13142 "configure"
13142 #include "confdefs.h"
13143 /* System header to define __stub macros and hopefully few prototypes,
13144     which can conflict with char $ac_func(); below.  */
13145 #include <assert.h>
13146 /* Override any gcc2 internal prototype to avoid an error.  */
13147 /* We use char because int might match the return type of a gcc2
13148     builtin and then its argument prototype would still apply.  */
13149 char $ac_func();
13150
13151 int main() {
13152
13153 /* The GNU C library defines this for functions which it implements
13154     to always fail with ENOSYS.  Some functions are actually named
13155     something starting with __ and the normal name is an alias.  */
13156 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13157 choke me
13158 #else
13159 $ac_func();
13160 #endif
13161
13162 ; return 0; }
13163 EOF
13164 if { (eval echo configure:13165: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13165   rm -rf conftest*
13166   eval "ac_cv_func_$ac_func=yes"
13167 else
13168   echo "configure: failed program was:" >&5
13169   cat conftest.$ac_ext >&5
13170   rm -rf conftest*
13171   eval "ac_cv_func_$ac_func=no"
13172 fi
13173 rm -f conftest*
13174 fi
13175
13176 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13177   echo "$ac_t""yes" 1>&6
13178     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13179   cat >> confdefs.h <<EOF
13180 #define $ac_tr_func 1
13181 EOF
13182
13183 else
13184   echo "$ac_t""no" 1>&6
13185 fi
13186 done
13187
13188   fi
13189
13190
13191   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
13192 echo "configure:13193: checking for _ceilf declaration" >&5
13193   if test x${glibcpp_cv_func__ceilf_use+set} != xset; then
13194     if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
13195   echo $ac_n "(cached) $ac_c" 1>&6
13196 else
13197
13198
13199       ac_ext=C
13200 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13201 ac_cpp='$CXXCPP $CPPFLAGS'
13202 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13203 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13204 cross_compiling=$ac_cv_prog_cxx_cross
13205
13206       cat > conftest.$ac_ext <<EOF
13207 #line 13208 "configure"
13208 #include "confdefs.h"
13209 #include <math.h>
13210 int main() {
13211  _ceilf(0);
13212 ; return 0; }
13213 EOF
13214 if { (eval echo configure:13215: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13215   rm -rf conftest*
13216   glibcpp_cv_func__ceilf_use=yes
13217 else
13218   echo "configure: failed program was:" >&5
13219   cat conftest.$ac_ext >&5
13220   rm -rf conftest*
13221   glibcpp_cv_func__ceilf_use=no
13222 fi
13223 rm -f conftest*
13224       ac_ext=c
13225 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13226 ac_cpp='$CPP $CPPFLAGS'
13227 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13228 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13229 cross_compiling=$ac_cv_prog_cc_cross
13230
13231
13232 fi
13233
13234   fi
13235   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
13236   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
13237     for ac_func in _ceilf
13238 do
13239 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13240 echo "configure:13241: checking for $ac_func" >&5
13241 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13242   echo $ac_n "(cached) $ac_c" 1>&6
13243 else
13244   cat > conftest.$ac_ext <<EOF
13245 #line 13246 "configure"
13246 #include "confdefs.h"
13247 /* System header to define __stub macros and hopefully few prototypes,
13248     which can conflict with char $ac_func(); below.  */
13249 #include <assert.h>
13250 /* Override any gcc2 internal prototype to avoid an error.  */
13251 /* We use char because int might match the return type of a gcc2
13252     builtin and then its argument prototype would still apply.  */
13253 char $ac_func();
13254
13255 int main() {
13256
13257 /* The GNU C library defines this for functions which it implements
13258     to always fail with ENOSYS.  Some functions are actually named
13259     something starting with __ and the normal name is an alias.  */
13260 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13261 choke me
13262 #else
13263 $ac_func();
13264 #endif
13265
13266 ; return 0; }
13267 EOF
13268 if { (eval echo configure:13269: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13269   rm -rf conftest*
13270   eval "ac_cv_func_$ac_func=yes"
13271 else
13272   echo "configure: failed program was:" >&5
13273   cat conftest.$ac_ext >&5
13274   rm -rf conftest*
13275   eval "ac_cv_func_$ac_func=no"
13276 fi
13277 rm -f conftest*
13278 fi
13279
13280 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13281   echo "$ac_t""yes" 1>&6
13282     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13283   cat >> confdefs.h <<EOF
13284 #define $ac_tr_func 1
13285 EOF
13286
13287 else
13288   echo "$ac_t""no" 1>&6
13289 fi
13290 done
13291
13292   fi
13293
13294
13295   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
13296 echo "configure:13297: checking for _cosf declaration" >&5
13297   if test x${glibcpp_cv_func__cosf_use+set} != xset; then
13298     if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
13299   echo $ac_n "(cached) $ac_c" 1>&6
13300 else
13301
13302
13303       ac_ext=C
13304 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13305 ac_cpp='$CXXCPP $CPPFLAGS'
13306 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13307 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13308 cross_compiling=$ac_cv_prog_cxx_cross
13309
13310       cat > conftest.$ac_ext <<EOF
13311 #line 13312 "configure"
13312 #include "confdefs.h"
13313 #include <math.h>
13314 int main() {
13315  _cosf(0);
13316 ; return 0; }
13317 EOF
13318 if { (eval echo configure:13319: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13319   rm -rf conftest*
13320   glibcpp_cv_func__cosf_use=yes
13321 else
13322   echo "configure: failed program was:" >&5
13323   cat conftest.$ac_ext >&5
13324   rm -rf conftest*
13325   glibcpp_cv_func__cosf_use=no
13326 fi
13327 rm -f conftest*
13328       ac_ext=c
13329 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13330 ac_cpp='$CPP $CPPFLAGS'
13331 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13332 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13333 cross_compiling=$ac_cv_prog_cc_cross
13334
13335
13336 fi
13337
13338   fi
13339   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
13340   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
13341     for ac_func in _cosf
13342 do
13343 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13344 echo "configure:13345: checking for $ac_func" >&5
13345 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13346   echo $ac_n "(cached) $ac_c" 1>&6
13347 else
13348   cat > conftest.$ac_ext <<EOF
13349 #line 13350 "configure"
13350 #include "confdefs.h"
13351 /* System header to define __stub macros and hopefully few prototypes,
13352     which can conflict with char $ac_func(); below.  */
13353 #include <assert.h>
13354 /* Override any gcc2 internal prototype to avoid an error.  */
13355 /* We use char because int might match the return type of a gcc2
13356     builtin and then its argument prototype would still apply.  */
13357 char $ac_func();
13358
13359 int main() {
13360
13361 /* The GNU C library defines this for functions which it implements
13362     to always fail with ENOSYS.  Some functions are actually named
13363     something starting with __ and the normal name is an alias.  */
13364 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13365 choke me
13366 #else
13367 $ac_func();
13368 #endif
13369
13370 ; return 0; }
13371 EOF
13372 if { (eval echo configure:13373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13373   rm -rf conftest*
13374   eval "ac_cv_func_$ac_func=yes"
13375 else
13376   echo "configure: failed program was:" >&5
13377   cat conftest.$ac_ext >&5
13378   rm -rf conftest*
13379   eval "ac_cv_func_$ac_func=no"
13380 fi
13381 rm -f conftest*
13382 fi
13383
13384 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13385   echo "$ac_t""yes" 1>&6
13386     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13387   cat >> confdefs.h <<EOF
13388 #define $ac_tr_func 1
13389 EOF
13390
13391 else
13392   echo "$ac_t""no" 1>&6
13393 fi
13394 done
13395
13396   fi
13397
13398
13399   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
13400 echo "configure:13401: checking for _coshf declaration" >&5
13401   if test x${glibcpp_cv_func__coshf_use+set} != xset; then
13402     if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
13403   echo $ac_n "(cached) $ac_c" 1>&6
13404 else
13405
13406
13407       ac_ext=C
13408 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13409 ac_cpp='$CXXCPP $CPPFLAGS'
13410 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13411 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13412 cross_compiling=$ac_cv_prog_cxx_cross
13413
13414       cat > conftest.$ac_ext <<EOF
13415 #line 13416 "configure"
13416 #include "confdefs.h"
13417 #include <math.h>
13418 int main() {
13419  _coshf(0);
13420 ; return 0; }
13421 EOF
13422 if { (eval echo configure:13423: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13423   rm -rf conftest*
13424   glibcpp_cv_func__coshf_use=yes
13425 else
13426   echo "configure: failed program was:" >&5
13427   cat conftest.$ac_ext >&5
13428   rm -rf conftest*
13429   glibcpp_cv_func__coshf_use=no
13430 fi
13431 rm -f conftest*
13432       ac_ext=c
13433 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13434 ac_cpp='$CPP $CPPFLAGS'
13435 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13436 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13437 cross_compiling=$ac_cv_prog_cc_cross
13438
13439
13440 fi
13441
13442   fi
13443   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
13444   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
13445     for ac_func in _coshf
13446 do
13447 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13448 echo "configure:13449: checking for $ac_func" >&5
13449 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13450   echo $ac_n "(cached) $ac_c" 1>&6
13451 else
13452   cat > conftest.$ac_ext <<EOF
13453 #line 13454 "configure"
13454 #include "confdefs.h"
13455 /* System header to define __stub macros and hopefully few prototypes,
13456     which can conflict with char $ac_func(); below.  */
13457 #include <assert.h>
13458 /* Override any gcc2 internal prototype to avoid an error.  */
13459 /* We use char because int might match the return type of a gcc2
13460     builtin and then its argument prototype would still apply.  */
13461 char $ac_func();
13462
13463 int main() {
13464
13465 /* The GNU C library defines this for functions which it implements
13466     to always fail with ENOSYS.  Some functions are actually named
13467     something starting with __ and the normal name is an alias.  */
13468 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13469 choke me
13470 #else
13471 $ac_func();
13472 #endif
13473
13474 ; return 0; }
13475 EOF
13476 if { (eval echo configure:13477: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13477   rm -rf conftest*
13478   eval "ac_cv_func_$ac_func=yes"
13479 else
13480   echo "configure: failed program was:" >&5
13481   cat conftest.$ac_ext >&5
13482   rm -rf conftest*
13483   eval "ac_cv_func_$ac_func=no"
13484 fi
13485 rm -f conftest*
13486 fi
13487
13488 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13489   echo "$ac_t""yes" 1>&6
13490     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13491   cat >> confdefs.h <<EOF
13492 #define $ac_tr_func 1
13493 EOF
13494
13495 else
13496   echo "$ac_t""no" 1>&6
13497 fi
13498 done
13499
13500   fi
13501
13502
13503   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
13504 echo "configure:13505: checking for _fabsf declaration" >&5
13505   if test x${glibcpp_cv_func__fabsf_use+set} != xset; then
13506     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
13507   echo $ac_n "(cached) $ac_c" 1>&6
13508 else
13509
13510
13511       ac_ext=C
13512 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13513 ac_cpp='$CXXCPP $CPPFLAGS'
13514 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13515 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13516 cross_compiling=$ac_cv_prog_cxx_cross
13517
13518       cat > conftest.$ac_ext <<EOF
13519 #line 13520 "configure"
13520 #include "confdefs.h"
13521 #include <math.h>
13522 int main() {
13523  _fabsf(0);
13524 ; return 0; }
13525 EOF
13526 if { (eval echo configure:13527: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13527   rm -rf conftest*
13528   glibcpp_cv_func__fabsf_use=yes
13529 else
13530   echo "configure: failed program was:" >&5
13531   cat conftest.$ac_ext >&5
13532   rm -rf conftest*
13533   glibcpp_cv_func__fabsf_use=no
13534 fi
13535 rm -f conftest*
13536       ac_ext=c
13537 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13538 ac_cpp='$CPP $CPPFLAGS'
13539 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13540 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13541 cross_compiling=$ac_cv_prog_cc_cross
13542
13543
13544 fi
13545
13546   fi
13547   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
13548   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
13549     for ac_func in _fabsf
13550 do
13551 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13552 echo "configure:13553: checking for $ac_func" >&5
13553 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13554   echo $ac_n "(cached) $ac_c" 1>&6
13555 else
13556   cat > conftest.$ac_ext <<EOF
13557 #line 13558 "configure"
13558 #include "confdefs.h"
13559 /* System header to define __stub macros and hopefully few prototypes,
13560     which can conflict with char $ac_func(); below.  */
13561 #include <assert.h>
13562 /* Override any gcc2 internal prototype to avoid an error.  */
13563 /* We use char because int might match the return type of a gcc2
13564     builtin and then its argument prototype would still apply.  */
13565 char $ac_func();
13566
13567 int main() {
13568
13569 /* The GNU C library defines this for functions which it implements
13570     to always fail with ENOSYS.  Some functions are actually named
13571     something starting with __ and the normal name is an alias.  */
13572 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13573 choke me
13574 #else
13575 $ac_func();
13576 #endif
13577
13578 ; return 0; }
13579 EOF
13580 if { (eval echo configure:13581: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13581   rm -rf conftest*
13582   eval "ac_cv_func_$ac_func=yes"
13583 else
13584   echo "configure: failed program was:" >&5
13585   cat conftest.$ac_ext >&5
13586   rm -rf conftest*
13587   eval "ac_cv_func_$ac_func=no"
13588 fi
13589 rm -f conftest*
13590 fi
13591
13592 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13593   echo "$ac_t""yes" 1>&6
13594     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13595   cat >> confdefs.h <<EOF
13596 #define $ac_tr_func 1
13597 EOF
13598
13599 else
13600   echo "$ac_t""no" 1>&6
13601 fi
13602 done
13603
13604   fi
13605
13606
13607   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
13608 echo "configure:13609: checking for _floorf declaration" >&5
13609   if test x${glibcpp_cv_func__floorf_use+set} != xset; then
13610     if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
13611   echo $ac_n "(cached) $ac_c" 1>&6
13612 else
13613
13614
13615       ac_ext=C
13616 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13617 ac_cpp='$CXXCPP $CPPFLAGS'
13618 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13619 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13620 cross_compiling=$ac_cv_prog_cxx_cross
13621
13622       cat > conftest.$ac_ext <<EOF
13623 #line 13624 "configure"
13624 #include "confdefs.h"
13625 #include <math.h>
13626 int main() {
13627  _floorf(0);
13628 ; return 0; }
13629 EOF
13630 if { (eval echo configure:13631: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13631   rm -rf conftest*
13632   glibcpp_cv_func__floorf_use=yes
13633 else
13634   echo "configure: failed program was:" >&5
13635   cat conftest.$ac_ext >&5
13636   rm -rf conftest*
13637   glibcpp_cv_func__floorf_use=no
13638 fi
13639 rm -f conftest*
13640       ac_ext=c
13641 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13642 ac_cpp='$CPP $CPPFLAGS'
13643 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13644 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13645 cross_compiling=$ac_cv_prog_cc_cross
13646
13647
13648 fi
13649
13650   fi
13651   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
13652   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
13653     for ac_func in _floorf
13654 do
13655 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13656 echo "configure:13657: checking for $ac_func" >&5
13657 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13658   echo $ac_n "(cached) $ac_c" 1>&6
13659 else
13660   cat > conftest.$ac_ext <<EOF
13661 #line 13662 "configure"
13662 #include "confdefs.h"
13663 /* System header to define __stub macros and hopefully few prototypes,
13664     which can conflict with char $ac_func(); below.  */
13665 #include <assert.h>
13666 /* Override any gcc2 internal prototype to avoid an error.  */
13667 /* We use char because int might match the return type of a gcc2
13668     builtin and then its argument prototype would still apply.  */
13669 char $ac_func();
13670
13671 int main() {
13672
13673 /* The GNU C library defines this for functions which it implements
13674     to always fail with ENOSYS.  Some functions are actually named
13675     something starting with __ and the normal name is an alias.  */
13676 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13677 choke me
13678 #else
13679 $ac_func();
13680 #endif
13681
13682 ; return 0; }
13683 EOF
13684 if { (eval echo configure:13685: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13685   rm -rf conftest*
13686   eval "ac_cv_func_$ac_func=yes"
13687 else
13688   echo "configure: failed program was:" >&5
13689   cat conftest.$ac_ext >&5
13690   rm -rf conftest*
13691   eval "ac_cv_func_$ac_func=no"
13692 fi
13693 rm -f conftest*
13694 fi
13695
13696 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13697   echo "$ac_t""yes" 1>&6
13698     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13699   cat >> confdefs.h <<EOF
13700 #define $ac_tr_func 1
13701 EOF
13702
13703 else
13704   echo "$ac_t""no" 1>&6
13705 fi
13706 done
13707
13708   fi
13709
13710
13711   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
13712 echo "configure:13713: checking for _fmodf declaration" >&5
13713   if test x${glibcpp_cv_func__fmodf_use+set} != xset; then
13714     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
13715   echo $ac_n "(cached) $ac_c" 1>&6
13716 else
13717
13718
13719       ac_ext=C
13720 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13721 ac_cpp='$CXXCPP $CPPFLAGS'
13722 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13723 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13724 cross_compiling=$ac_cv_prog_cxx_cross
13725
13726       cat > conftest.$ac_ext <<EOF
13727 #line 13728 "configure"
13728 #include "confdefs.h"
13729 #include <math.h>
13730 int main() {
13731  _fmodf(0, 0);
13732 ; return 0; }
13733 EOF
13734 if { (eval echo configure:13735: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13735   rm -rf conftest*
13736   glibcpp_cv_func__fmodf_use=yes
13737 else
13738   echo "configure: failed program was:" >&5
13739   cat conftest.$ac_ext >&5
13740   rm -rf conftest*
13741   glibcpp_cv_func__fmodf_use=no
13742 fi
13743 rm -f conftest*
13744       ac_ext=c
13745 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13746 ac_cpp='$CPP $CPPFLAGS'
13747 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13748 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13749 cross_compiling=$ac_cv_prog_cc_cross
13750
13751
13752 fi
13753
13754   fi
13755   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
13756   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
13757     for ac_func in _fmodf
13758 do
13759 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13760 echo "configure:13761: checking for $ac_func" >&5
13761 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13762   echo $ac_n "(cached) $ac_c" 1>&6
13763 else
13764   cat > conftest.$ac_ext <<EOF
13765 #line 13766 "configure"
13766 #include "confdefs.h"
13767 /* System header to define __stub macros and hopefully few prototypes,
13768     which can conflict with char $ac_func(); below.  */
13769 #include <assert.h>
13770 /* Override any gcc2 internal prototype to avoid an error.  */
13771 /* We use char because int might match the return type of a gcc2
13772     builtin and then its argument prototype would still apply.  */
13773 char $ac_func();
13774
13775 int main() {
13776
13777 /* The GNU C library defines this for functions which it implements
13778     to always fail with ENOSYS.  Some functions are actually named
13779     something starting with __ and the normal name is an alias.  */
13780 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13781 choke me
13782 #else
13783 $ac_func();
13784 #endif
13785
13786 ; return 0; }
13787 EOF
13788 if { (eval echo configure:13789: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13789   rm -rf conftest*
13790   eval "ac_cv_func_$ac_func=yes"
13791 else
13792   echo "configure: failed program was:" >&5
13793   cat conftest.$ac_ext >&5
13794   rm -rf conftest*
13795   eval "ac_cv_func_$ac_func=no"
13796 fi
13797 rm -f conftest*
13798 fi
13799
13800 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13801   echo "$ac_t""yes" 1>&6
13802     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13803   cat >> confdefs.h <<EOF
13804 #define $ac_tr_func 1
13805 EOF
13806
13807 else
13808   echo "$ac_t""no" 1>&6
13809 fi
13810 done
13811
13812   fi
13813
13814
13815   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
13816 echo "configure:13817: checking for _frexpf declaration" >&5
13817   if test x${glibcpp_cv_func__frexpf_use+set} != xset; then
13818     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
13819   echo $ac_n "(cached) $ac_c" 1>&6
13820 else
13821
13822
13823       ac_ext=C
13824 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13825 ac_cpp='$CXXCPP $CPPFLAGS'
13826 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13827 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13828 cross_compiling=$ac_cv_prog_cxx_cross
13829
13830       cat > conftest.$ac_ext <<EOF
13831 #line 13832 "configure"
13832 #include "confdefs.h"
13833 #include <math.h>
13834 int main() {
13835  _frexpf(0, 0);
13836 ; return 0; }
13837 EOF
13838 if { (eval echo configure:13839: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13839   rm -rf conftest*
13840   glibcpp_cv_func__frexpf_use=yes
13841 else
13842   echo "configure: failed program was:" >&5
13843   cat conftest.$ac_ext >&5
13844   rm -rf conftest*
13845   glibcpp_cv_func__frexpf_use=no
13846 fi
13847 rm -f conftest*
13848       ac_ext=c
13849 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13850 ac_cpp='$CPP $CPPFLAGS'
13851 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13852 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13853 cross_compiling=$ac_cv_prog_cc_cross
13854
13855
13856 fi
13857
13858   fi
13859   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
13860   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
13861     for ac_func in _frexpf
13862 do
13863 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13864 echo "configure:13865: checking for $ac_func" >&5
13865 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13866   echo $ac_n "(cached) $ac_c" 1>&6
13867 else
13868   cat > conftest.$ac_ext <<EOF
13869 #line 13870 "configure"
13870 #include "confdefs.h"
13871 /* System header to define __stub macros and hopefully few prototypes,
13872     which can conflict with char $ac_func(); below.  */
13873 #include <assert.h>
13874 /* Override any gcc2 internal prototype to avoid an error.  */
13875 /* We use char because int might match the return type of a gcc2
13876     builtin and then its argument prototype would still apply.  */
13877 char $ac_func();
13878
13879 int main() {
13880
13881 /* The GNU C library defines this for functions which it implements
13882     to always fail with ENOSYS.  Some functions are actually named
13883     something starting with __ and the normal name is an alias.  */
13884 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13885 choke me
13886 #else
13887 $ac_func();
13888 #endif
13889
13890 ; return 0; }
13891 EOF
13892 if { (eval echo configure:13893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13893   rm -rf conftest*
13894   eval "ac_cv_func_$ac_func=yes"
13895 else
13896   echo "configure: failed program was:" >&5
13897   cat conftest.$ac_ext >&5
13898   rm -rf conftest*
13899   eval "ac_cv_func_$ac_func=no"
13900 fi
13901 rm -f conftest*
13902 fi
13903
13904 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13905   echo "$ac_t""yes" 1>&6
13906     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13907   cat >> confdefs.h <<EOF
13908 #define $ac_tr_func 1
13909 EOF
13910
13911 else
13912   echo "$ac_t""no" 1>&6
13913 fi
13914 done
13915
13916   fi
13917
13918
13919   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13920 echo "configure:13921: checking for _ldexpf declaration" >&5
13921   if test x${glibcpp_cv_func__ldexpf_use+set} != xset; then
13922     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13923   echo $ac_n "(cached) $ac_c" 1>&6
13924 else
13925
13926
13927       ac_ext=C
13928 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13929 ac_cpp='$CXXCPP $CPPFLAGS'
13930 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13931 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13932 cross_compiling=$ac_cv_prog_cxx_cross
13933
13934       cat > conftest.$ac_ext <<EOF
13935 #line 13936 "configure"
13936 #include "confdefs.h"
13937 #include <math.h>
13938 int main() {
13939  _ldexpf(0, 0);
13940 ; return 0; }
13941 EOF
13942 if { (eval echo configure:13943: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13943   rm -rf conftest*
13944   glibcpp_cv_func__ldexpf_use=yes
13945 else
13946   echo "configure: failed program was:" >&5
13947   cat conftest.$ac_ext >&5
13948   rm -rf conftest*
13949   glibcpp_cv_func__ldexpf_use=no
13950 fi
13951 rm -f conftest*
13952       ac_ext=c
13953 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13954 ac_cpp='$CPP $CPPFLAGS'
13955 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13956 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13957 cross_compiling=$ac_cv_prog_cc_cross
13958
13959
13960 fi
13961
13962   fi
13963   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13964   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13965     for ac_func in _ldexpf
13966 do
13967 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13968 echo "configure:13969: checking for $ac_func" >&5
13969 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13970   echo $ac_n "(cached) $ac_c" 1>&6
13971 else
13972   cat > conftest.$ac_ext <<EOF
13973 #line 13974 "configure"
13974 #include "confdefs.h"
13975 /* System header to define __stub macros and hopefully few prototypes,
13976     which can conflict with char $ac_func(); below.  */
13977 #include <assert.h>
13978 /* Override any gcc2 internal prototype to avoid an error.  */
13979 /* We use char because int might match the return type of a gcc2
13980     builtin and then its argument prototype would still apply.  */
13981 char $ac_func();
13982
13983 int main() {
13984
13985 /* The GNU C library defines this for functions which it implements
13986     to always fail with ENOSYS.  Some functions are actually named
13987     something starting with __ and the normal name is an alias.  */
13988 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13989 choke me
13990 #else
13991 $ac_func();
13992 #endif
13993
13994 ; return 0; }
13995 EOF
13996 if { (eval echo configure:13997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13997   rm -rf conftest*
13998   eval "ac_cv_func_$ac_func=yes"
13999 else
14000   echo "configure: failed program was:" >&5
14001   cat conftest.$ac_ext >&5
14002   rm -rf conftest*
14003   eval "ac_cv_func_$ac_func=no"
14004 fi
14005 rm -f conftest*
14006 fi
14007
14008 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14009   echo "$ac_t""yes" 1>&6
14010     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14011   cat >> confdefs.h <<EOF
14012 #define $ac_tr_func 1
14013 EOF
14014
14015 else
14016   echo "$ac_t""no" 1>&6
14017 fi
14018 done
14019
14020   fi
14021
14022
14023   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
14024 echo "configure:14025: checking for _logf declaration" >&5
14025   if test x${glibcpp_cv_func__logf_use+set} != xset; then
14026     if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
14027   echo $ac_n "(cached) $ac_c" 1>&6
14028 else
14029
14030
14031       ac_ext=C
14032 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14033 ac_cpp='$CXXCPP $CPPFLAGS'
14034 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14035 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14036 cross_compiling=$ac_cv_prog_cxx_cross
14037
14038       cat > conftest.$ac_ext <<EOF
14039 #line 14040 "configure"
14040 #include "confdefs.h"
14041 #include <math.h>
14042 int main() {
14043  _logf(0);
14044 ; return 0; }
14045 EOF
14046 if { (eval echo configure:14047: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14047   rm -rf conftest*
14048   glibcpp_cv_func__logf_use=yes
14049 else
14050   echo "configure: failed program was:" >&5
14051   cat conftest.$ac_ext >&5
14052   rm -rf conftest*
14053   glibcpp_cv_func__logf_use=no
14054 fi
14055 rm -f conftest*
14056       ac_ext=c
14057 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14058 ac_cpp='$CPP $CPPFLAGS'
14059 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14060 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14061 cross_compiling=$ac_cv_prog_cc_cross
14062
14063
14064 fi
14065
14066   fi
14067   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
14068   if test x$glibcpp_cv_func__logf_use = x"yes"; then
14069     for ac_func in _logf
14070 do
14071 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14072 echo "configure:14073: checking for $ac_func" >&5
14073 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14074   echo $ac_n "(cached) $ac_c" 1>&6
14075 else
14076   cat > conftest.$ac_ext <<EOF
14077 #line 14078 "configure"
14078 #include "confdefs.h"
14079 /* System header to define __stub macros and hopefully few prototypes,
14080     which can conflict with char $ac_func(); below.  */
14081 #include <assert.h>
14082 /* Override any gcc2 internal prototype to avoid an error.  */
14083 /* We use char because int might match the return type of a gcc2
14084     builtin and then its argument prototype would still apply.  */
14085 char $ac_func();
14086
14087 int main() {
14088
14089 /* The GNU C library defines this for functions which it implements
14090     to always fail with ENOSYS.  Some functions are actually named
14091     something starting with __ and the normal name is an alias.  */
14092 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14093 choke me
14094 #else
14095 $ac_func();
14096 #endif
14097
14098 ; return 0; }
14099 EOF
14100 if { (eval echo configure:14101: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14101   rm -rf conftest*
14102   eval "ac_cv_func_$ac_func=yes"
14103 else
14104   echo "configure: failed program was:" >&5
14105   cat conftest.$ac_ext >&5
14106   rm -rf conftest*
14107   eval "ac_cv_func_$ac_func=no"
14108 fi
14109 rm -f conftest*
14110 fi
14111
14112 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14113   echo "$ac_t""yes" 1>&6
14114     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14115   cat >> confdefs.h <<EOF
14116 #define $ac_tr_func 1
14117 EOF
14118
14119 else
14120   echo "$ac_t""no" 1>&6
14121 fi
14122 done
14123
14124   fi
14125
14126
14127   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
14128 echo "configure:14129: checking for _log10f declaration" >&5
14129   if test x${glibcpp_cv_func__log10f_use+set} != xset; then
14130     if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
14131   echo $ac_n "(cached) $ac_c" 1>&6
14132 else
14133
14134
14135       ac_ext=C
14136 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14137 ac_cpp='$CXXCPP $CPPFLAGS'
14138 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14139 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14140 cross_compiling=$ac_cv_prog_cxx_cross
14141
14142       cat > conftest.$ac_ext <<EOF
14143 #line 14144 "configure"
14144 #include "confdefs.h"
14145 #include <math.h>
14146 int main() {
14147  _log10f(0);
14148 ; return 0; }
14149 EOF
14150 if { (eval echo configure:14151: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14151   rm -rf conftest*
14152   glibcpp_cv_func__log10f_use=yes
14153 else
14154   echo "configure: failed program was:" >&5
14155   cat conftest.$ac_ext >&5
14156   rm -rf conftest*
14157   glibcpp_cv_func__log10f_use=no
14158 fi
14159 rm -f conftest*
14160       ac_ext=c
14161 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14162 ac_cpp='$CPP $CPPFLAGS'
14163 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14164 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14165 cross_compiling=$ac_cv_prog_cc_cross
14166
14167
14168 fi
14169
14170   fi
14171   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
14172   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
14173     for ac_func in _log10f
14174 do
14175 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14176 echo "configure:14177: checking for $ac_func" >&5
14177 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14178   echo $ac_n "(cached) $ac_c" 1>&6
14179 else
14180   cat > conftest.$ac_ext <<EOF
14181 #line 14182 "configure"
14182 #include "confdefs.h"
14183 /* System header to define __stub macros and hopefully few prototypes,
14184     which can conflict with char $ac_func(); below.  */
14185 #include <assert.h>
14186 /* Override any gcc2 internal prototype to avoid an error.  */
14187 /* We use char because int might match the return type of a gcc2
14188     builtin and then its argument prototype would still apply.  */
14189 char $ac_func();
14190
14191 int main() {
14192
14193 /* The GNU C library defines this for functions which it implements
14194     to always fail with ENOSYS.  Some functions are actually named
14195     something starting with __ and the normal name is an alias.  */
14196 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14197 choke me
14198 #else
14199 $ac_func();
14200 #endif
14201
14202 ; return 0; }
14203 EOF
14204 if { (eval echo configure:14205: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14205   rm -rf conftest*
14206   eval "ac_cv_func_$ac_func=yes"
14207 else
14208   echo "configure: failed program was:" >&5
14209   cat conftest.$ac_ext >&5
14210   rm -rf conftest*
14211   eval "ac_cv_func_$ac_func=no"
14212 fi
14213 rm -f conftest*
14214 fi
14215
14216 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14217   echo "$ac_t""yes" 1>&6
14218     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14219   cat >> confdefs.h <<EOF
14220 #define $ac_tr_func 1
14221 EOF
14222
14223 else
14224   echo "$ac_t""no" 1>&6
14225 fi
14226 done
14227
14228   fi
14229
14230
14231   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
14232 echo "configure:14233: checking for _modff declaration" >&5
14233   if test x${glibcpp_cv_func__modff_use+set} != xset; then
14234     if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
14235   echo $ac_n "(cached) $ac_c" 1>&6
14236 else
14237
14238
14239       ac_ext=C
14240 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14241 ac_cpp='$CXXCPP $CPPFLAGS'
14242 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14243 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14244 cross_compiling=$ac_cv_prog_cxx_cross
14245
14246       cat > conftest.$ac_ext <<EOF
14247 #line 14248 "configure"
14248 #include "confdefs.h"
14249 #include <math.h>
14250 int main() {
14251  _modff(0, 0);
14252 ; return 0; }
14253 EOF
14254 if { (eval echo configure:14255: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14255   rm -rf conftest*
14256   glibcpp_cv_func__modff_use=yes
14257 else
14258   echo "configure: failed program was:" >&5
14259   cat conftest.$ac_ext >&5
14260   rm -rf conftest*
14261   glibcpp_cv_func__modff_use=no
14262 fi
14263 rm -f conftest*
14264       ac_ext=c
14265 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14266 ac_cpp='$CPP $CPPFLAGS'
14267 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14268 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14269 cross_compiling=$ac_cv_prog_cc_cross
14270
14271
14272 fi
14273
14274   fi
14275   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
14276   if test x$glibcpp_cv_func__modff_use = x"yes"; then
14277     for ac_func in _modff
14278 do
14279 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14280 echo "configure:14281: checking for $ac_func" >&5
14281 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14282   echo $ac_n "(cached) $ac_c" 1>&6
14283 else
14284   cat > conftest.$ac_ext <<EOF
14285 #line 14286 "configure"
14286 #include "confdefs.h"
14287 /* System header to define __stub macros and hopefully few prototypes,
14288     which can conflict with char $ac_func(); below.  */
14289 #include <assert.h>
14290 /* Override any gcc2 internal prototype to avoid an error.  */
14291 /* We use char because int might match the return type of a gcc2
14292     builtin and then its argument prototype would still apply.  */
14293 char $ac_func();
14294
14295 int main() {
14296
14297 /* The GNU C library defines this for functions which it implements
14298     to always fail with ENOSYS.  Some functions are actually named
14299     something starting with __ and the normal name is an alias.  */
14300 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14301 choke me
14302 #else
14303 $ac_func();
14304 #endif
14305
14306 ; return 0; }
14307 EOF
14308 if { (eval echo configure:14309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14309   rm -rf conftest*
14310   eval "ac_cv_func_$ac_func=yes"
14311 else
14312   echo "configure: failed program was:" >&5
14313   cat conftest.$ac_ext >&5
14314   rm -rf conftest*
14315   eval "ac_cv_func_$ac_func=no"
14316 fi
14317 rm -f conftest*
14318 fi
14319
14320 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14321   echo "$ac_t""yes" 1>&6
14322     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14323   cat >> confdefs.h <<EOF
14324 #define $ac_tr_func 1
14325 EOF
14326
14327 else
14328   echo "$ac_t""no" 1>&6
14329 fi
14330 done
14331
14332   fi
14333
14334
14335   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
14336 echo "configure:14337: checking for _powf declaration" >&5
14337   if test x${glibcpp_cv_func__powf_use+set} != xset; then
14338     if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
14339   echo $ac_n "(cached) $ac_c" 1>&6
14340 else
14341
14342
14343       ac_ext=C
14344 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14345 ac_cpp='$CXXCPP $CPPFLAGS'
14346 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14347 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14348 cross_compiling=$ac_cv_prog_cxx_cross
14349
14350       cat > conftest.$ac_ext <<EOF
14351 #line 14352 "configure"
14352 #include "confdefs.h"
14353 #include <math.h>
14354 int main() {
14355  _powf(0, 0);
14356 ; return 0; }
14357 EOF
14358 if { (eval echo configure:14359: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14359   rm -rf conftest*
14360   glibcpp_cv_func__powf_use=yes
14361 else
14362   echo "configure: failed program was:" >&5
14363   cat conftest.$ac_ext >&5
14364   rm -rf conftest*
14365   glibcpp_cv_func__powf_use=no
14366 fi
14367 rm -f conftest*
14368       ac_ext=c
14369 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14370 ac_cpp='$CPP $CPPFLAGS'
14371 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14372 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14373 cross_compiling=$ac_cv_prog_cc_cross
14374
14375
14376 fi
14377
14378   fi
14379   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
14380   if test x$glibcpp_cv_func__powf_use = x"yes"; then
14381     for ac_func in _powf
14382 do
14383 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14384 echo "configure:14385: checking for $ac_func" >&5
14385 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14386   echo $ac_n "(cached) $ac_c" 1>&6
14387 else
14388   cat > conftest.$ac_ext <<EOF
14389 #line 14390 "configure"
14390 #include "confdefs.h"
14391 /* System header to define __stub macros and hopefully few prototypes,
14392     which can conflict with char $ac_func(); below.  */
14393 #include <assert.h>
14394 /* Override any gcc2 internal prototype to avoid an error.  */
14395 /* We use char because int might match the return type of a gcc2
14396     builtin and then its argument prototype would still apply.  */
14397 char $ac_func();
14398
14399 int main() {
14400
14401 /* The GNU C library defines this for functions which it implements
14402     to always fail with ENOSYS.  Some functions are actually named
14403     something starting with __ and the normal name is an alias.  */
14404 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14405 choke me
14406 #else
14407 $ac_func();
14408 #endif
14409
14410 ; return 0; }
14411 EOF
14412 if { (eval echo configure:14413: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14413   rm -rf conftest*
14414   eval "ac_cv_func_$ac_func=yes"
14415 else
14416   echo "configure: failed program was:" >&5
14417   cat conftest.$ac_ext >&5
14418   rm -rf conftest*
14419   eval "ac_cv_func_$ac_func=no"
14420 fi
14421 rm -f conftest*
14422 fi
14423
14424 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14425   echo "$ac_t""yes" 1>&6
14426     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14427   cat >> confdefs.h <<EOF
14428 #define $ac_tr_func 1
14429 EOF
14430
14431 else
14432   echo "$ac_t""no" 1>&6
14433 fi
14434 done
14435
14436   fi
14437
14438
14439   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
14440 echo "configure:14441: checking for _sinf declaration" >&5
14441   if test x${glibcpp_cv_func__sinf_use+set} != xset; then
14442     if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
14443   echo $ac_n "(cached) $ac_c" 1>&6
14444 else
14445
14446
14447       ac_ext=C
14448 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14449 ac_cpp='$CXXCPP $CPPFLAGS'
14450 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14451 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14452 cross_compiling=$ac_cv_prog_cxx_cross
14453
14454       cat > conftest.$ac_ext <<EOF
14455 #line 14456 "configure"
14456 #include "confdefs.h"
14457 #include <math.h>
14458 int main() {
14459  _sinf(0);
14460 ; return 0; }
14461 EOF
14462 if { (eval echo configure:14463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14463   rm -rf conftest*
14464   glibcpp_cv_func__sinf_use=yes
14465 else
14466   echo "configure: failed program was:" >&5
14467   cat conftest.$ac_ext >&5
14468   rm -rf conftest*
14469   glibcpp_cv_func__sinf_use=no
14470 fi
14471 rm -f conftest*
14472       ac_ext=c
14473 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14474 ac_cpp='$CPP $CPPFLAGS'
14475 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14476 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14477 cross_compiling=$ac_cv_prog_cc_cross
14478
14479
14480 fi
14481
14482   fi
14483   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
14484   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
14485     for ac_func in _sinf
14486 do
14487 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14488 echo "configure:14489: checking for $ac_func" >&5
14489 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14490   echo $ac_n "(cached) $ac_c" 1>&6
14491 else
14492   cat > conftest.$ac_ext <<EOF
14493 #line 14494 "configure"
14494 #include "confdefs.h"
14495 /* System header to define __stub macros and hopefully few prototypes,
14496     which can conflict with char $ac_func(); below.  */
14497 #include <assert.h>
14498 /* Override any gcc2 internal prototype to avoid an error.  */
14499 /* We use char because int might match the return type of a gcc2
14500     builtin and then its argument prototype would still apply.  */
14501 char $ac_func();
14502
14503 int main() {
14504
14505 /* The GNU C library defines this for functions which it implements
14506     to always fail with ENOSYS.  Some functions are actually named
14507     something starting with __ and the normal name is an alias.  */
14508 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14509 choke me
14510 #else
14511 $ac_func();
14512 #endif
14513
14514 ; return 0; }
14515 EOF
14516 if { (eval echo configure:14517: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14517   rm -rf conftest*
14518   eval "ac_cv_func_$ac_func=yes"
14519 else
14520   echo "configure: failed program was:" >&5
14521   cat conftest.$ac_ext >&5
14522   rm -rf conftest*
14523   eval "ac_cv_func_$ac_func=no"
14524 fi
14525 rm -f conftest*
14526 fi
14527
14528 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14529   echo "$ac_t""yes" 1>&6
14530     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14531   cat >> confdefs.h <<EOF
14532 #define $ac_tr_func 1
14533 EOF
14534
14535 else
14536   echo "$ac_t""no" 1>&6
14537 fi
14538 done
14539
14540   fi
14541
14542
14543   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
14544 echo "configure:14545: checking for _sinhf declaration" >&5
14545   if test x${glibcpp_cv_func__sinhf_use+set} != xset; then
14546     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
14547   echo $ac_n "(cached) $ac_c" 1>&6
14548 else
14549
14550
14551       ac_ext=C
14552 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14553 ac_cpp='$CXXCPP $CPPFLAGS'
14554 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14555 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14556 cross_compiling=$ac_cv_prog_cxx_cross
14557
14558       cat > conftest.$ac_ext <<EOF
14559 #line 14560 "configure"
14560 #include "confdefs.h"
14561 #include <math.h>
14562 int main() {
14563  _sinhf(0);
14564 ; return 0; }
14565 EOF
14566 if { (eval echo configure:14567: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14567   rm -rf conftest*
14568   glibcpp_cv_func__sinhf_use=yes
14569 else
14570   echo "configure: failed program was:" >&5
14571   cat conftest.$ac_ext >&5
14572   rm -rf conftest*
14573   glibcpp_cv_func__sinhf_use=no
14574 fi
14575 rm -f conftest*
14576       ac_ext=c
14577 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14578 ac_cpp='$CPP $CPPFLAGS'
14579 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14580 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14581 cross_compiling=$ac_cv_prog_cc_cross
14582
14583
14584 fi
14585
14586   fi
14587   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
14588   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
14589     for ac_func in _sinhf
14590 do
14591 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14592 echo "configure:14593: checking for $ac_func" >&5
14593 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14594   echo $ac_n "(cached) $ac_c" 1>&6
14595 else
14596   cat > conftest.$ac_ext <<EOF
14597 #line 14598 "configure"
14598 #include "confdefs.h"
14599 /* System header to define __stub macros and hopefully few prototypes,
14600     which can conflict with char $ac_func(); below.  */
14601 #include <assert.h>
14602 /* Override any gcc2 internal prototype to avoid an error.  */
14603 /* We use char because int might match the return type of a gcc2
14604     builtin and then its argument prototype would still apply.  */
14605 char $ac_func();
14606
14607 int main() {
14608
14609 /* The GNU C library defines this for functions which it implements
14610     to always fail with ENOSYS.  Some functions are actually named
14611     something starting with __ and the normal name is an alias.  */
14612 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14613 choke me
14614 #else
14615 $ac_func();
14616 #endif
14617
14618 ; return 0; }
14619 EOF
14620 if { (eval echo configure:14621: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14621   rm -rf conftest*
14622   eval "ac_cv_func_$ac_func=yes"
14623 else
14624   echo "configure: failed program was:" >&5
14625   cat conftest.$ac_ext >&5
14626   rm -rf conftest*
14627   eval "ac_cv_func_$ac_func=no"
14628 fi
14629 rm -f conftest*
14630 fi
14631
14632 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14633   echo "$ac_t""yes" 1>&6
14634     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14635   cat >> confdefs.h <<EOF
14636 #define $ac_tr_func 1
14637 EOF
14638
14639 else
14640   echo "$ac_t""no" 1>&6
14641 fi
14642 done
14643
14644   fi
14645
14646
14647   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
14648 echo "configure:14649: checking for _sqrtf declaration" >&5
14649   if test x${glibcpp_cv_func__sqrtf_use+set} != xset; then
14650     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
14651   echo $ac_n "(cached) $ac_c" 1>&6
14652 else
14653
14654
14655       ac_ext=C
14656 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14657 ac_cpp='$CXXCPP $CPPFLAGS'
14658 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14659 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14660 cross_compiling=$ac_cv_prog_cxx_cross
14661
14662       cat > conftest.$ac_ext <<EOF
14663 #line 14664 "configure"
14664 #include "confdefs.h"
14665 #include <math.h>
14666 int main() {
14667  _sqrtf(0);
14668 ; return 0; }
14669 EOF
14670 if { (eval echo configure:14671: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14671   rm -rf conftest*
14672   glibcpp_cv_func__sqrtf_use=yes
14673 else
14674   echo "configure: failed program was:" >&5
14675   cat conftest.$ac_ext >&5
14676   rm -rf conftest*
14677   glibcpp_cv_func__sqrtf_use=no
14678 fi
14679 rm -f conftest*
14680       ac_ext=c
14681 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14682 ac_cpp='$CPP $CPPFLAGS'
14683 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14684 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14685 cross_compiling=$ac_cv_prog_cc_cross
14686
14687
14688 fi
14689
14690   fi
14691   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
14692   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
14693     for ac_func in _sqrtf
14694 do
14695 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14696 echo "configure:14697: checking for $ac_func" >&5
14697 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14698   echo $ac_n "(cached) $ac_c" 1>&6
14699 else
14700   cat > conftest.$ac_ext <<EOF
14701 #line 14702 "configure"
14702 #include "confdefs.h"
14703 /* System header to define __stub macros and hopefully few prototypes,
14704     which can conflict with char $ac_func(); below.  */
14705 #include <assert.h>
14706 /* Override any gcc2 internal prototype to avoid an error.  */
14707 /* We use char because int might match the return type of a gcc2
14708     builtin and then its argument prototype would still apply.  */
14709 char $ac_func();
14710
14711 int main() {
14712
14713 /* The GNU C library defines this for functions which it implements
14714     to always fail with ENOSYS.  Some functions are actually named
14715     something starting with __ and the normal name is an alias.  */
14716 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14717 choke me
14718 #else
14719 $ac_func();
14720 #endif
14721
14722 ; return 0; }
14723 EOF
14724 if { (eval echo configure:14725: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14725   rm -rf conftest*
14726   eval "ac_cv_func_$ac_func=yes"
14727 else
14728   echo "configure: failed program was:" >&5
14729   cat conftest.$ac_ext >&5
14730   rm -rf conftest*
14731   eval "ac_cv_func_$ac_func=no"
14732 fi
14733 rm -f conftest*
14734 fi
14735
14736 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14737   echo "$ac_t""yes" 1>&6
14738     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14739   cat >> confdefs.h <<EOF
14740 #define $ac_tr_func 1
14741 EOF
14742
14743 else
14744   echo "$ac_t""no" 1>&6
14745 fi
14746 done
14747
14748   fi
14749
14750
14751   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
14752 echo "configure:14753: checking for _tanf declaration" >&5
14753   if test x${glibcpp_cv_func__tanf_use+set} != xset; then
14754     if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
14755   echo $ac_n "(cached) $ac_c" 1>&6
14756 else
14757
14758
14759       ac_ext=C
14760 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14761 ac_cpp='$CXXCPP $CPPFLAGS'
14762 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14763 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14764 cross_compiling=$ac_cv_prog_cxx_cross
14765
14766       cat > conftest.$ac_ext <<EOF
14767 #line 14768 "configure"
14768 #include "confdefs.h"
14769 #include <math.h>
14770 int main() {
14771  _tanf(0);
14772 ; return 0; }
14773 EOF
14774 if { (eval echo configure:14775: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14775   rm -rf conftest*
14776   glibcpp_cv_func__tanf_use=yes
14777 else
14778   echo "configure: failed program was:" >&5
14779   cat conftest.$ac_ext >&5
14780   rm -rf conftest*
14781   glibcpp_cv_func__tanf_use=no
14782 fi
14783 rm -f conftest*
14784       ac_ext=c
14785 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14786 ac_cpp='$CPP $CPPFLAGS'
14787 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14788 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14789 cross_compiling=$ac_cv_prog_cc_cross
14790
14791
14792 fi
14793
14794   fi
14795   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
14796   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
14797     for ac_func in _tanf
14798 do
14799 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14800 echo "configure:14801: checking for $ac_func" >&5
14801 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14802   echo $ac_n "(cached) $ac_c" 1>&6
14803 else
14804   cat > conftest.$ac_ext <<EOF
14805 #line 14806 "configure"
14806 #include "confdefs.h"
14807 /* System header to define __stub macros and hopefully few prototypes,
14808     which can conflict with char $ac_func(); below.  */
14809 #include <assert.h>
14810 /* Override any gcc2 internal prototype to avoid an error.  */
14811 /* We use char because int might match the return type of a gcc2
14812     builtin and then its argument prototype would still apply.  */
14813 char $ac_func();
14814
14815 int main() {
14816
14817 /* The GNU C library defines this for functions which it implements
14818     to always fail with ENOSYS.  Some functions are actually named
14819     something starting with __ and the normal name is an alias.  */
14820 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14821 choke me
14822 #else
14823 $ac_func();
14824 #endif
14825
14826 ; return 0; }
14827 EOF
14828 if { (eval echo configure:14829: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14829   rm -rf conftest*
14830   eval "ac_cv_func_$ac_func=yes"
14831 else
14832   echo "configure: failed program was:" >&5
14833   cat conftest.$ac_ext >&5
14834   rm -rf conftest*
14835   eval "ac_cv_func_$ac_func=no"
14836 fi
14837 rm -f conftest*
14838 fi
14839
14840 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14841   echo "$ac_t""yes" 1>&6
14842     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14843   cat >> confdefs.h <<EOF
14844 #define $ac_tr_func 1
14845 EOF
14846
14847 else
14848   echo "$ac_t""no" 1>&6
14849 fi
14850 done
14851
14852   fi
14853
14854
14855   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
14856 echo "configure:14857: checking for _tanhf declaration" >&5
14857   if test x${glibcpp_cv_func__tanhf_use+set} != xset; then
14858     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
14859   echo $ac_n "(cached) $ac_c" 1>&6
14860 else
14861
14862
14863       ac_ext=C
14864 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14865 ac_cpp='$CXXCPP $CPPFLAGS'
14866 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14867 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14868 cross_compiling=$ac_cv_prog_cxx_cross
14869
14870       cat > conftest.$ac_ext <<EOF
14871 #line 14872 "configure"
14872 #include "confdefs.h"
14873 #include <math.h>
14874 int main() {
14875  _tanhf(0);
14876 ; return 0; }
14877 EOF
14878 if { (eval echo configure:14879: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14879   rm -rf conftest*
14880   glibcpp_cv_func__tanhf_use=yes
14881 else
14882   echo "configure: failed program was:" >&5
14883   cat conftest.$ac_ext >&5
14884   rm -rf conftest*
14885   glibcpp_cv_func__tanhf_use=no
14886 fi
14887 rm -f conftest*
14888       ac_ext=c
14889 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14890 ac_cpp='$CPP $CPPFLAGS'
14891 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14892 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14893 cross_compiling=$ac_cv_prog_cc_cross
14894
14895
14896 fi
14897
14898   fi
14899   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
14900   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
14901     for ac_func in _tanhf
14902 do
14903 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14904 echo "configure:14905: checking for $ac_func" >&5
14905 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14906   echo $ac_n "(cached) $ac_c" 1>&6
14907 else
14908   cat > conftest.$ac_ext <<EOF
14909 #line 14910 "configure"
14910 #include "confdefs.h"
14911 /* System header to define __stub macros and hopefully few prototypes,
14912     which can conflict with char $ac_func(); below.  */
14913 #include <assert.h>
14914 /* Override any gcc2 internal prototype to avoid an error.  */
14915 /* We use char because int might match the return type of a gcc2
14916     builtin and then its argument prototype would still apply.  */
14917 char $ac_func();
14918
14919 int main() {
14920
14921 /* The GNU C library defines this for functions which it implements
14922     to always fail with ENOSYS.  Some functions are actually named
14923     something starting with __ and the normal name is an alias.  */
14924 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14925 choke me
14926 #else
14927 $ac_func();
14928 #endif
14929
14930 ; return 0; }
14931 EOF
14932 if { (eval echo configure:14933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14933   rm -rf conftest*
14934   eval "ac_cv_func_$ac_func=yes"
14935 else
14936   echo "configure: failed program was:" >&5
14937   cat conftest.$ac_ext >&5
14938   rm -rf conftest*
14939   eval "ac_cv_func_$ac_func=no"
14940 fi
14941 rm -f conftest*
14942 fi
14943
14944 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14945   echo "$ac_t""yes" 1>&6
14946     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14947   cat >> confdefs.h <<EOF
14948 #define $ac_tr_func 1
14949 EOF
14950
14951 else
14952   echo "$ac_t""no" 1>&6
14953 fi
14954 done
14955
14956   fi
14957
14958
14959   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14960 echo "configure:14961: checking for _sincosf declaration" >&5
14961   if test x${glibcpp_cv_func__sincosf_use+set} != xset; then
14962     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14963   echo $ac_n "(cached) $ac_c" 1>&6
14964 else
14965
14966
14967       ac_ext=C
14968 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14969 ac_cpp='$CXXCPP $CPPFLAGS'
14970 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14971 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14972 cross_compiling=$ac_cv_prog_cxx_cross
14973
14974       cat > conftest.$ac_ext <<EOF
14975 #line 14976 "configure"
14976 #include "confdefs.h"
14977 #include <math.h>
14978 int main() {
14979  _sincosf(0, 0, 0);
14980 ; return 0; }
14981 EOF
14982 if { (eval echo configure:14983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14983   rm -rf conftest*
14984   glibcpp_cv_func__sincosf_use=yes
14985 else
14986   echo "configure: failed program was:" >&5
14987   cat conftest.$ac_ext >&5
14988   rm -rf conftest*
14989   glibcpp_cv_func__sincosf_use=no
14990 fi
14991 rm -f conftest*
14992       ac_ext=c
14993 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14994 ac_cpp='$CPP $CPPFLAGS'
14995 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14996 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14997 cross_compiling=$ac_cv_prog_cc_cross
14998
14999
15000 fi
15001
15002   fi
15003   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
15004   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
15005     for ac_func in _sincosf
15006 do
15007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15008 echo "configure:15009: checking for $ac_func" >&5
15009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15010   echo $ac_n "(cached) $ac_c" 1>&6
15011 else
15012   cat > conftest.$ac_ext <<EOF
15013 #line 15014 "configure"
15014 #include "confdefs.h"
15015 /* System header to define __stub macros and hopefully few prototypes,
15016     which can conflict with char $ac_func(); below.  */
15017 #include <assert.h>
15018 /* Override any gcc2 internal prototype to avoid an error.  */
15019 /* We use char because int might match the return type of a gcc2
15020     builtin and then its argument prototype would still apply.  */
15021 char $ac_func();
15022
15023 int main() {
15024
15025 /* The GNU C library defines this for functions which it implements
15026     to always fail with ENOSYS.  Some functions are actually named
15027     something starting with __ and the normal name is an alias.  */
15028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15029 choke me
15030 #else
15031 $ac_func();
15032 #endif
15033
15034 ; return 0; }
15035 EOF
15036 if { (eval echo configure:15037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15037   rm -rf conftest*
15038   eval "ac_cv_func_$ac_func=yes"
15039 else
15040   echo "configure: failed program was:" >&5
15041   cat conftest.$ac_ext >&5
15042   rm -rf conftest*
15043   eval "ac_cv_func_$ac_func=no"
15044 fi
15045 rm -f conftest*
15046 fi
15047
15048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15049   echo "$ac_t""yes" 1>&6
15050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15051   cat >> confdefs.h <<EOF
15052 #define $ac_tr_func 1
15053 EOF
15054
15055 else
15056   echo "$ac_t""no" 1>&6
15057 fi
15058 done
15059
15060   fi
15061
15062
15063   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
15064 echo "configure:15065: checking for _finitef declaration" >&5
15065   if test x${glibcpp_cv_func__finitef_use+set} != xset; then
15066     if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
15067   echo $ac_n "(cached) $ac_c" 1>&6
15068 else
15069
15070
15071       ac_ext=C
15072 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15073 ac_cpp='$CXXCPP $CPPFLAGS'
15074 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15075 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15076 cross_compiling=$ac_cv_prog_cxx_cross
15077
15078       cat > conftest.$ac_ext <<EOF
15079 #line 15080 "configure"
15080 #include "confdefs.h"
15081 #include <math.h>
15082 int main() {
15083  _finitef(0);
15084 ; return 0; }
15085 EOF
15086 if { (eval echo configure:15087: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15087   rm -rf conftest*
15088   glibcpp_cv_func__finitef_use=yes
15089 else
15090   echo "configure: failed program was:" >&5
15091   cat conftest.$ac_ext >&5
15092   rm -rf conftest*
15093   glibcpp_cv_func__finitef_use=no
15094 fi
15095 rm -f conftest*
15096       ac_ext=c
15097 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15098 ac_cpp='$CPP $CPPFLAGS'
15099 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15100 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15101 cross_compiling=$ac_cv_prog_cc_cross
15102
15103
15104 fi
15105
15106   fi
15107   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
15108   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
15109     for ac_func in _finitef
15110 do
15111 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15112 echo "configure:15113: checking for $ac_func" >&5
15113 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15114   echo $ac_n "(cached) $ac_c" 1>&6
15115 else
15116   cat > conftest.$ac_ext <<EOF
15117 #line 15118 "configure"
15118 #include "confdefs.h"
15119 /* System header to define __stub macros and hopefully few prototypes,
15120     which can conflict with char $ac_func(); below.  */
15121 #include <assert.h>
15122 /* Override any gcc2 internal prototype to avoid an error.  */
15123 /* We use char because int might match the return type of a gcc2
15124     builtin and then its argument prototype would still apply.  */
15125 char $ac_func();
15126
15127 int main() {
15128
15129 /* The GNU C library defines this for functions which it implements
15130     to always fail with ENOSYS.  Some functions are actually named
15131     something starting with __ and the normal name is an alias.  */
15132 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15133 choke me
15134 #else
15135 $ac_func();
15136 #endif
15137
15138 ; return 0; }
15139 EOF
15140 if { (eval echo configure:15141: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15141   rm -rf conftest*
15142   eval "ac_cv_func_$ac_func=yes"
15143 else
15144   echo "configure: failed program was:" >&5
15145   cat conftest.$ac_ext >&5
15146   rm -rf conftest*
15147   eval "ac_cv_func_$ac_func=no"
15148 fi
15149 rm -f conftest*
15150 fi
15151
15152 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15153   echo "$ac_t""yes" 1>&6
15154     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15155   cat >> confdefs.h <<EOF
15156 #define $ac_tr_func 1
15157 EOF
15158
15159 else
15160   echo "$ac_t""no" 1>&6
15161 fi
15162 done
15163
15164   fi
15165
15166
15167
15168   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
15169 echo "configure:15170: checking for _isnanl declaration" >&5
15170   if test x${glibcpp_cv_func__isnanl_use+set} != xset; then
15171     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
15172   echo $ac_n "(cached) $ac_c" 1>&6
15173 else
15174
15175
15176       ac_ext=C
15177 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15178 ac_cpp='$CXXCPP $CPPFLAGS'
15179 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15180 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15181 cross_compiling=$ac_cv_prog_cxx_cross
15182
15183       cat > conftest.$ac_ext <<EOF
15184 #line 15185 "configure"
15185 #include "confdefs.h"
15186 #include <math.h>
15187 int main() {
15188  _isnanl(0);
15189 ; return 0; }
15190 EOF
15191 if { (eval echo configure:15192: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15192   rm -rf conftest*
15193   glibcpp_cv_func__isnanl_use=yes
15194 else
15195   echo "configure: failed program was:" >&5
15196   cat conftest.$ac_ext >&5
15197   rm -rf conftest*
15198   glibcpp_cv_func__isnanl_use=no
15199 fi
15200 rm -f conftest*
15201       ac_ext=c
15202 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15203 ac_cpp='$CPP $CPPFLAGS'
15204 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15205 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15206 cross_compiling=$ac_cv_prog_cc_cross
15207
15208
15209 fi
15210
15211   fi
15212   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
15213   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
15214     for ac_func in _isnanl
15215 do
15216 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15217 echo "configure:15218: checking for $ac_func" >&5
15218 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15219   echo $ac_n "(cached) $ac_c" 1>&6
15220 else
15221   cat > conftest.$ac_ext <<EOF
15222 #line 15223 "configure"
15223 #include "confdefs.h"
15224 /* System header to define __stub macros and hopefully few prototypes,
15225     which can conflict with char $ac_func(); below.  */
15226 #include <assert.h>
15227 /* Override any gcc2 internal prototype to avoid an error.  */
15228 /* We use char because int might match the return type of a gcc2
15229     builtin and then its argument prototype would still apply.  */
15230 char $ac_func();
15231
15232 int main() {
15233
15234 /* The GNU C library defines this for functions which it implements
15235     to always fail with ENOSYS.  Some functions are actually named
15236     something starting with __ and the normal name is an alias.  */
15237 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15238 choke me
15239 #else
15240 $ac_func();
15241 #endif
15242
15243 ; return 0; }
15244 EOF
15245 if { (eval echo configure:15246: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15246   rm -rf conftest*
15247   eval "ac_cv_func_$ac_func=yes"
15248 else
15249   echo "configure: failed program was:" >&5
15250   cat conftest.$ac_ext >&5
15251   rm -rf conftest*
15252   eval "ac_cv_func_$ac_func=no"
15253 fi
15254 rm -f conftest*
15255 fi
15256
15257 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15258   echo "$ac_t""yes" 1>&6
15259     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15260   cat >> confdefs.h <<EOF
15261 #define $ac_tr_func 1
15262 EOF
15263
15264 else
15265   echo "$ac_t""no" 1>&6
15266 fi
15267 done
15268
15269   fi
15270
15271
15272   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
15273 echo "configure:15274: checking for _isinfl declaration" >&5
15274   if test x${glibcpp_cv_func__isinfl_use+set} != xset; then
15275     if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
15276   echo $ac_n "(cached) $ac_c" 1>&6
15277 else
15278
15279
15280       ac_ext=C
15281 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15282 ac_cpp='$CXXCPP $CPPFLAGS'
15283 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15284 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15285 cross_compiling=$ac_cv_prog_cxx_cross
15286
15287       cat > conftest.$ac_ext <<EOF
15288 #line 15289 "configure"
15289 #include "confdefs.h"
15290 #include <math.h>
15291 int main() {
15292  _isinfl(0);
15293 ; return 0; }
15294 EOF
15295 if { (eval echo configure:15296: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15296   rm -rf conftest*
15297   glibcpp_cv_func__isinfl_use=yes
15298 else
15299   echo "configure: failed program was:" >&5
15300   cat conftest.$ac_ext >&5
15301   rm -rf conftest*
15302   glibcpp_cv_func__isinfl_use=no
15303 fi
15304 rm -f conftest*
15305       ac_ext=c
15306 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15307 ac_cpp='$CPP $CPPFLAGS'
15308 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15309 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15310 cross_compiling=$ac_cv_prog_cc_cross
15311
15312
15313 fi
15314
15315   fi
15316   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
15317   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
15318     for ac_func in _isinfl
15319 do
15320 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15321 echo "configure:15322: checking for $ac_func" >&5
15322 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15323   echo $ac_n "(cached) $ac_c" 1>&6
15324 else
15325   cat > conftest.$ac_ext <<EOF
15326 #line 15327 "configure"
15327 #include "confdefs.h"
15328 /* System header to define __stub macros and hopefully few prototypes,
15329     which can conflict with char $ac_func(); below.  */
15330 #include <assert.h>
15331 /* Override any gcc2 internal prototype to avoid an error.  */
15332 /* We use char because int might match the return type of a gcc2
15333     builtin and then its argument prototype would still apply.  */
15334 char $ac_func();
15335
15336 int main() {
15337
15338 /* The GNU C library defines this for functions which it implements
15339     to always fail with ENOSYS.  Some functions are actually named
15340     something starting with __ and the normal name is an alias.  */
15341 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15342 choke me
15343 #else
15344 $ac_func();
15345 #endif
15346
15347 ; return 0; }
15348 EOF
15349 if { (eval echo configure:15350: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15350   rm -rf conftest*
15351   eval "ac_cv_func_$ac_func=yes"
15352 else
15353   echo "configure: failed program was:" >&5
15354   cat conftest.$ac_ext >&5
15355   rm -rf conftest*
15356   eval "ac_cv_func_$ac_func=no"
15357 fi
15358 rm -f conftest*
15359 fi
15360
15361 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15362   echo "$ac_t""yes" 1>&6
15363     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15364   cat >> confdefs.h <<EOF
15365 #define $ac_tr_func 1
15366 EOF
15367
15368 else
15369   echo "$ac_t""no" 1>&6
15370 fi
15371 done
15372
15373   fi
15374
15375
15376   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
15377 echo "configure:15378: checking for _copysignl declaration" >&5
15378   if test x${glibcpp_cv_func__copysignl_use+set} != xset; then
15379     if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
15380   echo $ac_n "(cached) $ac_c" 1>&6
15381 else
15382
15383
15384       ac_ext=C
15385 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15386 ac_cpp='$CXXCPP $CPPFLAGS'
15387 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15388 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15389 cross_compiling=$ac_cv_prog_cxx_cross
15390
15391       cat > conftest.$ac_ext <<EOF
15392 #line 15393 "configure"
15393 #include "confdefs.h"
15394 #include <math.h>
15395 int main() {
15396  _copysignl(0, 0);
15397 ; return 0; }
15398 EOF
15399 if { (eval echo configure:15400: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15400   rm -rf conftest*
15401   glibcpp_cv_func__copysignl_use=yes
15402 else
15403   echo "configure: failed program was:" >&5
15404   cat conftest.$ac_ext >&5
15405   rm -rf conftest*
15406   glibcpp_cv_func__copysignl_use=no
15407 fi
15408 rm -f conftest*
15409       ac_ext=c
15410 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15411 ac_cpp='$CPP $CPPFLAGS'
15412 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15413 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15414 cross_compiling=$ac_cv_prog_cc_cross
15415
15416
15417 fi
15418
15419   fi
15420   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
15421   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
15422     for ac_func in _copysignl
15423 do
15424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15425 echo "configure:15426: checking for $ac_func" >&5
15426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15427   echo $ac_n "(cached) $ac_c" 1>&6
15428 else
15429   cat > conftest.$ac_ext <<EOF
15430 #line 15431 "configure"
15431 #include "confdefs.h"
15432 /* System header to define __stub macros and hopefully few prototypes,
15433     which can conflict with char $ac_func(); below.  */
15434 #include <assert.h>
15435 /* Override any gcc2 internal prototype to avoid an error.  */
15436 /* We use char because int might match the return type of a gcc2
15437     builtin and then its argument prototype would still apply.  */
15438 char $ac_func();
15439
15440 int main() {
15441
15442 /* The GNU C library defines this for functions which it implements
15443     to always fail with ENOSYS.  Some functions are actually named
15444     something starting with __ and the normal name is an alias.  */
15445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15446 choke me
15447 #else
15448 $ac_func();
15449 #endif
15450
15451 ; return 0; }
15452 EOF
15453 if { (eval echo configure:15454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15454   rm -rf conftest*
15455   eval "ac_cv_func_$ac_func=yes"
15456 else
15457   echo "configure: failed program was:" >&5
15458   cat conftest.$ac_ext >&5
15459   rm -rf conftest*
15460   eval "ac_cv_func_$ac_func=no"
15461 fi
15462 rm -f conftest*
15463 fi
15464
15465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15466   echo "$ac_t""yes" 1>&6
15467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15468   cat >> confdefs.h <<EOF
15469 #define $ac_tr_func 1
15470 EOF
15471
15472 else
15473   echo "$ac_t""no" 1>&6
15474 fi
15475 done
15476
15477   fi
15478
15479
15480   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
15481 echo "configure:15482: checking for _acosl declaration" >&5
15482   if test x${glibcpp_cv_func__acosl_use+set} != xset; then
15483     if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
15484   echo $ac_n "(cached) $ac_c" 1>&6
15485 else
15486
15487
15488       ac_ext=C
15489 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15490 ac_cpp='$CXXCPP $CPPFLAGS'
15491 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15492 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15493 cross_compiling=$ac_cv_prog_cxx_cross
15494
15495       cat > conftest.$ac_ext <<EOF
15496 #line 15497 "configure"
15497 #include "confdefs.h"
15498 #include <math.h>
15499 int main() {
15500  _acosl(0);
15501 ; return 0; }
15502 EOF
15503 if { (eval echo configure:15504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15504   rm -rf conftest*
15505   glibcpp_cv_func__acosl_use=yes
15506 else
15507   echo "configure: failed program was:" >&5
15508   cat conftest.$ac_ext >&5
15509   rm -rf conftest*
15510   glibcpp_cv_func__acosl_use=no
15511 fi
15512 rm -f conftest*
15513       ac_ext=c
15514 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15515 ac_cpp='$CPP $CPPFLAGS'
15516 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15517 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15518 cross_compiling=$ac_cv_prog_cc_cross
15519
15520
15521 fi
15522
15523   fi
15524   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
15525   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
15526     for ac_func in _acosl
15527 do
15528 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15529 echo "configure:15530: checking for $ac_func" >&5
15530 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15531   echo $ac_n "(cached) $ac_c" 1>&6
15532 else
15533   cat > conftest.$ac_ext <<EOF
15534 #line 15535 "configure"
15535 #include "confdefs.h"
15536 /* System header to define __stub macros and hopefully few prototypes,
15537     which can conflict with char $ac_func(); below.  */
15538 #include <assert.h>
15539 /* Override any gcc2 internal prototype to avoid an error.  */
15540 /* We use char because int might match the return type of a gcc2
15541     builtin and then its argument prototype would still apply.  */
15542 char $ac_func();
15543
15544 int main() {
15545
15546 /* The GNU C library defines this for functions which it implements
15547     to always fail with ENOSYS.  Some functions are actually named
15548     something starting with __ and the normal name is an alias.  */
15549 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15550 choke me
15551 #else
15552 $ac_func();
15553 #endif
15554
15555 ; return 0; }
15556 EOF
15557 if { (eval echo configure:15558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15558   rm -rf conftest*
15559   eval "ac_cv_func_$ac_func=yes"
15560 else
15561   echo "configure: failed program was:" >&5
15562   cat conftest.$ac_ext >&5
15563   rm -rf conftest*
15564   eval "ac_cv_func_$ac_func=no"
15565 fi
15566 rm -f conftest*
15567 fi
15568
15569 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15570   echo "$ac_t""yes" 1>&6
15571     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15572   cat >> confdefs.h <<EOF
15573 #define $ac_tr_func 1
15574 EOF
15575
15576 else
15577   echo "$ac_t""no" 1>&6
15578 fi
15579 done
15580
15581   fi
15582
15583
15584   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
15585 echo "configure:15586: checking for _asinl declaration" >&5
15586   if test x${glibcpp_cv_func__asinl_use+set} != xset; then
15587     if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
15588   echo $ac_n "(cached) $ac_c" 1>&6
15589 else
15590
15591
15592       ac_ext=C
15593 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15594 ac_cpp='$CXXCPP $CPPFLAGS'
15595 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15596 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15597 cross_compiling=$ac_cv_prog_cxx_cross
15598
15599       cat > conftest.$ac_ext <<EOF
15600 #line 15601 "configure"
15601 #include "confdefs.h"
15602 #include <math.h>
15603 int main() {
15604  _asinl(0);
15605 ; return 0; }
15606 EOF
15607 if { (eval echo configure:15608: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15608   rm -rf conftest*
15609   glibcpp_cv_func__asinl_use=yes
15610 else
15611   echo "configure: failed program was:" >&5
15612   cat conftest.$ac_ext >&5
15613   rm -rf conftest*
15614   glibcpp_cv_func__asinl_use=no
15615 fi
15616 rm -f conftest*
15617       ac_ext=c
15618 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15619 ac_cpp='$CPP $CPPFLAGS'
15620 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15621 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15622 cross_compiling=$ac_cv_prog_cc_cross
15623
15624
15625 fi
15626
15627   fi
15628   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
15629   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
15630     for ac_func in _asinl
15631 do
15632 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15633 echo "configure:15634: checking for $ac_func" >&5
15634 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15635   echo $ac_n "(cached) $ac_c" 1>&6
15636 else
15637   cat > conftest.$ac_ext <<EOF
15638 #line 15639 "configure"
15639 #include "confdefs.h"
15640 /* System header to define __stub macros and hopefully few prototypes,
15641     which can conflict with char $ac_func(); below.  */
15642 #include <assert.h>
15643 /* Override any gcc2 internal prototype to avoid an error.  */
15644 /* We use char because int might match the return type of a gcc2
15645     builtin and then its argument prototype would still apply.  */
15646 char $ac_func();
15647
15648 int main() {
15649
15650 /* The GNU C library defines this for functions which it implements
15651     to always fail with ENOSYS.  Some functions are actually named
15652     something starting with __ and the normal name is an alias.  */
15653 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15654 choke me
15655 #else
15656 $ac_func();
15657 #endif
15658
15659 ; return 0; }
15660 EOF
15661 if { (eval echo configure:15662: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15662   rm -rf conftest*
15663   eval "ac_cv_func_$ac_func=yes"
15664 else
15665   echo "configure: failed program was:" >&5
15666   cat conftest.$ac_ext >&5
15667   rm -rf conftest*
15668   eval "ac_cv_func_$ac_func=no"
15669 fi
15670 rm -f conftest*
15671 fi
15672
15673 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15674   echo "$ac_t""yes" 1>&6
15675     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15676   cat >> confdefs.h <<EOF
15677 #define $ac_tr_func 1
15678 EOF
15679
15680 else
15681   echo "$ac_t""no" 1>&6
15682 fi
15683 done
15684
15685   fi
15686
15687
15688   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
15689 echo "configure:15690: checking for _atanl declaration" >&5
15690   if test x${glibcpp_cv_func__atanl_use+set} != xset; then
15691     if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
15692   echo $ac_n "(cached) $ac_c" 1>&6
15693 else
15694
15695
15696       ac_ext=C
15697 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15698 ac_cpp='$CXXCPP $CPPFLAGS'
15699 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15700 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15701 cross_compiling=$ac_cv_prog_cxx_cross
15702
15703       cat > conftest.$ac_ext <<EOF
15704 #line 15705 "configure"
15705 #include "confdefs.h"
15706 #include <math.h>
15707 int main() {
15708  _atanl(0);
15709 ; return 0; }
15710 EOF
15711 if { (eval echo configure:15712: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15712   rm -rf conftest*
15713   glibcpp_cv_func__atanl_use=yes
15714 else
15715   echo "configure: failed program was:" >&5
15716   cat conftest.$ac_ext >&5
15717   rm -rf conftest*
15718   glibcpp_cv_func__atanl_use=no
15719 fi
15720 rm -f conftest*
15721       ac_ext=c
15722 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15723 ac_cpp='$CPP $CPPFLAGS'
15724 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15725 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15726 cross_compiling=$ac_cv_prog_cc_cross
15727
15728
15729 fi
15730
15731   fi
15732   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
15733   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
15734     for ac_func in _atanl
15735 do
15736 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15737 echo "configure:15738: checking for $ac_func" >&5
15738 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15739   echo $ac_n "(cached) $ac_c" 1>&6
15740 else
15741   cat > conftest.$ac_ext <<EOF
15742 #line 15743 "configure"
15743 #include "confdefs.h"
15744 /* System header to define __stub macros and hopefully few prototypes,
15745     which can conflict with char $ac_func(); below.  */
15746 #include <assert.h>
15747 /* Override any gcc2 internal prototype to avoid an error.  */
15748 /* We use char because int might match the return type of a gcc2
15749     builtin and then its argument prototype would still apply.  */
15750 char $ac_func();
15751
15752 int main() {
15753
15754 /* The GNU C library defines this for functions which it implements
15755     to always fail with ENOSYS.  Some functions are actually named
15756     something starting with __ and the normal name is an alias.  */
15757 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15758 choke me
15759 #else
15760 $ac_func();
15761 #endif
15762
15763 ; return 0; }
15764 EOF
15765 if { (eval echo configure:15766: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15766   rm -rf conftest*
15767   eval "ac_cv_func_$ac_func=yes"
15768 else
15769   echo "configure: failed program was:" >&5
15770   cat conftest.$ac_ext >&5
15771   rm -rf conftest*
15772   eval "ac_cv_func_$ac_func=no"
15773 fi
15774 rm -f conftest*
15775 fi
15776
15777 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15778   echo "$ac_t""yes" 1>&6
15779     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15780   cat >> confdefs.h <<EOF
15781 #define $ac_tr_func 1
15782 EOF
15783
15784 else
15785   echo "$ac_t""no" 1>&6
15786 fi
15787 done
15788
15789   fi
15790
15791
15792   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
15793 echo "configure:15794: checking for _atan2l declaration" >&5
15794   if test x${glibcpp_cv_func__atan2l_use+set} != xset; then
15795     if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
15796   echo $ac_n "(cached) $ac_c" 1>&6
15797 else
15798
15799
15800       ac_ext=C
15801 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15802 ac_cpp='$CXXCPP $CPPFLAGS'
15803 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15804 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15805 cross_compiling=$ac_cv_prog_cxx_cross
15806
15807       cat > conftest.$ac_ext <<EOF
15808 #line 15809 "configure"
15809 #include "confdefs.h"
15810 #include <math.h>
15811 int main() {
15812  _atan2l(0, 0);
15813 ; return 0; }
15814 EOF
15815 if { (eval echo configure:15816: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15816   rm -rf conftest*
15817   glibcpp_cv_func__atan2l_use=yes
15818 else
15819   echo "configure: failed program was:" >&5
15820   cat conftest.$ac_ext >&5
15821   rm -rf conftest*
15822   glibcpp_cv_func__atan2l_use=no
15823 fi
15824 rm -f conftest*
15825       ac_ext=c
15826 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15827 ac_cpp='$CPP $CPPFLAGS'
15828 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15829 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15830 cross_compiling=$ac_cv_prog_cc_cross
15831
15832
15833 fi
15834
15835   fi
15836   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
15837   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
15838     for ac_func in _atan2l
15839 do
15840 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15841 echo "configure:15842: checking for $ac_func" >&5
15842 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15843   echo $ac_n "(cached) $ac_c" 1>&6
15844 else
15845   cat > conftest.$ac_ext <<EOF
15846 #line 15847 "configure"
15847 #include "confdefs.h"
15848 /* System header to define __stub macros and hopefully few prototypes,
15849     which can conflict with char $ac_func(); below.  */
15850 #include <assert.h>
15851 /* Override any gcc2 internal prototype to avoid an error.  */
15852 /* We use char because int might match the return type of a gcc2
15853     builtin and then its argument prototype would still apply.  */
15854 char $ac_func();
15855
15856 int main() {
15857
15858 /* The GNU C library defines this for functions which it implements
15859     to always fail with ENOSYS.  Some functions are actually named
15860     something starting with __ and the normal name is an alias.  */
15861 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15862 choke me
15863 #else
15864 $ac_func();
15865 #endif
15866
15867 ; return 0; }
15868 EOF
15869 if { (eval echo configure:15870: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15870   rm -rf conftest*
15871   eval "ac_cv_func_$ac_func=yes"
15872 else
15873   echo "configure: failed program was:" >&5
15874   cat conftest.$ac_ext >&5
15875   rm -rf conftest*
15876   eval "ac_cv_func_$ac_func=no"
15877 fi
15878 rm -f conftest*
15879 fi
15880
15881 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15882   echo "$ac_t""yes" 1>&6
15883     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15884   cat >> confdefs.h <<EOF
15885 #define $ac_tr_func 1
15886 EOF
15887
15888 else
15889   echo "$ac_t""no" 1>&6
15890 fi
15891 done
15892
15893   fi
15894
15895
15896   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
15897 echo "configure:15898: checking for _ceill declaration" >&5
15898   if test x${glibcpp_cv_func__ceill_use+set} != xset; then
15899     if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
15900   echo $ac_n "(cached) $ac_c" 1>&6
15901 else
15902
15903
15904       ac_ext=C
15905 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15906 ac_cpp='$CXXCPP $CPPFLAGS'
15907 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15908 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15909 cross_compiling=$ac_cv_prog_cxx_cross
15910
15911       cat > conftest.$ac_ext <<EOF
15912 #line 15913 "configure"
15913 #include "confdefs.h"
15914 #include <math.h>
15915 int main() {
15916  _ceill(0);
15917 ; return 0; }
15918 EOF
15919 if { (eval echo configure:15920: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15920   rm -rf conftest*
15921   glibcpp_cv_func__ceill_use=yes
15922 else
15923   echo "configure: failed program was:" >&5
15924   cat conftest.$ac_ext >&5
15925   rm -rf conftest*
15926   glibcpp_cv_func__ceill_use=no
15927 fi
15928 rm -f conftest*
15929       ac_ext=c
15930 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15931 ac_cpp='$CPP $CPPFLAGS'
15932 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15933 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15934 cross_compiling=$ac_cv_prog_cc_cross
15935
15936
15937 fi
15938
15939   fi
15940   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
15941   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
15942     for ac_func in _ceill
15943 do
15944 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15945 echo "configure:15946: checking for $ac_func" >&5
15946 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15947   echo $ac_n "(cached) $ac_c" 1>&6
15948 else
15949   cat > conftest.$ac_ext <<EOF
15950 #line 15951 "configure"
15951 #include "confdefs.h"
15952 /* System header to define __stub macros and hopefully few prototypes,
15953     which can conflict with char $ac_func(); below.  */
15954 #include <assert.h>
15955 /* Override any gcc2 internal prototype to avoid an error.  */
15956 /* We use char because int might match the return type of a gcc2
15957     builtin and then its argument prototype would still apply.  */
15958 char $ac_func();
15959
15960 int main() {
15961
15962 /* The GNU C library defines this for functions which it implements
15963     to always fail with ENOSYS.  Some functions are actually named
15964     something starting with __ and the normal name is an alias.  */
15965 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15966 choke me
15967 #else
15968 $ac_func();
15969 #endif
15970
15971 ; return 0; }
15972 EOF
15973 if { (eval echo configure:15974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15974   rm -rf conftest*
15975   eval "ac_cv_func_$ac_func=yes"
15976 else
15977   echo "configure: failed program was:" >&5
15978   cat conftest.$ac_ext >&5
15979   rm -rf conftest*
15980   eval "ac_cv_func_$ac_func=no"
15981 fi
15982 rm -f conftest*
15983 fi
15984
15985 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15986   echo "$ac_t""yes" 1>&6
15987     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15988   cat >> confdefs.h <<EOF
15989 #define $ac_tr_func 1
15990 EOF
15991
15992 else
15993   echo "$ac_t""no" 1>&6
15994 fi
15995 done
15996
15997   fi
15998
15999
16000   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
16001 echo "configure:16002: checking for _cosl declaration" >&5
16002   if test x${glibcpp_cv_func__cosl_use+set} != xset; then
16003     if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
16004   echo $ac_n "(cached) $ac_c" 1>&6
16005 else
16006
16007
16008       ac_ext=C
16009 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16010 ac_cpp='$CXXCPP $CPPFLAGS'
16011 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16012 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16013 cross_compiling=$ac_cv_prog_cxx_cross
16014
16015       cat > conftest.$ac_ext <<EOF
16016 #line 16017 "configure"
16017 #include "confdefs.h"
16018 #include <math.h>
16019 int main() {
16020  _cosl(0);
16021 ; return 0; }
16022 EOF
16023 if { (eval echo configure:16024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16024   rm -rf conftest*
16025   glibcpp_cv_func__cosl_use=yes
16026 else
16027   echo "configure: failed program was:" >&5
16028   cat conftest.$ac_ext >&5
16029   rm -rf conftest*
16030   glibcpp_cv_func__cosl_use=no
16031 fi
16032 rm -f conftest*
16033       ac_ext=c
16034 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16035 ac_cpp='$CPP $CPPFLAGS'
16036 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16037 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16038 cross_compiling=$ac_cv_prog_cc_cross
16039
16040
16041 fi
16042
16043   fi
16044   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
16045   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
16046     for ac_func in _cosl
16047 do
16048 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16049 echo "configure:16050: checking for $ac_func" >&5
16050 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16051   echo $ac_n "(cached) $ac_c" 1>&6
16052 else
16053   cat > conftest.$ac_ext <<EOF
16054 #line 16055 "configure"
16055 #include "confdefs.h"
16056 /* System header to define __stub macros and hopefully few prototypes,
16057     which can conflict with char $ac_func(); below.  */
16058 #include <assert.h>
16059 /* Override any gcc2 internal prototype to avoid an error.  */
16060 /* We use char because int might match the return type of a gcc2
16061     builtin and then its argument prototype would still apply.  */
16062 char $ac_func();
16063
16064 int main() {
16065
16066 /* The GNU C library defines this for functions which it implements
16067     to always fail with ENOSYS.  Some functions are actually named
16068     something starting with __ and the normal name is an alias.  */
16069 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16070 choke me
16071 #else
16072 $ac_func();
16073 #endif
16074
16075 ; return 0; }
16076 EOF
16077 if { (eval echo configure:16078: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16078   rm -rf conftest*
16079   eval "ac_cv_func_$ac_func=yes"
16080 else
16081   echo "configure: failed program was:" >&5
16082   cat conftest.$ac_ext >&5
16083   rm -rf conftest*
16084   eval "ac_cv_func_$ac_func=no"
16085 fi
16086 rm -f conftest*
16087 fi
16088
16089 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16090   echo "$ac_t""yes" 1>&6
16091     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16092   cat >> confdefs.h <<EOF
16093 #define $ac_tr_func 1
16094 EOF
16095
16096 else
16097   echo "$ac_t""no" 1>&6
16098 fi
16099 done
16100
16101   fi
16102
16103
16104   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
16105 echo "configure:16106: checking for _coshl declaration" >&5
16106   if test x${glibcpp_cv_func__coshl_use+set} != xset; then
16107     if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
16108   echo $ac_n "(cached) $ac_c" 1>&6
16109 else
16110
16111
16112       ac_ext=C
16113 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16114 ac_cpp='$CXXCPP $CPPFLAGS'
16115 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16116 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16117 cross_compiling=$ac_cv_prog_cxx_cross
16118
16119       cat > conftest.$ac_ext <<EOF
16120 #line 16121 "configure"
16121 #include "confdefs.h"
16122 #include <math.h>
16123 int main() {
16124  _coshl(0);
16125 ; return 0; }
16126 EOF
16127 if { (eval echo configure:16128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16128   rm -rf conftest*
16129   glibcpp_cv_func__coshl_use=yes
16130 else
16131   echo "configure: failed program was:" >&5
16132   cat conftest.$ac_ext >&5
16133   rm -rf conftest*
16134   glibcpp_cv_func__coshl_use=no
16135 fi
16136 rm -f conftest*
16137       ac_ext=c
16138 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16139 ac_cpp='$CPP $CPPFLAGS'
16140 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16141 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16142 cross_compiling=$ac_cv_prog_cc_cross
16143
16144
16145 fi
16146
16147   fi
16148   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
16149   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
16150     for ac_func in _coshl
16151 do
16152 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16153 echo "configure:16154: checking for $ac_func" >&5
16154 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16155   echo $ac_n "(cached) $ac_c" 1>&6
16156 else
16157   cat > conftest.$ac_ext <<EOF
16158 #line 16159 "configure"
16159 #include "confdefs.h"
16160 /* System header to define __stub macros and hopefully few prototypes,
16161     which can conflict with char $ac_func(); below.  */
16162 #include <assert.h>
16163 /* Override any gcc2 internal prototype to avoid an error.  */
16164 /* We use char because int might match the return type of a gcc2
16165     builtin and then its argument prototype would still apply.  */
16166 char $ac_func();
16167
16168 int main() {
16169
16170 /* The GNU C library defines this for functions which it implements
16171     to always fail with ENOSYS.  Some functions are actually named
16172     something starting with __ and the normal name is an alias.  */
16173 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16174 choke me
16175 #else
16176 $ac_func();
16177 #endif
16178
16179 ; return 0; }
16180 EOF
16181 if { (eval echo configure:16182: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16182   rm -rf conftest*
16183   eval "ac_cv_func_$ac_func=yes"
16184 else
16185   echo "configure: failed program was:" >&5
16186   cat conftest.$ac_ext >&5
16187   rm -rf conftest*
16188   eval "ac_cv_func_$ac_func=no"
16189 fi
16190 rm -f conftest*
16191 fi
16192
16193 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16194   echo "$ac_t""yes" 1>&6
16195     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16196   cat >> confdefs.h <<EOF
16197 #define $ac_tr_func 1
16198 EOF
16199
16200 else
16201   echo "$ac_t""no" 1>&6
16202 fi
16203 done
16204
16205   fi
16206
16207
16208   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
16209 echo "configure:16210: checking for _expl declaration" >&5
16210   if test x${glibcpp_cv_func__expl_use+set} != xset; then
16211     if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
16212   echo $ac_n "(cached) $ac_c" 1>&6
16213 else
16214
16215
16216       ac_ext=C
16217 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16218 ac_cpp='$CXXCPP $CPPFLAGS'
16219 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16220 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16221 cross_compiling=$ac_cv_prog_cxx_cross
16222
16223       cat > conftest.$ac_ext <<EOF
16224 #line 16225 "configure"
16225 #include "confdefs.h"
16226 #include <math.h>
16227 int main() {
16228  _expl(0);
16229 ; return 0; }
16230 EOF
16231 if { (eval echo configure:16232: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16232   rm -rf conftest*
16233   glibcpp_cv_func__expl_use=yes
16234 else
16235   echo "configure: failed program was:" >&5
16236   cat conftest.$ac_ext >&5
16237   rm -rf conftest*
16238   glibcpp_cv_func__expl_use=no
16239 fi
16240 rm -f conftest*
16241       ac_ext=c
16242 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16243 ac_cpp='$CPP $CPPFLAGS'
16244 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16245 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16246 cross_compiling=$ac_cv_prog_cc_cross
16247
16248
16249 fi
16250
16251   fi
16252   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
16253   if test x$glibcpp_cv_func__expl_use = x"yes"; then
16254     for ac_func in _expl
16255 do
16256 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16257 echo "configure:16258: checking for $ac_func" >&5
16258 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16259   echo $ac_n "(cached) $ac_c" 1>&6
16260 else
16261   cat > conftest.$ac_ext <<EOF
16262 #line 16263 "configure"
16263 #include "confdefs.h"
16264 /* System header to define __stub macros and hopefully few prototypes,
16265     which can conflict with char $ac_func(); below.  */
16266 #include <assert.h>
16267 /* Override any gcc2 internal prototype to avoid an error.  */
16268 /* We use char because int might match the return type of a gcc2
16269     builtin and then its argument prototype would still apply.  */
16270 char $ac_func();
16271
16272 int main() {
16273
16274 /* The GNU C library defines this for functions which it implements
16275     to always fail with ENOSYS.  Some functions are actually named
16276     something starting with __ and the normal name is an alias.  */
16277 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16278 choke me
16279 #else
16280 $ac_func();
16281 #endif
16282
16283 ; return 0; }
16284 EOF
16285 if { (eval echo configure:16286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16286   rm -rf conftest*
16287   eval "ac_cv_func_$ac_func=yes"
16288 else
16289   echo "configure: failed program was:" >&5
16290   cat conftest.$ac_ext >&5
16291   rm -rf conftest*
16292   eval "ac_cv_func_$ac_func=no"
16293 fi
16294 rm -f conftest*
16295 fi
16296
16297 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16298   echo "$ac_t""yes" 1>&6
16299     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16300   cat >> confdefs.h <<EOF
16301 #define $ac_tr_func 1
16302 EOF
16303
16304 else
16305   echo "$ac_t""no" 1>&6
16306 fi
16307 done
16308
16309   fi
16310
16311
16312   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
16313 echo "configure:16314: checking for _fabsl declaration" >&5
16314   if test x${glibcpp_cv_func__fabsl_use+set} != xset; then
16315     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
16316   echo $ac_n "(cached) $ac_c" 1>&6
16317 else
16318
16319
16320       ac_ext=C
16321 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16322 ac_cpp='$CXXCPP $CPPFLAGS'
16323 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16324 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16325 cross_compiling=$ac_cv_prog_cxx_cross
16326
16327       cat > conftest.$ac_ext <<EOF
16328 #line 16329 "configure"
16329 #include "confdefs.h"
16330 #include <math.h>
16331 int main() {
16332  _fabsl(0);
16333 ; return 0; }
16334 EOF
16335 if { (eval echo configure:16336: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16336   rm -rf conftest*
16337   glibcpp_cv_func__fabsl_use=yes
16338 else
16339   echo "configure: failed program was:" >&5
16340   cat conftest.$ac_ext >&5
16341   rm -rf conftest*
16342   glibcpp_cv_func__fabsl_use=no
16343 fi
16344 rm -f conftest*
16345       ac_ext=c
16346 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16347 ac_cpp='$CPP $CPPFLAGS'
16348 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16349 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16350 cross_compiling=$ac_cv_prog_cc_cross
16351
16352
16353 fi
16354
16355   fi
16356   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
16357   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
16358     for ac_func in _fabsl
16359 do
16360 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16361 echo "configure:16362: checking for $ac_func" >&5
16362 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16363   echo $ac_n "(cached) $ac_c" 1>&6
16364 else
16365   cat > conftest.$ac_ext <<EOF
16366 #line 16367 "configure"
16367 #include "confdefs.h"
16368 /* System header to define __stub macros and hopefully few prototypes,
16369     which can conflict with char $ac_func(); below.  */
16370 #include <assert.h>
16371 /* Override any gcc2 internal prototype to avoid an error.  */
16372 /* We use char because int might match the return type of a gcc2
16373     builtin and then its argument prototype would still apply.  */
16374 char $ac_func();
16375
16376 int main() {
16377
16378 /* The GNU C library defines this for functions which it implements
16379     to always fail with ENOSYS.  Some functions are actually named
16380     something starting with __ and the normal name is an alias.  */
16381 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16382 choke me
16383 #else
16384 $ac_func();
16385 #endif
16386
16387 ; return 0; }
16388 EOF
16389 if { (eval echo configure:16390: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16390   rm -rf conftest*
16391   eval "ac_cv_func_$ac_func=yes"
16392 else
16393   echo "configure: failed program was:" >&5
16394   cat conftest.$ac_ext >&5
16395   rm -rf conftest*
16396   eval "ac_cv_func_$ac_func=no"
16397 fi
16398 rm -f conftest*
16399 fi
16400
16401 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16402   echo "$ac_t""yes" 1>&6
16403     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16404   cat >> confdefs.h <<EOF
16405 #define $ac_tr_func 1
16406 EOF
16407
16408 else
16409   echo "$ac_t""no" 1>&6
16410 fi
16411 done
16412
16413   fi
16414
16415
16416   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
16417 echo "configure:16418: checking for _floorl declaration" >&5
16418   if test x${glibcpp_cv_func__floorl_use+set} != xset; then
16419     if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
16420   echo $ac_n "(cached) $ac_c" 1>&6
16421 else
16422
16423
16424       ac_ext=C
16425 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16426 ac_cpp='$CXXCPP $CPPFLAGS'
16427 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16428 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16429 cross_compiling=$ac_cv_prog_cxx_cross
16430
16431       cat > conftest.$ac_ext <<EOF
16432 #line 16433 "configure"
16433 #include "confdefs.h"
16434 #include <math.h>
16435 int main() {
16436  _floorl(0);
16437 ; return 0; }
16438 EOF
16439 if { (eval echo configure:16440: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16440   rm -rf conftest*
16441   glibcpp_cv_func__floorl_use=yes
16442 else
16443   echo "configure: failed program was:" >&5
16444   cat conftest.$ac_ext >&5
16445   rm -rf conftest*
16446   glibcpp_cv_func__floorl_use=no
16447 fi
16448 rm -f conftest*
16449       ac_ext=c
16450 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16451 ac_cpp='$CPP $CPPFLAGS'
16452 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16453 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16454 cross_compiling=$ac_cv_prog_cc_cross
16455
16456
16457 fi
16458
16459   fi
16460   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
16461   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
16462     for ac_func in _floorl
16463 do
16464 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16465 echo "configure:16466: checking for $ac_func" >&5
16466 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16467   echo $ac_n "(cached) $ac_c" 1>&6
16468 else
16469   cat > conftest.$ac_ext <<EOF
16470 #line 16471 "configure"
16471 #include "confdefs.h"
16472 /* System header to define __stub macros and hopefully few prototypes,
16473     which can conflict with char $ac_func(); below.  */
16474 #include <assert.h>
16475 /* Override any gcc2 internal prototype to avoid an error.  */
16476 /* We use char because int might match the return type of a gcc2
16477     builtin and then its argument prototype would still apply.  */
16478 char $ac_func();
16479
16480 int main() {
16481
16482 /* The GNU C library defines this for functions which it implements
16483     to always fail with ENOSYS.  Some functions are actually named
16484     something starting with __ and the normal name is an alias.  */
16485 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16486 choke me
16487 #else
16488 $ac_func();
16489 #endif
16490
16491 ; return 0; }
16492 EOF
16493 if { (eval echo configure:16494: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16494   rm -rf conftest*
16495   eval "ac_cv_func_$ac_func=yes"
16496 else
16497   echo "configure: failed program was:" >&5
16498   cat conftest.$ac_ext >&5
16499   rm -rf conftest*
16500   eval "ac_cv_func_$ac_func=no"
16501 fi
16502 rm -f conftest*
16503 fi
16504
16505 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16506   echo "$ac_t""yes" 1>&6
16507     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16508   cat >> confdefs.h <<EOF
16509 #define $ac_tr_func 1
16510 EOF
16511
16512 else
16513   echo "$ac_t""no" 1>&6
16514 fi
16515 done
16516
16517   fi
16518
16519
16520   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
16521 echo "configure:16522: checking for _fmodl declaration" >&5
16522   if test x${glibcpp_cv_func__fmodl_use+set} != xset; then
16523     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
16524   echo $ac_n "(cached) $ac_c" 1>&6
16525 else
16526
16527
16528       ac_ext=C
16529 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16530 ac_cpp='$CXXCPP $CPPFLAGS'
16531 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16532 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16533 cross_compiling=$ac_cv_prog_cxx_cross
16534
16535       cat > conftest.$ac_ext <<EOF
16536 #line 16537 "configure"
16537 #include "confdefs.h"
16538 #include <math.h>
16539 int main() {
16540  _fmodl(0, 0);
16541 ; return 0; }
16542 EOF
16543 if { (eval echo configure:16544: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16544   rm -rf conftest*
16545   glibcpp_cv_func__fmodl_use=yes
16546 else
16547   echo "configure: failed program was:" >&5
16548   cat conftest.$ac_ext >&5
16549   rm -rf conftest*
16550   glibcpp_cv_func__fmodl_use=no
16551 fi
16552 rm -f conftest*
16553       ac_ext=c
16554 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16555 ac_cpp='$CPP $CPPFLAGS'
16556 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16557 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16558 cross_compiling=$ac_cv_prog_cc_cross
16559
16560
16561 fi
16562
16563   fi
16564   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
16565   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
16566     for ac_func in _fmodl
16567 do
16568 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16569 echo "configure:16570: checking for $ac_func" >&5
16570 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16571   echo $ac_n "(cached) $ac_c" 1>&6
16572 else
16573   cat > conftest.$ac_ext <<EOF
16574 #line 16575 "configure"
16575 #include "confdefs.h"
16576 /* System header to define __stub macros and hopefully few prototypes,
16577     which can conflict with char $ac_func(); below.  */
16578 #include <assert.h>
16579 /* Override any gcc2 internal prototype to avoid an error.  */
16580 /* We use char because int might match the return type of a gcc2
16581     builtin and then its argument prototype would still apply.  */
16582 char $ac_func();
16583
16584 int main() {
16585
16586 /* The GNU C library defines this for functions which it implements
16587     to always fail with ENOSYS.  Some functions are actually named
16588     something starting with __ and the normal name is an alias.  */
16589 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16590 choke me
16591 #else
16592 $ac_func();
16593 #endif
16594
16595 ; return 0; }
16596 EOF
16597 if { (eval echo configure:16598: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16598   rm -rf conftest*
16599   eval "ac_cv_func_$ac_func=yes"
16600 else
16601   echo "configure: failed program was:" >&5
16602   cat conftest.$ac_ext >&5
16603   rm -rf conftest*
16604   eval "ac_cv_func_$ac_func=no"
16605 fi
16606 rm -f conftest*
16607 fi
16608
16609 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16610   echo "$ac_t""yes" 1>&6
16611     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16612   cat >> confdefs.h <<EOF
16613 #define $ac_tr_func 1
16614 EOF
16615
16616 else
16617   echo "$ac_t""no" 1>&6
16618 fi
16619 done
16620
16621   fi
16622
16623
16624   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
16625 echo "configure:16626: checking for _frexpl declaration" >&5
16626   if test x${glibcpp_cv_func__frexpl_use+set} != xset; then
16627     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
16628   echo $ac_n "(cached) $ac_c" 1>&6
16629 else
16630
16631
16632       ac_ext=C
16633 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16634 ac_cpp='$CXXCPP $CPPFLAGS'
16635 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16636 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16637 cross_compiling=$ac_cv_prog_cxx_cross
16638
16639       cat > conftest.$ac_ext <<EOF
16640 #line 16641 "configure"
16641 #include "confdefs.h"
16642 #include <math.h>
16643 int main() {
16644  _frexpl(0, 0);
16645 ; return 0; }
16646 EOF
16647 if { (eval echo configure:16648: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16648   rm -rf conftest*
16649   glibcpp_cv_func__frexpl_use=yes
16650 else
16651   echo "configure: failed program was:" >&5
16652   cat conftest.$ac_ext >&5
16653   rm -rf conftest*
16654   glibcpp_cv_func__frexpl_use=no
16655 fi
16656 rm -f conftest*
16657       ac_ext=c
16658 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16659 ac_cpp='$CPP $CPPFLAGS'
16660 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16661 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16662 cross_compiling=$ac_cv_prog_cc_cross
16663
16664
16665 fi
16666
16667   fi
16668   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
16669   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
16670     for ac_func in _frexpl
16671 do
16672 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16673 echo "configure:16674: checking for $ac_func" >&5
16674 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16675   echo $ac_n "(cached) $ac_c" 1>&6
16676 else
16677   cat > conftest.$ac_ext <<EOF
16678 #line 16679 "configure"
16679 #include "confdefs.h"
16680 /* System header to define __stub macros and hopefully few prototypes,
16681     which can conflict with char $ac_func(); below.  */
16682 #include <assert.h>
16683 /* Override any gcc2 internal prototype to avoid an error.  */
16684 /* We use char because int might match the return type of a gcc2
16685     builtin and then its argument prototype would still apply.  */
16686 char $ac_func();
16687
16688 int main() {
16689
16690 /* The GNU C library defines this for functions which it implements
16691     to always fail with ENOSYS.  Some functions are actually named
16692     something starting with __ and the normal name is an alias.  */
16693 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16694 choke me
16695 #else
16696 $ac_func();
16697 #endif
16698
16699 ; return 0; }
16700 EOF
16701 if { (eval echo configure:16702: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16702   rm -rf conftest*
16703   eval "ac_cv_func_$ac_func=yes"
16704 else
16705   echo "configure: failed program was:" >&5
16706   cat conftest.$ac_ext >&5
16707   rm -rf conftest*
16708   eval "ac_cv_func_$ac_func=no"
16709 fi
16710 rm -f conftest*
16711 fi
16712
16713 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16714   echo "$ac_t""yes" 1>&6
16715     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16716   cat >> confdefs.h <<EOF
16717 #define $ac_tr_func 1
16718 EOF
16719
16720 else
16721   echo "$ac_t""no" 1>&6
16722 fi
16723 done
16724
16725   fi
16726
16727
16728   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
16729 echo "configure:16730: checking for _ldexpl declaration" >&5
16730   if test x${glibcpp_cv_func__ldexpl_use+set} != xset; then
16731     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
16732   echo $ac_n "(cached) $ac_c" 1>&6
16733 else
16734
16735
16736       ac_ext=C
16737 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16738 ac_cpp='$CXXCPP $CPPFLAGS'
16739 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16740 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16741 cross_compiling=$ac_cv_prog_cxx_cross
16742
16743       cat > conftest.$ac_ext <<EOF
16744 #line 16745 "configure"
16745 #include "confdefs.h"
16746 #include <math.h>
16747 int main() {
16748  _ldexpl(0, 0);
16749 ; return 0; }
16750 EOF
16751 if { (eval echo configure:16752: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16752   rm -rf conftest*
16753   glibcpp_cv_func__ldexpl_use=yes
16754 else
16755   echo "configure: failed program was:" >&5
16756   cat conftest.$ac_ext >&5
16757   rm -rf conftest*
16758   glibcpp_cv_func__ldexpl_use=no
16759 fi
16760 rm -f conftest*
16761       ac_ext=c
16762 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16763 ac_cpp='$CPP $CPPFLAGS'
16764 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16765 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16766 cross_compiling=$ac_cv_prog_cc_cross
16767
16768
16769 fi
16770
16771   fi
16772   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
16773   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
16774     for ac_func in _ldexpl
16775 do
16776 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16777 echo "configure:16778: checking for $ac_func" >&5
16778 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16779   echo $ac_n "(cached) $ac_c" 1>&6
16780 else
16781   cat > conftest.$ac_ext <<EOF
16782 #line 16783 "configure"
16783 #include "confdefs.h"
16784 /* System header to define __stub macros and hopefully few prototypes,
16785     which can conflict with char $ac_func(); below.  */
16786 #include <assert.h>
16787 /* Override any gcc2 internal prototype to avoid an error.  */
16788 /* We use char because int might match the return type of a gcc2
16789     builtin and then its argument prototype would still apply.  */
16790 char $ac_func();
16791
16792 int main() {
16793
16794 /* The GNU C library defines this for functions which it implements
16795     to always fail with ENOSYS.  Some functions are actually named
16796     something starting with __ and the normal name is an alias.  */
16797 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16798 choke me
16799 #else
16800 $ac_func();
16801 #endif
16802
16803 ; return 0; }
16804 EOF
16805 if { (eval echo configure:16806: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16806   rm -rf conftest*
16807   eval "ac_cv_func_$ac_func=yes"
16808 else
16809   echo "configure: failed program was:" >&5
16810   cat conftest.$ac_ext >&5
16811   rm -rf conftest*
16812   eval "ac_cv_func_$ac_func=no"
16813 fi
16814 rm -f conftest*
16815 fi
16816
16817 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16818   echo "$ac_t""yes" 1>&6
16819     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16820   cat >> confdefs.h <<EOF
16821 #define $ac_tr_func 1
16822 EOF
16823
16824 else
16825   echo "$ac_t""no" 1>&6
16826 fi
16827 done
16828
16829   fi
16830
16831
16832   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
16833 echo "configure:16834: checking for _logl declaration" >&5
16834   if test x${glibcpp_cv_func__logl_use+set} != xset; then
16835     if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
16836   echo $ac_n "(cached) $ac_c" 1>&6
16837 else
16838
16839
16840       ac_ext=C
16841 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16842 ac_cpp='$CXXCPP $CPPFLAGS'
16843 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16844 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16845 cross_compiling=$ac_cv_prog_cxx_cross
16846
16847       cat > conftest.$ac_ext <<EOF
16848 #line 16849 "configure"
16849 #include "confdefs.h"
16850 #include <math.h>
16851 int main() {
16852  _logl(0);
16853 ; return 0; }
16854 EOF
16855 if { (eval echo configure:16856: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16856   rm -rf conftest*
16857   glibcpp_cv_func__logl_use=yes
16858 else
16859   echo "configure: failed program was:" >&5
16860   cat conftest.$ac_ext >&5
16861   rm -rf conftest*
16862   glibcpp_cv_func__logl_use=no
16863 fi
16864 rm -f conftest*
16865       ac_ext=c
16866 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16867 ac_cpp='$CPP $CPPFLAGS'
16868 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16869 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16870 cross_compiling=$ac_cv_prog_cc_cross
16871
16872
16873 fi
16874
16875   fi
16876   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
16877   if test x$glibcpp_cv_func__logl_use = x"yes"; then
16878     for ac_func in _logl
16879 do
16880 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16881 echo "configure:16882: checking for $ac_func" >&5
16882 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16883   echo $ac_n "(cached) $ac_c" 1>&6
16884 else
16885   cat > conftest.$ac_ext <<EOF
16886 #line 16887 "configure"
16887 #include "confdefs.h"
16888 /* System header to define __stub macros and hopefully few prototypes,
16889     which can conflict with char $ac_func(); below.  */
16890 #include <assert.h>
16891 /* Override any gcc2 internal prototype to avoid an error.  */
16892 /* We use char because int might match the return type of a gcc2
16893     builtin and then its argument prototype would still apply.  */
16894 char $ac_func();
16895
16896 int main() {
16897
16898 /* The GNU C library defines this for functions which it implements
16899     to always fail with ENOSYS.  Some functions are actually named
16900     something starting with __ and the normal name is an alias.  */
16901 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16902 choke me
16903 #else
16904 $ac_func();
16905 #endif
16906
16907 ; return 0; }
16908 EOF
16909 if { (eval echo configure:16910: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16910   rm -rf conftest*
16911   eval "ac_cv_func_$ac_func=yes"
16912 else
16913   echo "configure: failed program was:" >&5
16914   cat conftest.$ac_ext >&5
16915   rm -rf conftest*
16916   eval "ac_cv_func_$ac_func=no"
16917 fi
16918 rm -f conftest*
16919 fi
16920
16921 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16922   echo "$ac_t""yes" 1>&6
16923     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16924   cat >> confdefs.h <<EOF
16925 #define $ac_tr_func 1
16926 EOF
16927
16928 else
16929   echo "$ac_t""no" 1>&6
16930 fi
16931 done
16932
16933   fi
16934
16935
16936   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
16937 echo "configure:16938: checking for _log10l declaration" >&5
16938   if test x${glibcpp_cv_func__log10l_use+set} != xset; then
16939     if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
16940   echo $ac_n "(cached) $ac_c" 1>&6
16941 else
16942
16943
16944       ac_ext=C
16945 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16946 ac_cpp='$CXXCPP $CPPFLAGS'
16947 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16948 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16949 cross_compiling=$ac_cv_prog_cxx_cross
16950
16951       cat > conftest.$ac_ext <<EOF
16952 #line 16953 "configure"
16953 #include "confdefs.h"
16954 #include <math.h>
16955 int main() {
16956  _log10l(0);
16957 ; return 0; }
16958 EOF
16959 if { (eval echo configure:16960: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16960   rm -rf conftest*
16961   glibcpp_cv_func__log10l_use=yes
16962 else
16963   echo "configure: failed program was:" >&5
16964   cat conftest.$ac_ext >&5
16965   rm -rf conftest*
16966   glibcpp_cv_func__log10l_use=no
16967 fi
16968 rm -f conftest*
16969       ac_ext=c
16970 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16971 ac_cpp='$CPP $CPPFLAGS'
16972 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16973 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16974 cross_compiling=$ac_cv_prog_cc_cross
16975
16976
16977 fi
16978
16979   fi
16980   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
16981   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
16982     for ac_func in _log10l
16983 do
16984 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16985 echo "configure:16986: checking for $ac_func" >&5
16986 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16987   echo $ac_n "(cached) $ac_c" 1>&6
16988 else
16989   cat > conftest.$ac_ext <<EOF
16990 #line 16991 "configure"
16991 #include "confdefs.h"
16992 /* System header to define __stub macros and hopefully few prototypes,
16993     which can conflict with char $ac_func(); below.  */
16994 #include <assert.h>
16995 /* Override any gcc2 internal prototype to avoid an error.  */
16996 /* We use char because int might match the return type of a gcc2
16997     builtin and then its argument prototype would still apply.  */
16998 char $ac_func();
16999
17000 int main() {
17001
17002 /* The GNU C library defines this for functions which it implements
17003     to always fail with ENOSYS.  Some functions are actually named
17004     something starting with __ and the normal name is an alias.  */
17005 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17006 choke me
17007 #else
17008 $ac_func();
17009 #endif
17010
17011 ; return 0; }
17012 EOF
17013 if { (eval echo configure:17014: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17014   rm -rf conftest*
17015   eval "ac_cv_func_$ac_func=yes"
17016 else
17017   echo "configure: failed program was:" >&5
17018   cat conftest.$ac_ext >&5
17019   rm -rf conftest*
17020   eval "ac_cv_func_$ac_func=no"
17021 fi
17022 rm -f conftest*
17023 fi
17024
17025 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17026   echo "$ac_t""yes" 1>&6
17027     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17028   cat >> confdefs.h <<EOF
17029 #define $ac_tr_func 1
17030 EOF
17031
17032 else
17033   echo "$ac_t""no" 1>&6
17034 fi
17035 done
17036
17037   fi
17038
17039
17040   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
17041 echo "configure:17042: checking for _modfl declaration" >&5
17042   if test x${glibcpp_cv_func__modfl_use+set} != xset; then
17043     if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
17044   echo $ac_n "(cached) $ac_c" 1>&6
17045 else
17046
17047
17048       ac_ext=C
17049 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17050 ac_cpp='$CXXCPP $CPPFLAGS'
17051 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17052 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17053 cross_compiling=$ac_cv_prog_cxx_cross
17054
17055       cat > conftest.$ac_ext <<EOF
17056 #line 17057 "configure"
17057 #include "confdefs.h"
17058 #include <math.h>
17059 int main() {
17060  _modfl(0, 0);
17061 ; return 0; }
17062 EOF
17063 if { (eval echo configure:17064: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17064   rm -rf conftest*
17065   glibcpp_cv_func__modfl_use=yes
17066 else
17067   echo "configure: failed program was:" >&5
17068   cat conftest.$ac_ext >&5
17069   rm -rf conftest*
17070   glibcpp_cv_func__modfl_use=no
17071 fi
17072 rm -f conftest*
17073       ac_ext=c
17074 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17075 ac_cpp='$CPP $CPPFLAGS'
17076 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17077 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17078 cross_compiling=$ac_cv_prog_cc_cross
17079
17080
17081 fi
17082
17083   fi
17084   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
17085   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
17086     for ac_func in _modfl
17087 do
17088 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17089 echo "configure:17090: checking for $ac_func" >&5
17090 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17091   echo $ac_n "(cached) $ac_c" 1>&6
17092 else
17093   cat > conftest.$ac_ext <<EOF
17094 #line 17095 "configure"
17095 #include "confdefs.h"
17096 /* System header to define __stub macros and hopefully few prototypes,
17097     which can conflict with char $ac_func(); below.  */
17098 #include <assert.h>
17099 /* Override any gcc2 internal prototype to avoid an error.  */
17100 /* We use char because int might match the return type of a gcc2
17101     builtin and then its argument prototype would still apply.  */
17102 char $ac_func();
17103
17104 int main() {
17105
17106 /* The GNU C library defines this for functions which it implements
17107     to always fail with ENOSYS.  Some functions are actually named
17108     something starting with __ and the normal name is an alias.  */
17109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17110 choke me
17111 #else
17112 $ac_func();
17113 #endif
17114
17115 ; return 0; }
17116 EOF
17117 if { (eval echo configure:17118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17118   rm -rf conftest*
17119   eval "ac_cv_func_$ac_func=yes"
17120 else
17121   echo "configure: failed program was:" >&5
17122   cat conftest.$ac_ext >&5
17123   rm -rf conftest*
17124   eval "ac_cv_func_$ac_func=no"
17125 fi
17126 rm -f conftest*
17127 fi
17128
17129 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17130   echo "$ac_t""yes" 1>&6
17131     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17132   cat >> confdefs.h <<EOF
17133 #define $ac_tr_func 1
17134 EOF
17135
17136 else
17137   echo "$ac_t""no" 1>&6
17138 fi
17139 done
17140
17141   fi
17142
17143
17144   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
17145 echo "configure:17146: checking for _powl declaration" >&5
17146   if test x${glibcpp_cv_func__powl_use+set} != xset; then
17147     if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
17148   echo $ac_n "(cached) $ac_c" 1>&6
17149 else
17150
17151
17152       ac_ext=C
17153 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17154 ac_cpp='$CXXCPP $CPPFLAGS'
17155 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17156 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17157 cross_compiling=$ac_cv_prog_cxx_cross
17158
17159       cat > conftest.$ac_ext <<EOF
17160 #line 17161 "configure"
17161 #include "confdefs.h"
17162 #include <math.h>
17163 int main() {
17164  _powl(0, 0);
17165 ; return 0; }
17166 EOF
17167 if { (eval echo configure:17168: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17168   rm -rf conftest*
17169   glibcpp_cv_func__powl_use=yes
17170 else
17171   echo "configure: failed program was:" >&5
17172   cat conftest.$ac_ext >&5
17173   rm -rf conftest*
17174   glibcpp_cv_func__powl_use=no
17175 fi
17176 rm -f conftest*
17177       ac_ext=c
17178 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17179 ac_cpp='$CPP $CPPFLAGS'
17180 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17181 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17182 cross_compiling=$ac_cv_prog_cc_cross
17183
17184
17185 fi
17186
17187   fi
17188   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
17189   if test x$glibcpp_cv_func__powl_use = x"yes"; then
17190     for ac_func in _powl
17191 do
17192 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17193 echo "configure:17194: checking for $ac_func" >&5
17194 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17195   echo $ac_n "(cached) $ac_c" 1>&6
17196 else
17197   cat > conftest.$ac_ext <<EOF
17198 #line 17199 "configure"
17199 #include "confdefs.h"
17200 /* System header to define __stub macros and hopefully few prototypes,
17201     which can conflict with char $ac_func(); below.  */
17202 #include <assert.h>
17203 /* Override any gcc2 internal prototype to avoid an error.  */
17204 /* We use char because int might match the return type of a gcc2
17205     builtin and then its argument prototype would still apply.  */
17206 char $ac_func();
17207
17208 int main() {
17209
17210 /* The GNU C library defines this for functions which it implements
17211     to always fail with ENOSYS.  Some functions are actually named
17212     something starting with __ and the normal name is an alias.  */
17213 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17214 choke me
17215 #else
17216 $ac_func();
17217 #endif
17218
17219 ; return 0; }
17220 EOF
17221 if { (eval echo configure:17222: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17222   rm -rf conftest*
17223   eval "ac_cv_func_$ac_func=yes"
17224 else
17225   echo "configure: failed program was:" >&5
17226   cat conftest.$ac_ext >&5
17227   rm -rf conftest*
17228   eval "ac_cv_func_$ac_func=no"
17229 fi
17230 rm -f conftest*
17231 fi
17232
17233 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17234   echo "$ac_t""yes" 1>&6
17235     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17236   cat >> confdefs.h <<EOF
17237 #define $ac_tr_func 1
17238 EOF
17239
17240 else
17241   echo "$ac_t""no" 1>&6
17242 fi
17243 done
17244
17245   fi
17246
17247
17248   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
17249 echo "configure:17250: checking for _sinl declaration" >&5
17250   if test x${glibcpp_cv_func__sinl_use+set} != xset; then
17251     if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
17252   echo $ac_n "(cached) $ac_c" 1>&6
17253 else
17254
17255
17256       ac_ext=C
17257 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17258 ac_cpp='$CXXCPP $CPPFLAGS'
17259 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17260 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17261 cross_compiling=$ac_cv_prog_cxx_cross
17262
17263       cat > conftest.$ac_ext <<EOF
17264 #line 17265 "configure"
17265 #include "confdefs.h"
17266 #include <math.h>
17267 int main() {
17268  _sinl(0);
17269 ; return 0; }
17270 EOF
17271 if { (eval echo configure:17272: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17272   rm -rf conftest*
17273   glibcpp_cv_func__sinl_use=yes
17274 else
17275   echo "configure: failed program was:" >&5
17276   cat conftest.$ac_ext >&5
17277   rm -rf conftest*
17278   glibcpp_cv_func__sinl_use=no
17279 fi
17280 rm -f conftest*
17281       ac_ext=c
17282 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17283 ac_cpp='$CPP $CPPFLAGS'
17284 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17285 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17286 cross_compiling=$ac_cv_prog_cc_cross
17287
17288
17289 fi
17290
17291   fi
17292   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
17293   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
17294     for ac_func in _sinl
17295 do
17296 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17297 echo "configure:17298: checking for $ac_func" >&5
17298 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17299   echo $ac_n "(cached) $ac_c" 1>&6
17300 else
17301   cat > conftest.$ac_ext <<EOF
17302 #line 17303 "configure"
17303 #include "confdefs.h"
17304 /* System header to define __stub macros and hopefully few prototypes,
17305     which can conflict with char $ac_func(); below.  */
17306 #include <assert.h>
17307 /* Override any gcc2 internal prototype to avoid an error.  */
17308 /* We use char because int might match the return type of a gcc2
17309     builtin and then its argument prototype would still apply.  */
17310 char $ac_func();
17311
17312 int main() {
17313
17314 /* The GNU C library defines this for functions which it implements
17315     to always fail with ENOSYS.  Some functions are actually named
17316     something starting with __ and the normal name is an alias.  */
17317 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17318 choke me
17319 #else
17320 $ac_func();
17321 #endif
17322
17323 ; return 0; }
17324 EOF
17325 if { (eval echo configure:17326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17326   rm -rf conftest*
17327   eval "ac_cv_func_$ac_func=yes"
17328 else
17329   echo "configure: failed program was:" >&5
17330   cat conftest.$ac_ext >&5
17331   rm -rf conftest*
17332   eval "ac_cv_func_$ac_func=no"
17333 fi
17334 rm -f conftest*
17335 fi
17336
17337 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17338   echo "$ac_t""yes" 1>&6
17339     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17340   cat >> confdefs.h <<EOF
17341 #define $ac_tr_func 1
17342 EOF
17343
17344 else
17345   echo "$ac_t""no" 1>&6
17346 fi
17347 done
17348
17349   fi
17350
17351
17352   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
17353 echo "configure:17354: checking for _sinhl declaration" >&5
17354   if test x${glibcpp_cv_func__sinhl_use+set} != xset; then
17355     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
17356   echo $ac_n "(cached) $ac_c" 1>&6
17357 else
17358
17359
17360       ac_ext=C
17361 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17362 ac_cpp='$CXXCPP $CPPFLAGS'
17363 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17364 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17365 cross_compiling=$ac_cv_prog_cxx_cross
17366
17367       cat > conftest.$ac_ext <<EOF
17368 #line 17369 "configure"
17369 #include "confdefs.h"
17370 #include <math.h>
17371 int main() {
17372  _sinhl(0);
17373 ; return 0; }
17374 EOF
17375 if { (eval echo configure:17376: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17376   rm -rf conftest*
17377   glibcpp_cv_func__sinhl_use=yes
17378 else
17379   echo "configure: failed program was:" >&5
17380   cat conftest.$ac_ext >&5
17381   rm -rf conftest*
17382   glibcpp_cv_func__sinhl_use=no
17383 fi
17384 rm -f conftest*
17385       ac_ext=c
17386 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17387 ac_cpp='$CPP $CPPFLAGS'
17388 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17389 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17390 cross_compiling=$ac_cv_prog_cc_cross
17391
17392
17393 fi
17394
17395   fi
17396   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
17397   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
17398     for ac_func in _sinhl
17399 do
17400 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17401 echo "configure:17402: checking for $ac_func" >&5
17402 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17403   echo $ac_n "(cached) $ac_c" 1>&6
17404 else
17405   cat > conftest.$ac_ext <<EOF
17406 #line 17407 "configure"
17407 #include "confdefs.h"
17408 /* System header to define __stub macros and hopefully few prototypes,
17409     which can conflict with char $ac_func(); below.  */
17410 #include <assert.h>
17411 /* Override any gcc2 internal prototype to avoid an error.  */
17412 /* We use char because int might match the return type of a gcc2
17413     builtin and then its argument prototype would still apply.  */
17414 char $ac_func();
17415
17416 int main() {
17417
17418 /* The GNU C library defines this for functions which it implements
17419     to always fail with ENOSYS.  Some functions are actually named
17420     something starting with __ and the normal name is an alias.  */
17421 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17422 choke me
17423 #else
17424 $ac_func();
17425 #endif
17426
17427 ; return 0; }
17428 EOF
17429 if { (eval echo configure:17430: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17430   rm -rf conftest*
17431   eval "ac_cv_func_$ac_func=yes"
17432 else
17433   echo "configure: failed program was:" >&5
17434   cat conftest.$ac_ext >&5
17435   rm -rf conftest*
17436   eval "ac_cv_func_$ac_func=no"
17437 fi
17438 rm -f conftest*
17439 fi
17440
17441 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17442   echo "$ac_t""yes" 1>&6
17443     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17444   cat >> confdefs.h <<EOF
17445 #define $ac_tr_func 1
17446 EOF
17447
17448 else
17449   echo "$ac_t""no" 1>&6
17450 fi
17451 done
17452
17453   fi
17454
17455
17456   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
17457 echo "configure:17458: checking for _sqrtl declaration" >&5
17458   if test x${glibcpp_cv_func__sqrtl_use+set} != xset; then
17459     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
17460   echo $ac_n "(cached) $ac_c" 1>&6
17461 else
17462
17463
17464       ac_ext=C
17465 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17466 ac_cpp='$CXXCPP $CPPFLAGS'
17467 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17468 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17469 cross_compiling=$ac_cv_prog_cxx_cross
17470
17471       cat > conftest.$ac_ext <<EOF
17472 #line 17473 "configure"
17473 #include "confdefs.h"
17474 #include <math.h>
17475 int main() {
17476  _sqrtl(0);
17477 ; return 0; }
17478 EOF
17479 if { (eval echo configure:17480: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17480   rm -rf conftest*
17481   glibcpp_cv_func__sqrtl_use=yes
17482 else
17483   echo "configure: failed program was:" >&5
17484   cat conftest.$ac_ext >&5
17485   rm -rf conftest*
17486   glibcpp_cv_func__sqrtl_use=no
17487 fi
17488 rm -f conftest*
17489       ac_ext=c
17490 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17491 ac_cpp='$CPP $CPPFLAGS'
17492 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17493 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17494 cross_compiling=$ac_cv_prog_cc_cross
17495
17496
17497 fi
17498
17499   fi
17500   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
17501   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
17502     for ac_func in _sqrtl
17503 do
17504 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17505 echo "configure:17506: checking for $ac_func" >&5
17506 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17507   echo $ac_n "(cached) $ac_c" 1>&6
17508 else
17509   cat > conftest.$ac_ext <<EOF
17510 #line 17511 "configure"
17511 #include "confdefs.h"
17512 /* System header to define __stub macros and hopefully few prototypes,
17513     which can conflict with char $ac_func(); below.  */
17514 #include <assert.h>
17515 /* Override any gcc2 internal prototype to avoid an error.  */
17516 /* We use char because int might match the return type of a gcc2
17517     builtin and then its argument prototype would still apply.  */
17518 char $ac_func();
17519
17520 int main() {
17521
17522 /* The GNU C library defines this for functions which it implements
17523     to always fail with ENOSYS.  Some functions are actually named
17524     something starting with __ and the normal name is an alias.  */
17525 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17526 choke me
17527 #else
17528 $ac_func();
17529 #endif
17530
17531 ; return 0; }
17532 EOF
17533 if { (eval echo configure:17534: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17534   rm -rf conftest*
17535   eval "ac_cv_func_$ac_func=yes"
17536 else
17537   echo "configure: failed program was:" >&5
17538   cat conftest.$ac_ext >&5
17539   rm -rf conftest*
17540   eval "ac_cv_func_$ac_func=no"
17541 fi
17542 rm -f conftest*
17543 fi
17544
17545 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17546   echo "$ac_t""yes" 1>&6
17547     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17548   cat >> confdefs.h <<EOF
17549 #define $ac_tr_func 1
17550 EOF
17551
17552 else
17553   echo "$ac_t""no" 1>&6
17554 fi
17555 done
17556
17557   fi
17558
17559
17560   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
17561 echo "configure:17562: checking for _tanl declaration" >&5
17562   if test x${glibcpp_cv_func__tanl_use+set} != xset; then
17563     if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
17564   echo $ac_n "(cached) $ac_c" 1>&6
17565 else
17566
17567
17568       ac_ext=C
17569 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17570 ac_cpp='$CXXCPP $CPPFLAGS'
17571 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17572 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17573 cross_compiling=$ac_cv_prog_cxx_cross
17574
17575       cat > conftest.$ac_ext <<EOF
17576 #line 17577 "configure"
17577 #include "confdefs.h"
17578 #include <math.h>
17579 int main() {
17580  _tanl(0);
17581 ; return 0; }
17582 EOF
17583 if { (eval echo configure:17584: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17584   rm -rf conftest*
17585   glibcpp_cv_func__tanl_use=yes
17586 else
17587   echo "configure: failed program was:" >&5
17588   cat conftest.$ac_ext >&5
17589   rm -rf conftest*
17590   glibcpp_cv_func__tanl_use=no
17591 fi
17592 rm -f conftest*
17593       ac_ext=c
17594 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17595 ac_cpp='$CPP $CPPFLAGS'
17596 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17597 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17598 cross_compiling=$ac_cv_prog_cc_cross
17599
17600
17601 fi
17602
17603   fi
17604   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
17605   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
17606     for ac_func in _tanl
17607 do
17608 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17609 echo "configure:17610: checking for $ac_func" >&5
17610 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17611   echo $ac_n "(cached) $ac_c" 1>&6
17612 else
17613   cat > conftest.$ac_ext <<EOF
17614 #line 17615 "configure"
17615 #include "confdefs.h"
17616 /* System header to define __stub macros and hopefully few prototypes,
17617     which can conflict with char $ac_func(); below.  */
17618 #include <assert.h>
17619 /* Override any gcc2 internal prototype to avoid an error.  */
17620 /* We use char because int might match the return type of a gcc2
17621     builtin and then its argument prototype would still apply.  */
17622 char $ac_func();
17623
17624 int main() {
17625
17626 /* The GNU C library defines this for functions which it implements
17627     to always fail with ENOSYS.  Some functions are actually named
17628     something starting with __ and the normal name is an alias.  */
17629 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17630 choke me
17631 #else
17632 $ac_func();
17633 #endif
17634
17635 ; return 0; }
17636 EOF
17637 if { (eval echo configure:17638: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17638   rm -rf conftest*
17639   eval "ac_cv_func_$ac_func=yes"
17640 else
17641   echo "configure: failed program was:" >&5
17642   cat conftest.$ac_ext >&5
17643   rm -rf conftest*
17644   eval "ac_cv_func_$ac_func=no"
17645 fi
17646 rm -f conftest*
17647 fi
17648
17649 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17650   echo "$ac_t""yes" 1>&6
17651     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17652   cat >> confdefs.h <<EOF
17653 #define $ac_tr_func 1
17654 EOF
17655
17656 else
17657   echo "$ac_t""no" 1>&6
17658 fi
17659 done
17660
17661   fi
17662
17663
17664   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
17665 echo "configure:17666: checking for _tanhl declaration" >&5
17666   if test x${glibcpp_cv_func__tanhl_use+set} != xset; then
17667     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
17668   echo $ac_n "(cached) $ac_c" 1>&6
17669 else
17670
17671
17672       ac_ext=C
17673 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17674 ac_cpp='$CXXCPP $CPPFLAGS'
17675 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17676 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17677 cross_compiling=$ac_cv_prog_cxx_cross
17678
17679       cat > conftest.$ac_ext <<EOF
17680 #line 17681 "configure"
17681 #include "confdefs.h"
17682 #include <math.h>
17683 int main() {
17684  _tanhl(0);
17685 ; return 0; }
17686 EOF
17687 if { (eval echo configure:17688: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17688   rm -rf conftest*
17689   glibcpp_cv_func__tanhl_use=yes
17690 else
17691   echo "configure: failed program was:" >&5
17692   cat conftest.$ac_ext >&5
17693   rm -rf conftest*
17694   glibcpp_cv_func__tanhl_use=no
17695 fi
17696 rm -f conftest*
17697       ac_ext=c
17698 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17699 ac_cpp='$CPP $CPPFLAGS'
17700 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17701 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17702 cross_compiling=$ac_cv_prog_cc_cross
17703
17704
17705 fi
17706
17707   fi
17708   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
17709   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
17710     for ac_func in _tanhl
17711 do
17712 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17713 echo "configure:17714: checking for $ac_func" >&5
17714 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17715   echo $ac_n "(cached) $ac_c" 1>&6
17716 else
17717   cat > conftest.$ac_ext <<EOF
17718 #line 17719 "configure"
17719 #include "confdefs.h"
17720 /* System header to define __stub macros and hopefully few prototypes,
17721     which can conflict with char $ac_func(); below.  */
17722 #include <assert.h>
17723 /* Override any gcc2 internal prototype to avoid an error.  */
17724 /* We use char because int might match the return type of a gcc2
17725     builtin and then its argument prototype would still apply.  */
17726 char $ac_func();
17727
17728 int main() {
17729
17730 /* The GNU C library defines this for functions which it implements
17731     to always fail with ENOSYS.  Some functions are actually named
17732     something starting with __ and the normal name is an alias.  */
17733 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17734 choke me
17735 #else
17736 $ac_func();
17737 #endif
17738
17739 ; return 0; }
17740 EOF
17741 if { (eval echo configure:17742: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17742   rm -rf conftest*
17743   eval "ac_cv_func_$ac_func=yes"
17744 else
17745   echo "configure: failed program was:" >&5
17746   cat conftest.$ac_ext >&5
17747   rm -rf conftest*
17748   eval "ac_cv_func_$ac_func=no"
17749 fi
17750 rm -f conftest*
17751 fi
17752
17753 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17754   echo "$ac_t""yes" 1>&6
17755     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17756   cat >> confdefs.h <<EOF
17757 #define $ac_tr_func 1
17758 EOF
17759
17760 else
17761   echo "$ac_t""no" 1>&6
17762 fi
17763 done
17764
17765   fi
17766
17767
17768   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
17769 echo "configure:17770: checking for _sincosl declaration" >&5
17770   if test x${glibcpp_cv_func__sincosl_use+set} != xset; then
17771     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
17772   echo $ac_n "(cached) $ac_c" 1>&6
17773 else
17774
17775
17776       ac_ext=C
17777 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17778 ac_cpp='$CXXCPP $CPPFLAGS'
17779 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17780 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17781 cross_compiling=$ac_cv_prog_cxx_cross
17782
17783       cat > conftest.$ac_ext <<EOF
17784 #line 17785 "configure"
17785 #include "confdefs.h"
17786 #include <math.h>
17787 int main() {
17788  _sincosl(0, 0, 0);
17789 ; return 0; }
17790 EOF
17791 if { (eval echo configure:17792: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17792   rm -rf conftest*
17793   glibcpp_cv_func__sincosl_use=yes
17794 else
17795   echo "configure: failed program was:" >&5
17796   cat conftest.$ac_ext >&5
17797   rm -rf conftest*
17798   glibcpp_cv_func__sincosl_use=no
17799 fi
17800 rm -f conftest*
17801       ac_ext=c
17802 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17803 ac_cpp='$CPP $CPPFLAGS'
17804 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17805 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17806 cross_compiling=$ac_cv_prog_cc_cross
17807
17808
17809 fi
17810
17811   fi
17812   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
17813   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
17814     for ac_func in _sincosl
17815 do
17816 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17817 echo "configure:17818: checking for $ac_func" >&5
17818 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17819   echo $ac_n "(cached) $ac_c" 1>&6
17820 else
17821   cat > conftest.$ac_ext <<EOF
17822 #line 17823 "configure"
17823 #include "confdefs.h"
17824 /* System header to define __stub macros and hopefully few prototypes,
17825     which can conflict with char $ac_func(); below.  */
17826 #include <assert.h>
17827 /* Override any gcc2 internal prototype to avoid an error.  */
17828 /* We use char because int might match the return type of a gcc2
17829     builtin and then its argument prototype would still apply.  */
17830 char $ac_func();
17831
17832 int main() {
17833
17834 /* The GNU C library defines this for functions which it implements
17835     to always fail with ENOSYS.  Some functions are actually named
17836     something starting with __ and the normal name is an alias.  */
17837 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17838 choke me
17839 #else
17840 $ac_func();
17841 #endif
17842
17843 ; return 0; }
17844 EOF
17845 if { (eval echo configure:17846: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17846   rm -rf conftest*
17847   eval "ac_cv_func_$ac_func=yes"
17848 else
17849   echo "configure: failed program was:" >&5
17850   cat conftest.$ac_ext >&5
17851   rm -rf conftest*
17852   eval "ac_cv_func_$ac_func=no"
17853 fi
17854 rm -f conftest*
17855 fi
17856
17857 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17858   echo "$ac_t""yes" 1>&6
17859     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17860   cat >> confdefs.h <<EOF
17861 #define $ac_tr_func 1
17862 EOF
17863
17864 else
17865   echo "$ac_t""no" 1>&6
17866 fi
17867 done
17868
17869   fi
17870
17871
17872   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
17873 echo "configure:17874: checking for _finitel declaration" >&5
17874   if test x${glibcpp_cv_func__finitel_use+set} != xset; then
17875     if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
17876   echo $ac_n "(cached) $ac_c" 1>&6
17877 else
17878
17879
17880       ac_ext=C
17881 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17882 ac_cpp='$CXXCPP $CPPFLAGS'
17883 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17884 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17885 cross_compiling=$ac_cv_prog_cxx_cross
17886
17887       cat > conftest.$ac_ext <<EOF
17888 #line 17889 "configure"
17889 #include "confdefs.h"
17890 #include <math.h>
17891 int main() {
17892  _finitel(0);
17893 ; return 0; }
17894 EOF
17895 if { (eval echo configure:17896: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17896   rm -rf conftest*
17897   glibcpp_cv_func__finitel_use=yes
17898 else
17899   echo "configure: failed program was:" >&5
17900   cat conftest.$ac_ext >&5
17901   rm -rf conftest*
17902   glibcpp_cv_func__finitel_use=no
17903 fi
17904 rm -f conftest*
17905       ac_ext=c
17906 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17907 ac_cpp='$CPP $CPPFLAGS'
17908 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17909 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17910 cross_compiling=$ac_cv_prog_cc_cross
17911
17912
17913 fi
17914
17915   fi
17916   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
17917   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
17918     for ac_func in _finitel
17919 do
17920 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17921 echo "configure:17922: checking for $ac_func" >&5
17922 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17923   echo $ac_n "(cached) $ac_c" 1>&6
17924 else
17925   cat > conftest.$ac_ext <<EOF
17926 #line 17927 "configure"
17927 #include "confdefs.h"
17928 /* System header to define __stub macros and hopefully few prototypes,
17929     which can conflict with char $ac_func(); below.  */
17930 #include <assert.h>
17931 /* Override any gcc2 internal prototype to avoid an error.  */
17932 /* We use char because int might match the return type of a gcc2
17933     builtin and then its argument prototype would still apply.  */
17934 char $ac_func();
17935
17936 int main() {
17937
17938 /* The GNU C library defines this for functions which it implements
17939     to always fail with ENOSYS.  Some functions are actually named
17940     something starting with __ and the normal name is an alias.  */
17941 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17942 choke me
17943 #else
17944 $ac_func();
17945 #endif
17946
17947 ; return 0; }
17948 EOF
17949 if { (eval echo configure:17950: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17950   rm -rf conftest*
17951   eval "ac_cv_func_$ac_func=yes"
17952 else
17953   echo "configure: failed program was:" >&5
17954   cat conftest.$ac_ext >&5
17955   rm -rf conftest*
17956   eval "ac_cv_func_$ac_func=no"
17957 fi
17958 rm -f conftest*
17959 fi
17960
17961 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17962   echo "$ac_t""yes" 1>&6
17963     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17964   cat >> confdefs.h <<EOF
17965 #define $ac_tr_func 1
17966 EOF
17967
17968 else
17969   echo "$ac_t""no" 1>&6
17970 fi
17971 done
17972
17973   fi
17974
17975
17976   LIBS="$ac_save_LIBS"
17977   CXXFLAGS="$ac_save_CXXFLAGS"
17978
17979
17980     echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
17981 echo "configure:17982: checking for main in -lm" >&5
17982 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
17983 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
17984   echo $ac_n "(cached) $ac_c" 1>&6
17985 else
17986   ac_save_LIBS="$LIBS"
17987 LIBS="-lm  $LIBS"
17988 cat > conftest.$ac_ext <<EOF
17989 #line 17990 "configure"
17990 #include "confdefs.h"
17991
17992 int main() {
17993 main()
17994 ; return 0; }
17995 EOF
17996 if { (eval echo configure:17997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17997   rm -rf conftest*
17998   eval "ac_cv_lib_$ac_lib_var=yes"
17999 else
18000   echo "configure: failed program was:" >&5
18001   cat conftest.$ac_ext >&5
18002   rm -rf conftest*
18003   eval "ac_cv_lib_$ac_lib_var=no"
18004 fi
18005 rm -f conftest*
18006 LIBS="$ac_save_LIBS"
18007
18008 fi
18009 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
18010   echo "$ac_t""yes" 1>&6
18011     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
18012     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
18013   cat >> confdefs.h <<EOF
18014 #define $ac_tr_lib 1
18015 EOF
18016
18017   LIBS="-lm $LIBS"
18018
18019 else
18020   echo "$ac_t""no" 1>&6
18021 fi
18022
18023   for ac_func in nan hypot hypotf atan2f expf copysignf
18024 do
18025 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18026 echo "configure:18027: checking for $ac_func" >&5
18027 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18028   echo $ac_n "(cached) $ac_c" 1>&6
18029 else
18030   cat > conftest.$ac_ext <<EOF
18031 #line 18032 "configure"
18032 #include "confdefs.h"
18033 /* System header to define __stub macros and hopefully few prototypes,
18034     which can conflict with char $ac_func(); below.  */
18035 #include <assert.h>
18036 /* Override any gcc2 internal prototype to avoid an error.  */
18037 /* We use char because int might match the return type of a gcc2
18038     builtin and then its argument prototype would still apply.  */
18039 char $ac_func();
18040
18041 int main() {
18042
18043 /* The GNU C library defines this for functions which it implements
18044     to always fail with ENOSYS.  Some functions are actually named
18045     something starting with __ and the normal name is an alias.  */
18046 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18047 choke me
18048 #else
18049 $ac_func();
18050 #endif
18051
18052 ; return 0; }
18053 EOF
18054 if { (eval echo configure:18055: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18055   rm -rf conftest*
18056   eval "ac_cv_func_$ac_func=yes"
18057 else
18058   echo "configure: failed program was:" >&5
18059   cat conftest.$ac_ext >&5
18060   rm -rf conftest*
18061   eval "ac_cv_func_$ac_func=no"
18062 fi
18063 rm -f conftest*
18064 fi
18065
18066 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18067   echo "$ac_t""yes" 1>&6
18068     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18069   cat >> confdefs.h <<EOF
18070 #define $ac_tr_func 1
18071 EOF
18072
18073 else
18074   echo "$ac_t""no" 1>&6
18075 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18076 fi
18077 done
18078
18079
18080
18081           USE_COMPLEX_LONG_DOUBLE=no
18082   if test x$ac_cv_func_atan2l = x"yes" \
18083      && test x$ac_cv_func_copysignl = x"yes"; then
18084     USE_COMPLEX_LONG_DOUBLE=yes
18085     for ac_func in hypotl signbitl
18086 do
18087 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18088 echo "configure:18089: checking for $ac_func" >&5
18089 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18090   echo $ac_n "(cached) $ac_c" 1>&6
18091 else
18092   cat > conftest.$ac_ext <<EOF
18093 #line 18094 "configure"
18094 #include "confdefs.h"
18095 /* System header to define __stub macros and hopefully few prototypes,
18096     which can conflict with char $ac_func(); below.  */
18097 #include <assert.h>
18098 /* Override any gcc2 internal prototype to avoid an error.  */
18099 /* We use char because int might match the return type of a gcc2
18100     builtin and then its argument prototype would still apply.  */
18101 char $ac_func();
18102
18103 int main() {
18104
18105 /* The GNU C library defines this for functions which it implements
18106     to always fail with ENOSYS.  Some functions are actually named
18107     something starting with __ and the normal name is an alias.  */
18108 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18109 choke me
18110 #else
18111 $ac_func();
18112 #endif
18113
18114 ; return 0; }
18115 EOF
18116 if { (eval echo configure:18117: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18117   rm -rf conftest*
18118   eval "ac_cv_func_$ac_func=yes"
18119 else
18120   echo "configure: failed program was:" >&5
18121   cat conftest.$ac_ext >&5
18122   rm -rf conftest*
18123   eval "ac_cv_func_$ac_func=no"
18124 fi
18125 rm -f conftest*
18126 fi
18127
18128 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18129   echo "$ac_t""yes" 1>&6
18130     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18131   cat >> confdefs.h <<EOF
18132 #define $ac_tr_func 1
18133 EOF
18134
18135 else
18136   echo "$ac_t""no" 1>&6
18137 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18138 fi
18139 done
18140
18141
18142   fi
18143
18144
18145
18146
18147
18148
18149   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
18150 echo "configure:18151: checking for GNU C++ __complex__ support" >&5
18151   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
18152   echo $ac_n "(cached) $ac_c" 1>&6
18153 else
18154
18155
18156     ac_ext=C
18157 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18158 ac_cpp='$CXXCPP $CPPFLAGS'
18159 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18160 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18161 cross_compiling=$ac_cv_prog_cxx_cross
18162
18163     cat > conftest.$ac_ext <<EOF
18164 #line 18165 "configure"
18165 #include "confdefs.h"
18166 struct dcomplex { __complex__ double x; }; \
18167                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
18168 int main() {
18169 \
18170                      dcomplex x; f(x);
18171 ; return 0; }
18172 EOF
18173 if { (eval echo configure:18174: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18174   rm -rf conftest*
18175   glibcpp_cv_complex=ok
18176 else
18177   echo "configure: failed program was:" >&5
18178   cat conftest.$ac_ext >&5
18179   rm -rf conftest*
18180   glibcpp_cv_complex=buggy
18181
18182 fi
18183 rm -f conftest*
18184     ac_ext=c
18185 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18186 ac_cpp='$CPP $CPPFLAGS'
18187 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18188 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18189 cross_compiling=$ac_cv_prog_cc_cross
18190
18191
18192 fi
18193
18194   echo "$ac_t""$glibcpp_cv_complex" 1>&6
18195   if test $glibcpp_cv_complex = buggy; then
18196     cat >> confdefs.h <<\EOF
18197 #define _GLIBCPP_BUGGY_COMPLEX 1
18198 EOF
18199
18200   fi
18201
18202   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
18203 echo "configure:18204: checking for GNU C++ __complex__ float support" >&5
18204   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
18205   echo $ac_n "(cached) $ac_c" 1>&6
18206 else
18207
18208
18209     ac_ext=C
18210 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18211 ac_cpp='$CXXCPP $CPPFLAGS'
18212 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18213 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18214 cross_compiling=$ac_cv_prog_cxx_cross
18215
18216     rm -f conftest.h
18217     cat > conftest.h <<EOB
18218       //
18219       // Check for buggy __complex__ that causes ICE in most versions of egcs
18220       // and gcc-2.95.x on certain platforms (eg., x86-win32).
18221       //
18222       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
18223       // more info on the bug itself.
18224       //
18225       struct
18226       float_complex
18227       {
18228        __complex__ float m_value;
18229        float_complex (float = 0.0f, float = 0.0f);
18230        float_complex (__complex__ float val) : m_value (val) {}
18231        float_complex foo (const float_complex &val)
18232          { return float_complex (~val.m_value); }
18233       };
18234 EOB
18235     cat > conftest.$ac_ext <<EOF
18236 #line 18237 "configure"
18237 #include "confdefs.h"
18238 #include "conftest.h"
18239 int main() {
18240
18241 ; return 0; }
18242 EOF
18243 if { (eval echo configure:18244: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18244   rm -rf conftest*
18245   glibcpp_cv_float_complex=ok
18246 else
18247   echo "configure: failed program was:" >&5
18248   cat conftest.$ac_ext >&5
18249   rm -rf conftest*
18250   glibcpp_cv_float_complex=buggy
18251
18252 fi
18253 rm -f conftest*
18254     ac_ext=c
18255 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18256 ac_cpp='$CPP $CPPFLAGS'
18257 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18258 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18259 cross_compiling=$ac_cv_prog_cc_cross
18260
18261
18262 fi
18263
18264   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
18265   if test $glibcpp_cv_float_complex = buggy; then
18266     cat >> confdefs.h <<\EOF
18267 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
18268 EOF
18269
18270   fi
18271
18272
18273   if test x$enable_c_mbchar != xno; then
18274
18275         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
18276 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
18277 echo "configure:18278: checking for wchar.h" >&5
18278 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18279   echo $ac_n "(cached) $ac_c" 1>&6
18280 else
18281   cat > conftest.$ac_ext <<EOF
18282 #line 18283 "configure"
18283 #include "confdefs.h"
18284 #include <wchar.h>
18285 EOF
18286 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18287 { (eval echo configure:18288: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18288 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18289 if test -z "$ac_err"; then
18290   rm -rf conftest*
18291   eval "ac_cv_header_$ac_safe=yes"
18292 else
18293   echo "$ac_err" >&5
18294   echo "configure: failed program was:" >&5
18295   cat conftest.$ac_ext >&5
18296   rm -rf conftest*
18297   eval "ac_cv_header_$ac_safe=no"
18298 fi
18299 rm -f conftest*
18300 fi
18301 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18302   echo "$ac_t""yes" 1>&6
18303   ac_has_wchar_h=yes
18304 else
18305   echo "$ac_t""no" 1>&6
18306 ac_has_wchar_h=no
18307 fi
18308
18309     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
18310 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
18311 echo "configure:18312: checking for wctype.h" >&5
18312 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18313   echo $ac_n "(cached) $ac_c" 1>&6
18314 else
18315   cat > conftest.$ac_ext <<EOF
18316 #line 18317 "configure"
18317 #include "confdefs.h"
18318 #include <wctype.h>
18319 EOF
18320 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18321 { (eval echo configure:18322: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18322 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18323 if test -z "$ac_err"; then
18324   rm -rf conftest*
18325   eval "ac_cv_header_$ac_safe=yes"
18326 else
18327   echo "$ac_err" >&5
18328   echo "configure: failed program was:" >&5
18329   cat conftest.$ac_ext >&5
18330   rm -rf conftest*
18331   eval "ac_cv_header_$ac_safe=no"
18332 fi
18333 rm -f conftest*
18334 fi
18335 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18336   echo "$ac_t""yes" 1>&6
18337   ac_has_wctype_h=yes
18338 else
18339   echo "$ac_t""no" 1>&6
18340 ac_has_wctype_h=no
18341 fi
18342
18343
18344         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
18345
18346                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
18347 echo "configure:18348: checking for mbstate_t" >&5
18348       cat > conftest.$ac_ext <<EOF
18349 #line 18350 "configure"
18350 #include "confdefs.h"
18351 #include <wchar.h>
18352 int main() {
18353 mbstate_t teststate;
18354 ; return 0; }
18355 EOF
18356 if { (eval echo configure:18357: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18357   rm -rf conftest*
18358   use_native_mbstatet=yes
18359 else
18360   echo "configure: failed program was:" >&5
18361   cat conftest.$ac_ext >&5
18362   rm -rf conftest*
18363   use_native_mbstatet=no
18364 fi
18365 rm -f conftest*
18366       echo "$ac_t""$use_native_mbstatet" 1>&6
18367
18368                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
18369 echo "configure:18370: checking for WCHAR_MIN and WCHAR_MAX" >&5
18370       cat > conftest.$ac_ext <<EOF
18371 #line 18372 "configure"
18372 #include "confdefs.h"
18373 #include <wchar.h>
18374 int main() {
18375 int i = WCHAR_MIN; int j = WCHAR_MAX;
18376 ; return 0; }
18377 EOF
18378 if { (eval echo configure:18379: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18379   rm -rf conftest*
18380   has_wchar_minmax=yes
18381 else
18382   echo "configure: failed program was:" >&5
18383   cat conftest.$ac_ext >&5
18384   rm -rf conftest*
18385   has_wchar_minmax=no
18386 fi
18387 rm -f conftest*
18388       echo "$ac_t""$has_wchar_minmax" 1>&6
18389
18390                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
18391 echo "configure:18392: checking for WEOF" >&5
18392       cat > conftest.$ac_ext <<EOF
18393 #line 18394 "configure"
18394 #include "confdefs.h"
18395
18396         #include <wchar.h>
18397         #include <stddef.h>
18398 int main() {
18399 wint_t i = WEOF;
18400 ; return 0; }
18401 EOF
18402 if { (eval echo configure:18403: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18403   rm -rf conftest*
18404   has_weof=yes
18405 else
18406   echo "configure: failed program was:" >&5
18407   cat conftest.$ac_ext >&5
18408   rm -rf conftest*
18409   has_weof=no
18410 fi
18411 rm -f conftest*
18412       echo "$ac_t""$has_weof" 1>&6
18413
18414             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
18415       wcsrtombs mbsrtowcs
18416 do
18417 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18418 echo "configure:18419: checking for $ac_func" >&5
18419 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18420   echo $ac_n "(cached) $ac_c" 1>&6
18421 else
18422   cat > conftest.$ac_ext <<EOF
18423 #line 18424 "configure"
18424 #include "confdefs.h"
18425 /* System header to define __stub macros and hopefully few prototypes,
18426     which can conflict with char $ac_func(); below.  */
18427 #include <assert.h>
18428 /* Override any gcc2 internal prototype to avoid an error.  */
18429 /* We use char because int might match the return type of a gcc2
18430     builtin and then its argument prototype would still apply.  */
18431 char $ac_func();
18432
18433 int main() {
18434
18435 /* The GNU C library defines this for functions which it implements
18436     to always fail with ENOSYS.  Some functions are actually named
18437     something starting with __ and the normal name is an alias.  */
18438 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18439 choke me
18440 #else
18441 $ac_func();
18442 #endif
18443
18444 ; return 0; }
18445 EOF
18446 if { (eval echo configure:18447: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18447   rm -rf conftest*
18448   eval "ac_cv_func_$ac_func=yes"
18449 else
18450   echo "configure: failed program was:" >&5
18451   cat conftest.$ac_ext >&5
18452   rm -rf conftest*
18453   eval "ac_cv_func_$ac_func=no"
18454 fi
18455 rm -f conftest*
18456 fi
18457
18458 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18459   echo "$ac_t""yes" 1>&6
18460     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18461   cat >> confdefs.h <<EOF
18462 #define $ac_tr_func 1
18463 EOF
18464  ac_wfuncs=yes
18465 else
18466   echo "$ac_t""no" 1>&6
18467 ac_wfuncs=no
18468 fi
18469 done
18470
18471
18472       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
18473 echo "configure:18474: checking for ISO C99 wchar_t support" >&5
18474       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
18475          && test x"$ac_wfuncs" = xyes; then
18476         ac_isoC99_wchar_t=yes
18477       else
18478         ac_isoC99_wchar_t=no
18479       fi
18480       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
18481
18482                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
18483 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
18484 echo "configure:18485: checking for iconv.h" >&5
18485 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18486   echo $ac_n "(cached) $ac_c" 1>&6
18487 else
18488   cat > conftest.$ac_ext <<EOF
18489 #line 18490 "configure"
18490 #include "confdefs.h"
18491 #include <iconv.h>
18492 EOF
18493 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18494 { (eval echo configure:18495: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18495 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18496 if test -z "$ac_err"; then
18497   rm -rf conftest*
18498   eval "ac_cv_header_$ac_safe=yes"
18499 else
18500   echo "$ac_err" >&5
18501   echo "configure: failed program was:" >&5
18502   cat conftest.$ac_ext >&5
18503   rm -rf conftest*
18504   eval "ac_cv_header_$ac_safe=no"
18505 fi
18506 rm -f conftest*
18507 fi
18508 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18509   echo "$ac_t""yes" 1>&6
18510   ac_has_iconv_h=yes
18511 else
18512   echo "$ac_t""no" 1>&6
18513 ac_has_iconv_h=no
18514 fi
18515
18516       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
18517 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
18518 echo "configure:18519: checking for langinfo.h" >&5
18519 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18520   echo $ac_n "(cached) $ac_c" 1>&6
18521 else
18522   cat > conftest.$ac_ext <<EOF
18523 #line 18524 "configure"
18524 #include "confdefs.h"
18525 #include <langinfo.h>
18526 EOF
18527 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18528 { (eval echo configure:18529: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18529 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18530 if test -z "$ac_err"; then
18531   rm -rf conftest*
18532   eval "ac_cv_header_$ac_safe=yes"
18533 else
18534   echo "$ac_err" >&5
18535   echo "configure: failed program was:" >&5
18536   cat conftest.$ac_ext >&5
18537   rm -rf conftest*
18538   eval "ac_cv_header_$ac_safe=no"
18539 fi
18540 rm -f conftest*
18541 fi
18542 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18543   echo "$ac_t""yes" 1>&6
18544   ac_has_langinfo_h=yes
18545 else
18546   echo "$ac_t""no" 1>&6
18547 ac_has_langinfo_h=no
18548 fi
18549
18550
18551             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
18552 echo "configure:18553: checking for iconv in -liconv" >&5
18553 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
18554 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
18555   echo $ac_n "(cached) $ac_c" 1>&6
18556 else
18557   ac_save_LIBS="$LIBS"
18558 LIBS="-liconv  $LIBS"
18559 cat > conftest.$ac_ext <<EOF
18560 #line 18561 "configure"
18561 #include "confdefs.h"
18562 /* Override any gcc2 internal prototype to avoid an error.  */
18563 /* We use char because int might match the return type of a gcc2
18564     builtin and then its argument prototype would still apply.  */
18565 char iconv();
18566
18567 int main() {
18568 iconv()
18569 ; return 0; }
18570 EOF
18571 if { (eval echo configure:18572: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18572   rm -rf conftest*
18573   eval "ac_cv_lib_$ac_lib_var=yes"
18574 else
18575   echo "configure: failed program was:" >&5
18576   cat conftest.$ac_ext >&5
18577   rm -rf conftest*
18578   eval "ac_cv_lib_$ac_lib_var=no"
18579 fi
18580 rm -f conftest*
18581 LIBS="$ac_save_LIBS"
18582
18583 fi
18584 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
18585   echo "$ac_t""yes" 1>&6
18586   libiconv="-liconv"
18587 else
18588   echo "$ac_t""no" 1>&6
18589 fi
18590
18591       ac_save_LIBS="$LIBS"
18592       LIBS="$LIBS $libiconv"
18593
18594       for ac_func in iconv_open iconv_close iconv nl_langinfo
18595 do
18596 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18597 echo "configure:18598: checking for $ac_func" >&5
18598 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18599   echo $ac_n "(cached) $ac_c" 1>&6
18600 else
18601   cat > conftest.$ac_ext <<EOF
18602 #line 18603 "configure"
18603 #include "confdefs.h"
18604 /* System header to define __stub macros and hopefully few prototypes,
18605     which can conflict with char $ac_func(); below.  */
18606 #include <assert.h>
18607 /* Override any gcc2 internal prototype to avoid an error.  */
18608 /* We use char because int might match the return type of a gcc2
18609     builtin and then its argument prototype would still apply.  */
18610 char $ac_func();
18611
18612 int main() {
18613
18614 /* The GNU C library defines this for functions which it implements
18615     to always fail with ENOSYS.  Some functions are actually named
18616     something starting with __ and the normal name is an alias.  */
18617 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18618 choke me
18619 #else
18620 $ac_func();
18621 #endif
18622
18623 ; return 0; }
18624 EOF
18625 if { (eval echo configure:18626: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18626   rm -rf conftest*
18627   eval "ac_cv_func_$ac_func=yes"
18628 else
18629   echo "configure: failed program was:" >&5
18630   cat conftest.$ac_ext >&5
18631   rm -rf conftest*
18632   eval "ac_cv_func_$ac_func=no"
18633 fi
18634 rm -f conftest*
18635 fi
18636
18637 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18638   echo "$ac_t""yes" 1>&6
18639     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18640   cat >> confdefs.h <<EOF
18641 #define $ac_tr_func 1
18642 EOF
18643  \
18644       ac_XPG2funcs=yes
18645 else
18646   echo "$ac_t""no" 1>&6
18647 ac_XPG2funcs=no
18648 fi
18649 done
18650
18651
18652       LIBS="$ac_save_LIBS"
18653
18654       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
18655 echo "configure:18656: checking for XPG2 wchar_t support" >&5
18656       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
18657          && test x"$ac_XPG2funcs" = xyes; then
18658         ac_XPG2_wchar_t=yes
18659       else
18660         ac_XPG2_wchar_t=no
18661       fi
18662       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
18663
18664                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
18665 echo "configure:18666: checking for enabled wchar_t specializations" >&5
18666       if test x"$ac_isoC99_wchar_t" = xyes \
18667          && test x"$ac_XPG2_wchar_t" = xyes; then
18668         libinst_wstring_la="libinst-wstring.la"
18669         cat >> confdefs.h <<\EOF
18670 #define _GLIBCPP_USE_WCHAR_T 1
18671 EOF
18672
18673         echo "$ac_t"""yes"" 1>&6
18674       else
18675         libinst_wstring_la=""
18676         echo "$ac_t"""no"" 1>&6
18677       fi
18678
18679
18680     else
18681       echo "configure: warning: <wchar.h> not found" 1>&2
18682     fi
18683
18684   else
18685         :
18686   fi
18687
18688
18689   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
18690 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
18691 echo "configure:18692: checking for ctype.h" >&5
18692 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18693   echo $ac_n "(cached) $ac_c" 1>&6
18694 else
18695   cat > conftest.$ac_ext <<EOF
18696 #line 18697 "configure"
18697 #include "confdefs.h"
18698 #include <ctype.h>
18699 EOF
18700 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18701 { (eval echo configure:18702: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18702 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18703 if test -z "$ac_err"; then
18704   rm -rf conftest*
18705   eval "ac_cv_header_$ac_safe=yes"
18706 else
18707   echo "$ac_err" >&5
18708   echo "configure: failed program was:" >&5
18709   cat conftest.$ac_ext >&5
18710   rm -rf conftest*
18711   eval "ac_cv_header_$ac_safe=no"
18712 fi
18713 rm -f conftest*
18714 fi
18715 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18716   echo "$ac_t""yes" 1>&6
18717
18718
18719         ctype_default=yes
18720
18721         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
18722 echo "configure:18723: checking <ctype> for GNU/Linux" >&5
18723     cat > conftest.$ac_ext <<EOF
18724 #line 18725 "configure"
18725 #include "confdefs.h"
18726 #include <ctype.h>
18727 int main() {
18728 int
18729     foo (int a)
18730     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
18731         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
18732         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
18733 ; return 0; }
18734 EOF
18735 if { (eval echo configure:18736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18736   rm -rf conftest*
18737   \
18738     ctype_linux=yes
18739 else
18740   echo "configure: failed program was:" >&5
18741   cat conftest.$ac_ext >&5
18742   rm -rf conftest*
18743   ctype_linux=no
18744 fi
18745 rm -f conftest*
18746     echo "$ac_t""$ctype_linux" 1>&6
18747     if test $ctype_linux = "yes"; then
18748       ctype_include_dir="config/os/gnu-linux"
18749       ctype_default=no
18750     fi
18751
18752         if test $ctype_default = "yes"; then
18753     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
18754 echo "configure:18755: checking <ctype> for FreeBSD 4.0" >&5
18755     cat > conftest.$ac_ext <<EOF
18756 #line 18757 "configure"
18757 #include "confdefs.h"
18758 #include <ctype.h>
18759 int main() {
18760 int
18761     foo (int a)
18762     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
18763         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
18764 ; return 0; }
18765 EOF
18766 if { (eval echo configure:18767: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18767   rm -rf conftest*
18768   \
18769     ctype_bsd=yes
18770 else
18771   echo "configure: failed program was:" >&5
18772   cat conftest.$ac_ext >&5
18773   rm -rf conftest*
18774   ctype_bsd=no
18775 fi
18776 rm -f conftest*
18777     echo "$ac_t""$ctype_bsd" 1>&6
18778     if test $ctype_bsd = "yes"; then
18779       ctype_include_dir="config/os/bsd/freebsd"
18780       ctype_default=no
18781     fi
18782     fi
18783
18784         if test $ctype_default = "yes"; then
18785     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
18786 echo "configure:18787: checking <ctype> for FreeBSD 3.4" >&5
18787     cat > conftest.$ac_ext <<EOF
18788 #line 18789 "configure"
18789 #include "confdefs.h"
18790 #include <ctype.h>
18791 int main() {
18792 int
18793     foo (int a)
18794     { return _S + _R + _C + _U + _L + _A \
18795       + _D + _P + _X + _G + __istype (a, 0);}
18796 ; return 0; }
18797 EOF
18798 if { (eval echo configure:18799: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18799   rm -rf conftest*
18800   \
18801     ctype_freebsd34=yes
18802 else
18803   echo "configure: failed program was:" >&5
18804   cat conftest.$ac_ext >&5
18805   rm -rf conftest*
18806   ctype_freebsd34=no
18807 fi
18808 rm -f conftest*
18809     echo "$ac_t""$ctype_freebsd34" 1>&6
18810     if test $ctype_freebsd34 = "yes"; then
18811       ctype_include_dir="config/os/bsd/freebsd"
18812       ctype_default=no
18813     fi
18814     fi
18815
18816         if test $ctype_default = "yes"; then
18817     echo $ac_n "checking <ctype> for NetBSD""... $ac_c" 1>&6
18818 echo "configure:18819: checking <ctype> for NetBSD" >&5
18819     cat > conftest.$ac_ext <<EOF
18820 #line 18821 "configure"
18821 #include "confdefs.h"
18822 #include <ctype.h>
18823 int main() {
18824 int
18825     foo (int a)
18826     { return _S + _C + _U + _L \
18827       + _N + _P + _X + _tolower_tab_[a] + _toupper_tab_[a];}
18828 ; return 0; }
18829 EOF
18830 if { (eval echo configure:18831: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18831   rm -rf conftest*
18832   \
18833     ctype_netbsd=yes
18834 else
18835   echo "configure: failed program was:" >&5
18836   cat conftest.$ac_ext >&5
18837   rm -rf conftest*
18838   ctype_netbsd=no
18839 fi
18840 rm -f conftest*
18841     echo "$ac_t""$ctype_netbsd" 1>&6
18842     if test $ctype_netbsd = "yes"; then
18843       ctype_include_dir="config/os/bsd/netbsd"
18844       ctype_default=no
18845     fi
18846     fi
18847
18848         if test $ctype_default = "yes"; then
18849     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
18850 echo "configure:18851: checking <ctype> for Solaris 2.6,7,8" >&5
18851     cat > conftest.$ac_ext <<EOF
18852 #line 18853 "configure"
18853 #include "confdefs.h"
18854 #include <ctype.h>
18855 int main() {
18856 int
18857     foo (int a)
18858     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18859         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18860         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
18861 ; return 0; }
18862 EOF
18863 if { (eval echo configure:18864: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18864   rm -rf conftest*
18865   \
18866     ctype_solaris=yes
18867 else
18868   echo "configure: failed program was:" >&5
18869   cat conftest.$ac_ext >&5
18870   rm -rf conftest*
18871   ctype_solaris=no
18872 fi
18873 rm -f conftest*
18874     echo "$ac_t""$ctype_solaris" 1>&6
18875
18876     if test $ctype_solaris = "yes"; then
18877       echo $ac_n "checking   for version""... $ac_c" 1>&6
18878 echo "configure:18879: checking   for version" >&5
18879       ac_ext=C
18880 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18881 ac_cpp='$CXXCPP $CPPFLAGS'
18882 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18883 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18884 cross_compiling=$ac_cv_prog_cxx_cross
18885
18886       cat > conftest.$ac_ext <<EOF
18887 #line 18888 "configure"
18888 #include "confdefs.h"
18889 #include <ctype.h>
18890 int main() {
18891 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
18892 ; return 0; }
18893 EOF
18894 if { (eval echo configure:18895: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18895   rm -rf conftest*
18896   \
18897       ctype_solaris26=yes
18898 else
18899   echo "configure: failed program was:" >&5
18900   cat conftest.$ac_ext >&5
18901   rm -rf conftest*
18902   ctype_solaris26=no
18903 fi
18904 rm -f conftest*
18905       ac_ext=c
18906 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18907 ac_cpp='$CPP $CPPFLAGS'
18908 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18909 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18910 cross_compiling=$ac_cv_prog_cc_cross
18911
18912       if test $ctype_solaris26 = "yes"; then
18913         ctype_include_dir="config/os/solaris/solaris2.6"
18914         echo "$ac_t""Solaris 2.6" 1>&6
18915         ctype_default=no
18916       else
18917         ctype_include_dir="config/os/solaris/solaris2.7"
18918         echo "$ac_t""Solaris 7,8" 1>&6
18919         ctype_default=no
18920       fi
18921     fi
18922     fi
18923
18924         if test $ctype_default = "yes"; then
18925     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
18926 echo "configure:18927: checking <ctype> for Solaris 2.5.1" >&5
18927     cat > conftest.$ac_ext <<EOF
18928 #line 18929 "configure"
18929 #include "confdefs.h"
18930 #include <ctype.h>
18931 int main() {
18932 int
18933     foo (int a)
18934     { return _U + _L + _N + _S + _P + _C + _X + _B \
18935         + __ctype[a];}
18936 ; return 0; }
18937 EOF
18938 if { (eval echo configure:18939: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18939   rm -rf conftest*
18940   \
18941     ctype_solaris25=yes
18942 else
18943   echo "configure: failed program was:" >&5
18944   cat conftest.$ac_ext >&5
18945   rm -rf conftest*
18946   ctype_solaris25=no
18947 fi
18948 rm -f conftest*
18949     echo "$ac_t""$ctype_solaris25" 1>&6
18950     if test $ctype_solaris25 = "yes"; then
18951       ctype_include_dir="config/os/solaris/solaris2.5"
18952       ctype_default=no
18953     fi
18954     fi
18955
18956         if test $ctype_default = "yes"; then
18957     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
18958 echo "configure:18959: checking <ctype> for AIX" >&5
18959     cat > conftest.$ac_ext <<EOF
18960 #line 18961 "configure"
18961 #include "confdefs.h"
18962 #include <ctype.h>
18963 int main() {
18964 int
18965     foo (int a)
18966     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18967         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18968         + _VALC('a') + _IS('c', 0);}
18969 ; return 0; }
18970 EOF
18971 if { (eval echo configure:18972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18972   rm -rf conftest*
18973   \
18974     ctype_aix=yes
18975 else
18976   echo "configure: failed program was:" >&5
18977   cat conftest.$ac_ext >&5
18978   rm -rf conftest*
18979   ctype_aix=no
18980 fi
18981 rm -f conftest*
18982     echo "$ac_t""$ctype_aix" 1>&6
18983     if test $ctype_aix = "yes"; then
18984       ctype_include_dir="config/os/aix"
18985       ctype_default=no
18986     fi
18987     fi
18988
18989         if test $ctype_default = "yes"; then
18990     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
18991 echo "configure:18992: checking <ctype> for IRIX" >&5
18992     cat > conftest.$ac_ext <<EOF
18993 #line 18994 "configure"
18994 #include "confdefs.h"
18995 #include <ctype.h>
18996 int main() {
18997 int
18998     foo (int a)
18999     { return _U + _L + _N + _S + _P + _C + _B + _X + \
19000              _A + _PR + _G + _BL;}
19001 ; return 0; }
19002 EOF
19003 if { (eval echo configure:19004: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19004   rm -rf conftest*
19005   \
19006     ctype_irix=yes
19007 else
19008   echo "configure: failed program was:" >&5
19009   cat conftest.$ac_ext >&5
19010   rm -rf conftest*
19011   ctype_irix=no
19012 fi
19013 rm -f conftest*
19014     echo "$ac_t""$ctype_irix" 1>&6
19015     if test $ctype_irix = "yes"; then
19016       ctype_include_dir="config/os/irix"
19017       ctype_default=no
19018     fi
19019     fi
19020
19021         if test $ctype_default = "yes"; then
19022     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
19023 echo "configure:19024: checking <ctype> for newlib" >&5
19024     cat > conftest.$ac_ext <<EOF
19025 #line 19026 "configure"
19026 #include "confdefs.h"
19027 #include <ctype.h>
19028 int main() {
19029 int
19030     foo (int a)
19031     { return _U + _L + _N + _S + _P + _C + _X + _B \
19032         + _ctype_[a];}
19033 ; return 0; }
19034 EOF
19035 if { (eval echo configure:19036: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19036   rm -rf conftest*
19037   \
19038     ctype_newlib=yes
19039 else
19040   echo "configure: failed program was:" >&5
19041   cat conftest.$ac_ext >&5
19042   rm -rf conftest*
19043   ctype_newlib=no
19044 fi
19045 rm -f conftest*
19046     echo "$ac_t""$ctype_newlib" 1>&6
19047     if test $ctype_newlib = "yes"; then
19048       ctype_include_dir="config/os/newlib"
19049       ctype_default=no
19050     fi
19051     fi
19052
19053     if test $ctype_default = "yes"; then
19054       ctype_include_dir="config/os/generic"
19055       echo "configure: warning: "Using default ctype headers."" 1>&2
19056     fi
19057
19058 else
19059   echo "$ac_t""no" 1>&6
19060 fi
19061
19062
19063
19064   ac_test_CXXFLAGS="${CXXFLAGS+set}"
19065   ac_save_CXXFLAGS="$CXXFLAGS"
19066   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
19067
19068   for ac_func in strtof
19069 do
19070 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19071 echo "configure:19072: checking for $ac_func" >&5
19072 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19073   echo $ac_n "(cached) $ac_c" 1>&6
19074 else
19075   cat > conftest.$ac_ext <<EOF
19076 #line 19077 "configure"
19077 #include "confdefs.h"
19078 /* System header to define __stub macros and hopefully few prototypes,
19079     which can conflict with char $ac_func(); below.  */
19080 #include <assert.h>
19081 /* Override any gcc2 internal prototype to avoid an error.  */
19082 /* We use char because int might match the return type of a gcc2
19083     builtin and then its argument prototype would still apply.  */
19084 char $ac_func();
19085
19086 int main() {
19087
19088 /* The GNU C library defines this for functions which it implements
19089     to always fail with ENOSYS.  Some functions are actually named
19090     something starting with __ and the normal name is an alias.  */
19091 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19092 choke me
19093 #else
19094 $ac_func();
19095 #endif
19096
19097 ; return 0; }
19098 EOF
19099 if { (eval echo configure:19100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19100   rm -rf conftest*
19101   eval "ac_cv_func_$ac_func=yes"
19102 else
19103   echo "configure: failed program was:" >&5
19104   cat conftest.$ac_ext >&5
19105   rm -rf conftest*
19106   eval "ac_cv_func_$ac_func=no"
19107 fi
19108 rm -f conftest*
19109 fi
19110
19111 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19112   echo "$ac_t""yes" 1>&6
19113     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19114   cat >> confdefs.h <<EOF
19115 #define $ac_tr_func 1
19116 EOF
19117
19118 else
19119   echo "$ac_t""no" 1>&6
19120 fi
19121 done
19122
19123
19124   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
19125 echo "configure:19126: checking for strtold declaration" >&5
19126   if test x${glibcpp_cv_func_strtold_use+set} != xset; then
19127     if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
19128   echo $ac_n "(cached) $ac_c" 1>&6
19129 else
19130
19131
19132       ac_ext=C
19133 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19134 ac_cpp='$CXXCPP $CPPFLAGS'
19135 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19136 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19137 cross_compiling=$ac_cv_prog_cxx_cross
19138
19139       cat > conftest.$ac_ext <<EOF
19140 #line 19141 "configure"
19141 #include "confdefs.h"
19142 #include <stdlib.h>
19143 int main() {
19144  strtold(0, 0);
19145 ; return 0; }
19146 EOF
19147 if { (eval echo configure:19148: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19148   rm -rf conftest*
19149   glibcpp_cv_func_strtold_use=yes
19150 else
19151   echo "configure: failed program was:" >&5
19152   cat conftest.$ac_ext >&5
19153   rm -rf conftest*
19154   glibcpp_cv_func_strtold_use=no
19155 fi
19156 rm -f conftest*
19157       ac_ext=c
19158 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19159 ac_cpp='$CPP $CPPFLAGS'
19160 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19161 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19162 cross_compiling=$ac_cv_prog_cc_cross
19163
19164
19165 fi
19166
19167   fi
19168   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
19169   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
19170     for ac_func in strtold
19171 do
19172 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19173 echo "configure:19174: checking for $ac_func" >&5
19174 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19175   echo $ac_n "(cached) $ac_c" 1>&6
19176 else
19177   cat > conftest.$ac_ext <<EOF
19178 #line 19179 "configure"
19179 #include "confdefs.h"
19180 /* System header to define __stub macros and hopefully few prototypes,
19181     which can conflict with char $ac_func(); below.  */
19182 #include <assert.h>
19183 /* Override any gcc2 internal prototype to avoid an error.  */
19184 /* We use char because int might match the return type of a gcc2
19185     builtin and then its argument prototype would still apply.  */
19186 char $ac_func();
19187
19188 int main() {
19189
19190 /* The GNU C library defines this for functions which it implements
19191     to always fail with ENOSYS.  Some functions are actually named
19192     something starting with __ and the normal name is an alias.  */
19193 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19194 choke me
19195 #else
19196 $ac_func();
19197 #endif
19198
19199 ; return 0; }
19200 EOF
19201 if { (eval echo configure:19202: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19202   rm -rf conftest*
19203   eval "ac_cv_func_$ac_func=yes"
19204 else
19205   echo "configure: failed program was:" >&5
19206   cat conftest.$ac_ext >&5
19207   rm -rf conftest*
19208   eval "ac_cv_func_$ac_func=no"
19209 fi
19210 rm -f conftest*
19211 fi
19212
19213 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19214   echo "$ac_t""yes" 1>&6
19215     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19216   cat >> confdefs.h <<EOF
19217 #define $ac_tr_func 1
19218 EOF
19219
19220 else
19221   echo "$ac_t""no" 1>&6
19222 fi
19223 done
19224
19225   fi
19226
19227
19228   CXXFLAGS="$ac_save_CXXFLAGS"
19229
19230
19231   for ac_hdr in unistd.h
19232 do
19233 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
19234 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
19235 echo "configure:19236: checking for $ac_hdr" >&5
19236 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19237   echo $ac_n "(cached) $ac_c" 1>&6
19238 else
19239   cat > conftest.$ac_ext <<EOF
19240 #line 19241 "configure"
19241 #include "confdefs.h"
19242 #include <$ac_hdr>
19243 EOF
19244 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19245 { (eval echo configure:19246: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19246 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19247 if test -z "$ac_err"; then
19248   rm -rf conftest*
19249   eval "ac_cv_header_$ac_safe=yes"
19250 else
19251   echo "$ac_err" >&5
19252   echo "configure: failed program was:" >&5
19253   cat conftest.$ac_ext >&5
19254   rm -rf conftest*
19255   eval "ac_cv_header_$ac_safe=no"
19256 fi
19257 rm -f conftest*
19258 fi
19259 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19260   echo "$ac_t""yes" 1>&6
19261     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
19262   cat >> confdefs.h <<EOF
19263 #define $ac_tr_hdr 1
19264 EOF
19265
19266 else
19267   echo "$ac_t""no" 1>&6
19268 fi
19269 done
19270
19271 for ac_func in getpagesize
19272 do
19273 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19274 echo "configure:19275: checking for $ac_func" >&5
19275 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19276   echo $ac_n "(cached) $ac_c" 1>&6
19277 else
19278   cat > conftest.$ac_ext <<EOF
19279 #line 19280 "configure"
19280 #include "confdefs.h"
19281 /* System header to define __stub macros and hopefully few prototypes,
19282     which can conflict with char $ac_func(); below.  */
19283 #include <assert.h>
19284 /* Override any gcc2 internal prototype to avoid an error.  */
19285 /* We use char because int might match the return type of a gcc2
19286     builtin and then its argument prototype would still apply.  */
19287 char $ac_func();
19288
19289 int main() {
19290
19291 /* The GNU C library defines this for functions which it implements
19292     to always fail with ENOSYS.  Some functions are actually named
19293     something starting with __ and the normal name is an alias.  */
19294 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19295 choke me
19296 #else
19297 $ac_func();
19298 #endif
19299
19300 ; return 0; }
19301 EOF
19302 if { (eval echo configure:19303: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19303   rm -rf conftest*
19304   eval "ac_cv_func_$ac_func=yes"
19305 else
19306   echo "configure: failed program was:" >&5
19307   cat conftest.$ac_ext >&5
19308   rm -rf conftest*
19309   eval "ac_cv_func_$ac_func=no"
19310 fi
19311 rm -f conftest*
19312 fi
19313
19314 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19315   echo "$ac_t""yes" 1>&6
19316     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19317   cat >> confdefs.h <<EOF
19318 #define $ac_tr_func 1
19319 EOF
19320
19321 else
19322   echo "$ac_t""no" 1>&6
19323 fi
19324 done
19325
19326 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
19327 echo "configure:19328: checking for working mmap" >&5
19328 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
19329   echo $ac_n "(cached) $ac_c" 1>&6
19330 else
19331   if test "$cross_compiling" = yes; then
19332   ac_cv_func_mmap_fixed_mapped=no
19333 else
19334   cat > conftest.$ac_ext <<EOF
19335 #line 19336 "configure"
19336 #include "confdefs.h"
19337
19338 /* Thanks to Mike Haertel and Jim Avera for this test.
19339    Here is a matrix of mmap possibilities:
19340         mmap private not fixed
19341         mmap private fixed at somewhere currently unmapped
19342         mmap private fixed at somewhere already mapped
19343         mmap shared not fixed
19344         mmap shared fixed at somewhere currently unmapped
19345         mmap shared fixed at somewhere already mapped
19346    For private mappings, we should verify that changes cannot be read()
19347    back from the file, nor mmap's back from the file at a different
19348    address.  (There have been systems where private was not correctly
19349    implemented like the infamous i386 svr4.0, and systems where the
19350    VM page cache was not coherent with the filesystem buffer cache
19351    like early versions of FreeBSD and possibly contemporary NetBSD.)
19352    For shared mappings, we should conversely verify that changes get
19353    propogated back to all the places they're supposed to be.
19354
19355    Grep wants private fixed already mapped.
19356    The main things grep needs to know about mmap are:
19357    * does it exist and is it safe to write into the mmap'd area
19358    * how to use it (BSD variants)  */
19359 #include <sys/types.h>
19360 #include <fcntl.h>
19361 #include <sys/mman.h>
19362
19363 /* This mess was copied from the GNU getpagesize.h.  */
19364 #ifndef HAVE_GETPAGESIZE
19365 # ifdef HAVE_UNISTD_H
19366 #  include <unistd.h>
19367 # endif
19368
19369 /* Assume that all systems that can run configure have sys/param.h.  */
19370 # ifndef HAVE_SYS_PARAM_H
19371 #  define HAVE_SYS_PARAM_H 1
19372 # endif
19373
19374 # ifdef _SC_PAGESIZE
19375 #  define getpagesize() sysconf(_SC_PAGESIZE)
19376 # else /* no _SC_PAGESIZE */
19377 #  ifdef HAVE_SYS_PARAM_H
19378 #   include <sys/param.h>
19379 #   ifdef EXEC_PAGESIZE
19380 #    define getpagesize() EXEC_PAGESIZE
19381 #   else /* no EXEC_PAGESIZE */
19382 #    ifdef NBPG
19383 #     define getpagesize() NBPG * CLSIZE
19384 #     ifndef CLSIZE
19385 #      define CLSIZE 1
19386 #     endif /* no CLSIZE */
19387 #    else /* no NBPG */
19388 #     ifdef NBPC
19389 #      define getpagesize() NBPC
19390 #     else /* no NBPC */
19391 #      ifdef PAGESIZE
19392 #       define getpagesize() PAGESIZE
19393 #      endif /* PAGESIZE */
19394 #     endif /* no NBPC */
19395 #    endif /* no NBPG */
19396 #   endif /* no EXEC_PAGESIZE */
19397 #  else /* no HAVE_SYS_PARAM_H */
19398 #   define getpagesize() 8192   /* punt totally */
19399 #  endif /* no HAVE_SYS_PARAM_H */
19400 # endif /* no _SC_PAGESIZE */
19401
19402 #endif /* no HAVE_GETPAGESIZE */
19403
19404 #ifdef __cplusplus
19405 extern "C" { void *malloc(unsigned); }
19406 #else
19407 char *malloc();
19408 #endif
19409
19410 int
19411 main()
19412 {
19413         char *data, *data2, *data3;
19414         int i, pagesize;
19415         int fd;
19416
19417         pagesize = getpagesize();
19418
19419         /*
19420          * First, make a file with some known garbage in it.
19421          */
19422         data = malloc(pagesize);
19423         if (!data)
19424                 exit(1);
19425         for (i = 0; i < pagesize; ++i)
19426                 *(data + i) = rand();
19427         umask(0);
19428         fd = creat("conftestmmap", 0600);
19429         if (fd < 0)
19430                 exit(1);
19431         if (write(fd, data, pagesize) != pagesize)
19432                 exit(1);
19433         close(fd);
19434
19435         /*
19436          * Next, try to mmap the file at a fixed address which
19437          * already has something else allocated at it.  If we can,
19438          * also make sure that we see the same garbage.
19439          */
19440         fd = open("conftestmmap", O_RDWR);
19441         if (fd < 0)
19442                 exit(1);
19443         data2 = malloc(2 * pagesize);
19444         if (!data2)
19445                 exit(1);
19446         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
19447         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
19448             MAP_PRIVATE | MAP_FIXED, fd, 0L))
19449                 exit(1);
19450         for (i = 0; i < pagesize; ++i)
19451                 if (*(data + i) != *(data2 + i))
19452                         exit(1);
19453
19454         /*
19455          * Finally, make sure that changes to the mapped area
19456          * do not percolate back to the file as seen by read().
19457          * (This is a bug on some variants of i386 svr4.0.)
19458          */
19459         for (i = 0; i < pagesize; ++i)
19460                 *(data2 + i) = *(data2 + i) + 1;
19461         data3 = malloc(pagesize);
19462         if (!data3)
19463                 exit(1);
19464         if (read(fd, data3, pagesize) != pagesize)
19465                 exit(1);
19466         for (i = 0; i < pagesize; ++i)
19467                 if (*(data + i) != *(data3 + i))
19468                         exit(1);
19469         close(fd);
19470         unlink("conftestmmap");
19471         exit(0);
19472 }
19473
19474 EOF
19475 if { (eval echo configure:19476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
19476 then
19477   ac_cv_func_mmap_fixed_mapped=yes
19478 else
19479   echo "configure: failed program was:" >&5
19480   cat conftest.$ac_ext >&5
19481   rm -fr conftest*
19482   ac_cv_func_mmap_fixed_mapped=no
19483 fi
19484 rm -fr conftest*
19485 fi
19486
19487 fi
19488
19489 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
19490 if test $ac_cv_func_mmap_fixed_mapped = yes; then
19491   cat >> confdefs.h <<\EOF
19492 #define HAVE_MMAP 1
19493 EOF
19494
19495 fi
19496
19497 fi
19498
19499 # Now that ctype is determined for all possible targets, we can do this...
19500
19501
19502
19503
19504
19505
19506 if test "$NULL_TARGET" = yes; then
19507   NULL_TARGET_TRUE=
19508   NULL_TARGET_FALSE='#'
19509 else
19510   NULL_TARGET_TRUE='#'
19511   NULL_TARGET_FALSE=
19512 fi
19513
19514
19515 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
19516   NATIVE_TRUE=
19517   NATIVE_FALSE='#'
19518 else
19519   NATIVE_TRUE='#'
19520   NATIVE_FALSE=
19521 fi
19522
19523
19524 if test -z "$with_cross_host"; then
19525   USE_LIBDIR_TRUE=
19526   USE_LIBDIR_FALSE='#'
19527 else
19528   USE_LIBDIR_TRUE='#'
19529   USE_LIBDIR_FALSE=
19530 fi
19531
19532
19533 if test "$CANADIAN" = yes; then
19534   CANADIAN_TRUE=
19535   CANADIAN_FALSE='#'
19536 else
19537   CANADIAN_TRUE='#'
19538   CANADIAN_FALSE=
19539 fi
19540
19541 cat > confcache <<\EOF
19542 # This file is a shell script that caches the results of configure
19543 # tests run on this system so they can be shared between configure
19544 # scripts and configure runs.  It is not useful on other systems.
19545 # If it contains results you don't want to keep, you may remove or edit it.
19546 #
19547 # By default, configure uses ./config.cache as the cache file,
19548 # creating it if it does not exist already.  You can give configure
19549 # the --cache-file=FILE option to use a different cache file; that is
19550 # what configure does when it calls configure scripts in
19551 # subdirectories, so they share the cache.
19552 # Giving --cache-file=/dev/null disables caching, for debugging configure.
19553 # config.status only pays attention to the cache file if you give it the
19554 # --recheck option to rerun configure.
19555 #
19556 EOF
19557 # The following way of writing the cache mishandles newlines in values,
19558 # but we know of no workaround that is simple, portable, and efficient.
19559 # So, don't put newlines in cache variables' values.
19560 # Ultrix sh set writes to stderr and can't be redirected directly,
19561 # and sets the high bit in the cache file unless we assign to the vars.
19562 (set) 2>&1 |
19563   case `(ac_space=' '; set | grep ac_space) 2>&1` in
19564   *ac_space=\ *)
19565     # `set' does not quote correctly, so add quotes (double-quote substitution
19566     # turns \\\\ into \\, and sed turns \\ into \).
19567     sed -n \
19568       -e "s/'/'\\\\''/g" \
19569       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
19570     ;;
19571   *)
19572     # `set' quotes correctly as required by POSIX, so do not add quotes.
19573     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
19574     ;;
19575   esac >> confcache
19576 if cmp -s $cache_file confcache; then
19577   :
19578 else
19579   if test -w $cache_file; then
19580     echo "updating cache $cache_file"
19581     cat confcache > $cache_file
19582   else
19583     echo "not updating unwritable cache $cache_file"
19584   fi
19585 fi
19586 rm -f confcache
19587
19588
19589   ac_safe=`echo "locale.h" | sed 'y%./+-%__p_%'`
19590 echo $ac_n "checking for locale.h""... $ac_c" 1>&6
19591 echo "configure:19592: checking for locale.h" >&5
19592 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19593   echo $ac_n "(cached) $ac_c" 1>&6
19594 else
19595   cat > conftest.$ac_ext <<EOF
19596 #line 19597 "configure"
19597 #include "confdefs.h"
19598 #include <locale.h>
19599 EOF
19600 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19601 { (eval echo configure:19602: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19602 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19603 if test -z "$ac_err"; then
19604   rm -rf conftest*
19605   eval "ac_cv_header_$ac_safe=yes"
19606 else
19607   echo "$ac_err" >&5
19608   echo "configure: failed program was:" >&5
19609   cat conftest.$ac_ext >&5
19610   rm -rf conftest*
19611   eval "ac_cv_header_$ac_safe=no"
19612 fi
19613 rm -f conftest*
19614 fi
19615 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19616   echo "$ac_t""yes" 1>&6
19617
19618     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
19619 echo "configure:19620: checking for LC_MESSAGES" >&5
19620 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
19621   echo $ac_n "(cached) $ac_c" 1>&6
19622 else
19623   cat > conftest.$ac_ext <<EOF
19624 #line 19625 "configure"
19625 #include "confdefs.h"
19626 #include <locale.h>
19627 int main() {
19628 return LC_MESSAGES
19629 ; return 0; }
19630 EOF
19631 if { (eval echo configure:19632: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19632   rm -rf conftest*
19633   ac_cv_val_LC_MESSAGES=yes
19634 else
19635   echo "configure: failed program was:" >&5
19636   cat conftest.$ac_ext >&5
19637   rm -rf conftest*
19638   ac_cv_val_LC_MESSAGES=no
19639 fi
19640 rm -f conftest*
19641 fi
19642
19643 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
19644     if test $ac_cv_val_LC_MESSAGES = yes; then
19645       cat >> confdefs.h <<\EOF
19646 #define HAVE_LC_MESSAGES 1
19647 EOF
19648
19649     fi
19650
19651 else
19652   echo "$ac_t""no" 1>&6
19653 fi
19654
19655
19656
19657 if test "${multilib}" = "yes"; then
19658   multilib_arg="--enable-multilib"
19659 else
19660   multilib_arg=
19661 fi
19662
19663
19664 # Generate the various Makefiles, include files, and scripts.
19665
19666 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
19667 # Needed so that g++ can find the correct include subdir automatically.
19668 INTERFACE=v3
19669
19670 # Check for the interface version number for specifying where header
19671 # files are installed, if a version number is provided.
19672 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
19673 echo "configure:19674: checking for interface version number" >&5
19674 libstdcxx_interface=$INTERFACE
19675 echo "$ac_t""$libstdcxx_interface" 1>&6
19676
19677
19678 # Process the option --with-gxx-include-dir=<path to include-files directory>
19679 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
19680 echo "configure:19681: checking for --with-gxx-include-dir" >&5
19681 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
19682 if test "${with_gxx_include_dir+set}" = set; then
19683   withval="$with_gxx_include_dir"
19684   case "${withval}" in
19685   yes)
19686     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
19687     gxx_include_dir=no
19688     ;;
19689   no)
19690     gxx_include_dir=no
19691     ;;
19692   *)
19693     gxx_include_dir=${withval}
19694     ;;
19695 esac
19696 else
19697   gxx_include_dir=no
19698 fi
19699
19700 echo "$ac_t""$gxx_include_dir" 1>&6
19701
19702
19703
19704 if test x${gxx_include_dir} != xno; then
19705   GXX_INCLUDE_DIR_TRUE=
19706   GXX_INCLUDE_DIR_FALSE='#'
19707 else
19708   GXX_INCLUDE_DIR_TRUE='#'
19709   GXX_INCLUDE_DIR_FALSE=
19710 fi
19711
19712 # Process the option "--enable-version-specific-runtime-libs"
19713 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
19714 echo "configure:19715: checking for --enable-version-specific-runtime-libs" >&5
19715 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
19716 if test "${enable_version_specific_runtime_libs+set}" = set; then
19717   enableval="$enable_version_specific_runtime_libs"
19718     version_specific_libs=yes
19719 # Need the gcc compiler version to know where to install libraries
19720 # and header files if --enable-version-specific-runtime-libs option
19721 # is selected.
19722 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
19723 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
19724 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
19725 #gcc_version=$gcc_num-$gcc_date
19726 gcc_version=$gcc_num
19727
19728
19729 else
19730   version_specific_libs=no
19731 fi
19732
19733 echo "$ac_t""$version_specific_libs" 1>&6
19734 if test x${version_specific_libs} = xyes; then
19735
19736
19737 if test x${version_specific_libs} = xyes; then
19738   VERSION_SPECIFIC_LIBS_TRUE=
19739   VERSION_SPECIFIC_LIBS_FALSE='#'
19740 else
19741   VERSION_SPECIFIC_LIBS_TRUE='#'
19742   VERSION_SPECIFIC_LIBS_FALSE=
19743 fi
19744   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
19745 fi
19746
19747 # We have to install all the generated or linked includes files
19748 # specified as build_headers in src/Makefile.am in a target-dependent
19749 # place, or else multiple installs for different compilers will
19750 # overwrite these files.
19751 # NB: Keep this and gcc/Makefile.in's -DGPLUSPLUS_TOOL_INCLUDE_DIR in sync.
19752 gxx_target_include_dir='$(exec_prefix)/$(target_alias)/include/g++-$(libstdcxx_interface)'
19753
19754
19755
19756 # Export all the include and flag information to makefiles.
19757
19758   # Root level of the include sources.
19759   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
19760
19761   # Can either use include/c or include/c_std to grab "C" headers. This
19762   # variable is set to the include directory currently in use.
19763   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_CHEADERS
19764
19765   # Passed down for canadian crosses.
19766   if  test x"$CANADIAN" = xyes; then
19767     TOPLEVEL_INCLUDES='-I$(includedir)'
19768   fi
19769
19770   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
19771
19772   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
19773
19774   #if GLIBCPP_NEED_LIBIO
19775   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
19776   #else
19777   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
19778   #endif
19779
19780   #if GLIBCPP_USE_CSHADOW
19781   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
19782   #                   -I$(top_blddir)/cshadow'
19783   #else
19784   CSTD_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
19785   #endif
19786
19787   # Now, export this to all the little Makefiles....
19788
19789
19790
19791
19792
19793
19794
19795
19796   # Optimization flags that are probably a good idea for thrill-seekers. Just
19797   # uncomment the lines below and make, everything else is ready to go...
19798   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
19799   OPTIMIZE_CXXFLAGS=
19800
19801
19802   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
19803
19804
19805
19806 # This should be done by mkincludedir, but hack around it now.
19807 blddir=`pwd`
19808 echo "checking for $blddir/include"
19809
19810 if test ! -d "$blddir/include"; then
19811   mkdir "$blddir/include"
19812 fi
19813
19814 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
19815 # so that multilib installs will end up installed in the correct
19816 # place. To work around this not being passed down from config-ml.in
19817 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
19818 # append it here.
19819 trap '' 1 2 15
19820 cat > confcache <<\EOF
19821 # This file is a shell script that caches the results of configure
19822 # tests run on this system so they can be shared between configure
19823 # scripts and configure runs.  It is not useful on other systems.
19824 # If it contains results you don't want to keep, you may remove or edit it.
19825 #
19826 # By default, configure uses ./config.cache as the cache file,
19827 # creating it if it does not exist already.  You can give configure
19828 # the --cache-file=FILE option to use a different cache file; that is
19829 # what configure does when it calls configure scripts in
19830 # subdirectories, so they share the cache.
19831 # Giving --cache-file=/dev/null disables caching, for debugging configure.
19832 # config.status only pays attention to the cache file if you give it the
19833 # --recheck option to rerun configure.
19834 #
19835 EOF
19836 # The following way of writing the cache mishandles newlines in values,
19837 # but we know of no workaround that is simple, portable, and efficient.
19838 # So, don't put newlines in cache variables' values.
19839 # Ultrix sh set writes to stderr and can't be redirected directly,
19840 # and sets the high bit in the cache file unless we assign to the vars.
19841 (set) 2>&1 |
19842   case `(ac_space=' '; set | grep ac_space) 2>&1` in
19843   *ac_space=\ *)
19844     # `set' does not quote correctly, so add quotes (double-quote substitution
19845     # turns \\\\ into \\, and sed turns \\ into \).
19846     sed -n \
19847       -e "s/'/'\\\\''/g" \
19848       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
19849     ;;
19850   *)
19851     # `set' quotes correctly as required by POSIX, so do not add quotes.
19852     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
19853     ;;
19854   esac >> confcache
19855 if cmp -s $cache_file confcache; then
19856   :
19857 else
19858   if test -w $cache_file; then
19859     echo "updating cache $cache_file"
19860     cat confcache > $cache_file
19861   else
19862     echo "not updating unwritable cache $cache_file"
19863   fi
19864 fi
19865 rm -f confcache
19866
19867 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
19868
19869 test "x$prefix" = xNONE && prefix=$ac_default_prefix
19870 # Let make expand exec_prefix.
19871 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
19872
19873 # Any assignment to VPATH causes Sun make to only execute
19874 # the first set of double-colon rules, so remove it if not needed.
19875 # If there is a colon in the path, we need to keep it.
19876 if test "x$srcdir" = x.; then
19877   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
19878 fi
19879
19880 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
19881
19882 DEFS=-DHAVE_CONFIG_H
19883
19884 # Without the "./", some shells look in PATH for config.status.
19885 : ${CONFIG_STATUS=./config.status}
19886
19887 echo creating $CONFIG_STATUS
19888 rm -f $CONFIG_STATUS
19889 cat > $CONFIG_STATUS <<EOF
19890 #! /bin/sh
19891 # Generated automatically by configure.
19892 # Run this file to recreate the current configuration.
19893 # This directory was configured as follows,
19894 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
19895 #
19896 # $0 $ac_configure_args
19897 #
19898 # Compiler output produced by configure, useful for debugging
19899 # configure, is in ./config.log if it exists.
19900
19901 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
19902 for ac_option
19903 do
19904   case "\$ac_option" in
19905   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
19906     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
19907     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
19908   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
19909     echo "$CONFIG_STATUS generated by autoconf version 2.13"
19910     exit 0 ;;
19911   -help | --help | --hel | --he | --h)
19912     echo "\$ac_cs_usage"; exit 0 ;;
19913   *) echo "\$ac_cs_usage"; exit 1 ;;
19914   esac
19915 done
19916
19917 ac_given_srcdir=$srcdir
19918 ac_given_INSTALL="$INSTALL"
19919
19920 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
19921 EOF
19922 cat >> $CONFIG_STATUS <<EOF
19923
19924 # Protect against being on the right side of a sed subst in config.status.
19925 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
19926  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
19927 $ac_vpsub
19928 $extrasub
19929 s%@SHELL@%$SHELL%g
19930 s%@CFLAGS@%$CFLAGS%g
19931 s%@CPPFLAGS@%$CPPFLAGS%g
19932 s%@CXXFLAGS@%$CXXFLAGS%g
19933 s%@FFLAGS@%$FFLAGS%g
19934 s%@DEFS@%$DEFS%g
19935 s%@LDFLAGS@%$LDFLAGS%g
19936 s%@LIBS@%$LIBS%g
19937 s%@exec_prefix@%$exec_prefix%g
19938 s%@prefix@%$prefix%g
19939 s%@program_transform_name@%$program_transform_name%g
19940 s%@bindir@%$bindir%g
19941 s%@sbindir@%$sbindir%g
19942 s%@libexecdir@%$libexecdir%g
19943 s%@datadir@%$datadir%g
19944 s%@sysconfdir@%$sysconfdir%g
19945 s%@sharedstatedir@%$sharedstatedir%g
19946 s%@localstatedir@%$localstatedir%g
19947 s%@libdir@%$libdir%g
19948 s%@includedir@%$includedir%g
19949 s%@oldincludedir@%$oldincludedir%g
19950 s%@infodir@%$infodir%g
19951 s%@mandir@%$mandir%g
19952 s%@host@%$host%g
19953 s%@host_alias@%$host_alias%g
19954 s%@host_cpu@%$host_cpu%g
19955 s%@host_vendor@%$host_vendor%g
19956 s%@host_os@%$host_os%g
19957 s%@target@%$target%g
19958 s%@target_alias@%$target_alias%g
19959 s%@target_cpu@%$target_cpu%g
19960 s%@target_vendor@%$target_vendor%g
19961 s%@target_os@%$target_os%g
19962 s%@build@%$build%g
19963 s%@build_alias@%$build_alias%g
19964 s%@build_cpu@%$build_cpu%g
19965 s%@build_vendor@%$build_vendor%g
19966 s%@build_os@%$build_os%g
19967 s%@glibcpp_basedir@%$glibcpp_basedir%g
19968 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
19969 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
19970 s%@INSTALL_DATA@%$INSTALL_DATA%g
19971 s%@PACKAGE@%$PACKAGE%g
19972 s%@VERSION@%$VERSION%g
19973 s%@ACLOCAL@%$ACLOCAL%g
19974 s%@AUTOCONF@%$AUTOCONF%g
19975 s%@AUTOMAKE@%$AUTOMAKE%g
19976 s%@AUTOHEADER@%$AUTOHEADER%g
19977 s%@MAKEINFO@%$MAKEINFO%g
19978 s%@SET_MAKE@%$SET_MAKE%g
19979 s%@CC@%$CC%g
19980 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
19981 s%@CXX@%$CXX%g
19982 s%@AS@%$AS%g
19983 s%@AR@%$AR%g
19984 s%@RANLIB@%$RANLIB%g
19985 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
19986 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
19987 s%@MAINT@%$MAINT%g
19988 s%@EXEEXT@%$EXEEXT%g
19989 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
19990 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
19991 s%@LN_S@%$LN_S%g
19992 s%@OBJEXT@%$OBJEXT%g
19993 s%@STRIP@%$STRIP%g
19994 s%@LIBTOOL@%$LIBTOOL%g
19995 s%@CXXCPP@%$CXXCPP%g
19996 s%@enable_shared@%$enable_shared%g
19997 s%@enable_static@%$enable_static%g
19998 s%@ifGNUmake@%$ifGNUmake%g
19999 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
20000 s%@CPP@%$CPP%g
20001 s%@GLIBCPP_BUILD_LIBIO_TRUE@%$GLIBCPP_BUILD_LIBIO_TRUE%g
20002 s%@GLIBCPP_BUILD_LIBIO_FALSE@%$GLIBCPP_BUILD_LIBIO_FALSE%g
20003 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
20004 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
20005 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
20006 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
20007 s%@libio_la@%$libio_la%g
20008 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
20009 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
20010 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
20011 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
20012 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
20013 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
20014 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
20015 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
20016 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
20017 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
20018 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
20019 s%@libinst_wstring_la@%$libinst_wstring_la%g
20020 s%@WERROR@%$WERROR%g
20021 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
20022 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
20023 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
20024 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
20025 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
20026 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
20027 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
20028 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
20029 s%@libstdcxx_interface@%$libstdcxx_interface%g
20030 s%@gxx_include_dir@%$gxx_include_dir%g
20031 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
20032 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
20033 s%@gcc_version@%$gcc_version%g
20034 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
20035 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
20036 s%@gxx_target_include_dir@%$gxx_target_include_dir%g
20037 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
20038 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
20039 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
20040 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
20041 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
20042 s%@CSTD_INCLUDES@%$CSTD_INCLUDES%g
20043 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
20044 s%@WARN_FLAGS@%$WARN_FLAGS%g
20045
20046 CEOF
20047 EOF
20048
20049 cat >> $CONFIG_STATUS <<\EOF
20050
20051 # Split the substitutions into bite-sized pieces for seds with
20052 # small command number limits, like on Digital OSF/1 and HP-UX.
20053 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
20054 ac_file=1 # Number of current file.
20055 ac_beg=1 # First line for current file.
20056 ac_end=$ac_max_sed_cmds # Line after last line for current file.
20057 ac_more_lines=:
20058 ac_sed_cmds=""
20059 while $ac_more_lines; do
20060   if test $ac_beg -gt 1; then
20061     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
20062   else
20063     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
20064   fi
20065   if test ! -s conftest.s$ac_file; then
20066     ac_more_lines=false
20067     rm -f conftest.s$ac_file
20068   else
20069     if test -z "$ac_sed_cmds"; then
20070       ac_sed_cmds="sed -f conftest.s$ac_file"
20071     else
20072       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
20073     fi
20074     ac_file=`expr $ac_file + 1`
20075     ac_beg=$ac_end
20076     ac_end=`expr $ac_end + $ac_max_sed_cmds`
20077   fi
20078 done
20079 if test -z "$ac_sed_cmds"; then
20080   ac_sed_cmds=cat
20081 fi
20082 EOF
20083
20084 cat >> $CONFIG_STATUS <<EOF
20085
20086 CONFIG_FILES=\${CONFIG_FILES-"tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
20087 EOF
20088 cat >> $CONFIG_STATUS <<\EOF
20089 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
20090   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20091   case "$ac_file" in
20092   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20093        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20094   *) ac_file_in="${ac_file}.in" ;;
20095   esac
20096
20097   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
20098
20099   # Remove last slash and all that follows it.  Not all systems have dirname.
20100   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20101   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20102     # The file is in a subdirectory.
20103     test ! -d "$ac_dir" && mkdir "$ac_dir"
20104     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
20105     # A "../" for each directory in $ac_dir_suffix.
20106     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
20107   else
20108     ac_dir_suffix= ac_dots=
20109   fi
20110
20111   case "$ac_given_srcdir" in
20112   .)  srcdir=.
20113       if test -z "$ac_dots"; then top_srcdir=.
20114       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
20115   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
20116   *) # Relative path.
20117     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
20118     top_srcdir="$ac_dots$ac_given_srcdir" ;;
20119   esac
20120
20121   case "$ac_given_INSTALL" in
20122   [/$]*) INSTALL="$ac_given_INSTALL" ;;
20123   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
20124   esac
20125
20126   echo creating "$ac_file"
20127   rm -f "$ac_file"
20128   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
20129   case "$ac_file" in
20130   *Makefile*) ac_comsub="1i\\
20131 # $configure_input" ;;
20132   *) ac_comsub= ;;
20133   esac
20134
20135   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20136   sed -e "$ac_comsub
20137 s%@configure_input@%$configure_input%g
20138 s%@srcdir@%$srcdir%g
20139 s%@top_srcdir@%$top_srcdir%g
20140 s%@INSTALL@%$INSTALL%g
20141 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
20142 fi; done
20143 rm -f conftest.s*
20144
20145 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
20146 # NAME is the cpp macro being defined and VALUE is the value it is being given.
20147 #
20148 # ac_d sets the value in "#define NAME VALUE" lines.
20149 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
20150 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
20151 ac_dC='\3'
20152 ac_dD='%g'
20153 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
20154 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20155 ac_uB='\([      ]\)%\1#\2define\3'
20156 ac_uC=' '
20157 ac_uD='\4%g'
20158 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
20159 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20160 ac_eB='$%\1#\2define\3'
20161 ac_eC=' '
20162 ac_eD='%g'
20163
20164 if test "${CONFIG_HEADERS+set}" != set; then
20165 EOF
20166 cat >> $CONFIG_STATUS <<EOF
20167   CONFIG_HEADERS="config.h"
20168 EOF
20169 cat >> $CONFIG_STATUS <<\EOF
20170 fi
20171 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
20172   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20173   case "$ac_file" in
20174   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20175        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20176   *) ac_file_in="${ac_file}.in" ;;
20177   esac
20178
20179   echo creating $ac_file
20180
20181   rm -f conftest.frag conftest.in conftest.out
20182   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20183   cat $ac_file_inputs > conftest.in
20184
20185 EOF
20186
20187 # Transform confdefs.h into a sed script conftest.vals that substitutes
20188 # the proper values into config.h.in to produce config.h.  And first:
20189 # Protect against being on the right side of a sed subst in config.status.
20190 # Protect against being in an unquoted here document in config.status.
20191 rm -f conftest.vals
20192 cat > conftest.hdr <<\EOF
20193 s/[\\&%]/\\&/g
20194 s%[\\$`]%\\&%g
20195 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
20196 s%ac_d%ac_u%gp
20197 s%ac_u%ac_e%gp
20198 EOF
20199 sed -n -f conftest.hdr confdefs.h > conftest.vals
20200 rm -f conftest.hdr
20201
20202 # This sed command replaces #undef with comments.  This is necessary, for
20203 # example, in the case of _POSIX_SOURCE, which is predefined and required
20204 # on some systems where configure will not decide to define it.
20205 cat >> conftest.vals <<\EOF
20206 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
20207 EOF
20208
20209 # Break up conftest.vals because some shells have a limit on
20210 # the size of here documents, and old seds have small limits too.
20211
20212 rm -f conftest.tail
20213 while :
20214 do
20215   ac_lines=`grep -c . conftest.vals`
20216   # grep -c gives empty output for an empty file on some AIX systems.
20217   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
20218   # Write a limited-size here document to conftest.frag.
20219   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
20220   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
20221   echo 'CEOF
20222   sed -f conftest.frag conftest.in > conftest.out
20223   rm -f conftest.in
20224   mv conftest.out conftest.in
20225 ' >> $CONFIG_STATUS
20226   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
20227   rm -f conftest.vals
20228   mv conftest.tail conftest.vals
20229 done
20230 rm -f conftest.vals
20231
20232 cat >> $CONFIG_STATUS <<\EOF
20233   rm -f conftest.frag conftest.h
20234   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
20235   cat conftest.in >> conftest.h
20236   rm -f conftest.in
20237   if cmp -s $ac_file conftest.h 2>/dev/null; then
20238     echo "$ac_file is unchanged"
20239     rm -f conftest.h
20240   else
20241     # Remove last slash and all that follows it.  Not all systems have dirname.
20242       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20243       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20244       # The file is in a subdirectory.
20245       test ! -d "$ac_dir" && mkdir "$ac_dir"
20246     fi
20247     rm -f $ac_file
20248     mv conftest.h $ac_file
20249   fi
20250 fi; done
20251
20252 EOF
20253
20254 cat >> $CONFIG_STATUS <<EOF
20255 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"
20256 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 \
20257 include/bits/ctype_base.h \
20258 include/bits/ctype_inline.h \
20259 include/bits/ctype_noninline.h"
20260 EOF
20261
20262 cat >> $CONFIG_STATUS <<\EOF
20263 srcdir=$ac_given_srcdir
20264 while test -n "$ac_sources"; do
20265   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
20266   set $ac_sources; ac_source=$1; shift; ac_sources=$*
20267
20268   echo "linking $srcdir/$ac_source to $ac_dest"
20269
20270   if test ! -r $srcdir/$ac_source; then
20271     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
20272   fi
20273   rm -f $ac_dest
20274
20275   # Make relative symlinks.
20276   # Remove last slash and all that follows it.  Not all systems have dirname.
20277   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
20278   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
20279     # The dest file is in a subdirectory.
20280     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
20281     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
20282     # A "../" for each directory in $ac_dest_dir_suffix.
20283     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
20284   else
20285     ac_dest_dir_suffix= ac_dots=
20286   fi
20287
20288   case "$srcdir" in
20289   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
20290   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
20291   esac
20292
20293   # Make a symlink if possible; otherwise try a hard link.
20294   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
20295     ln $srcdir/$ac_source $ac_dest; then :
20296   else
20297     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
20298   fi
20299 done
20300 EOF
20301 cat >> $CONFIG_STATUS <<EOF
20302
20303 srcdir=${srcdir}
20304 host=${host}
20305 target=${target}
20306 with_multisubdir=${with_multisubdir}
20307 ac_configure_args="${multilib_arg} ${ac_configure_args}"
20308 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
20309 glibcpp_basedir=${glibcpp_basedir}
20310 CC="${CC}"
20311 CXX="${CXX}"
20312
20313 EOF
20314 cat >> $CONFIG_STATUS <<\EOF
20315 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
20316 if test -n "$CONFIG_FILES"; then
20317   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
20318   grep '^MULTISUBDIR =' Makefile >> src/Makefile
20319 fi
20320 chmod +x tests_flags
20321 chmod +x mkcheck
20322
20323 exit 0
20324 EOF
20325 chmod +x $CONFIG_STATUS
20326 rm -fr confdefs* $ac_clean_files
20327 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
20328
20329
20330
20331 # Generate bits/c++config.h
20332 # NB: This must be the first generated file as others include it. . .
20333 $srcdir/mkc++config $blddir $srcdir
20334
20335 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
20336 if test ! -f stamp-limits; then
20337   $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
20338   if test ! -f include/bits/std_limits.h; then
20339     echo "mknumeric_limits failed to execute properly: exiting"
20340     exit 1
20341   else
20342     touch stamp-limits
20343   fi
20344 fi
20345
20346
20347 # Sanity checking & User-visible messages.
20348 # Checks down here, otherwise they get scrolled off before
20349 # the user will notice.
20350
20351 # Trying to get more people to read documentation.  Possibly remove
20352 # check and warn all the time. There is no "informational" AC_MSG_
20353 # macro, so these are going to be printed even when --quiet/--silent
20354 # is given.
20355 if test ! -f stamp-sanity-warned; then
20356   touch stamp-sanity-warned
20357   echo ""
20358   echo "Please make certain that you read the installation information here:"
20359   echo "  faster => ${srcdir}/docs/install.html"
20360   echo "  slower => <URL:http://gcc.gnu.org/onlinedocs/libstdc++/install.html>"
20361   echo ""
20362   echo "and the configuration information here:"
20363   echo "  faster => ${srcdir}/docs/configopts.html"
20364   echo "  slower => <URL:http://gcc.gnu.org/onlinedocs/libstdc++/configopts.html>"
20365   echo ""
20366   echo "before proceeding with ${_cv_gnu_make_command}."
20367   echo ""
20368 fi